Skip to content

v0.0.2-alpha.74

Pre-release
Pre-release

Choose a tag to compare

@mobeenabdullah mobeenabdullah released this 11 Nov 03:15
· 3243 commits to dev since this release
5aaa9fd

Released 21 packages at 0.0.2-alpha.74 in lockstep. Every package below ships at this version.

What's changed

Patch Changes

  • #3728 0beb16e Thanks @nextly-agent! - A page binding that follows a relation into the media library, such as an image's alt text bound to featuredImage.altText, now shows that media item's field. The page's read-ahead reads the item through the media library, as the page's images are read, where before it asked for media as a collection, failed the read and showed the fallback. BindingSourcesArgs in @nextlyhq/blocks-react/next gains an optional media reader; without one, such a binding still shows its fallback.

  • #3616 0dc0951 Thanks @nextly-agent! - A block gets a "Show when" group in its Content tab, under "Visible on": one group of conditions, each a field, an operator and a value, edited as a list's filters are. Only fields visitors can see are offered. A block inside a collection list checks the list's item, and every other block the entry the page shows. A condition the page can't check says so, since visitors then never see the block, and groups set through the API are shown as they read, with a way to keep the first. The page actions API gains set-conditions, which sets or removes a block's conditions with the same checks as the editor's save.

  • #3312 23e8831 Thanks @nextly-agent! - A blocks field inside a field group was saved without the composition checks
    the same field gets on the page itself. The field group's write had no access
    to the component library, so a page could place a component past the depth
    limit through a field group and have it stored. A field group's blocks field is
    now judged with the write it belongs to, on that write's connection, for a
    collection entry and a single alike, repeatable field groups included.

    Locks in such a field are measured against the blocks a slot starts with
    alone. A field group's value has no stored copy of its own to compare with,
    and reading one by the page's id and the field's name would read the page's
    own field of the same name. So a stored
    field-group value whose "contentOnly" child kept an older value (an earlier
    default, say) is refused on its next save. Put that child back as the block
    now starts, and the save goes through.

  • #3333 9c6c948 Thanks @nextly-agent! - A blocks field inside a named group (hero.body) can be saved again when the page
    already stores a "contentOnly" value or a placement break it keeps. Its stored value
    was refused as "not a top-level field", which failed the save. A plugin field
    validator's write.readStored now reads a field inside named groups by its path.

  • #3583 369155b Thanks @nextly-agent! - Block visibility conditions now have a closed operator vocabulary and an evaluator in the blocks engine. A condition uses equals, not_equals, contains, not_contains, greater_than, less_than, exists, not_exists, is_true or is_false on one field of the entry, or of the list item for a block inside a list. The older spellings eq, ne, neq, gt and lt are read as the operators they name, and canonicalConditions rewrites them for storage. evaluateConditions decides whether a block is shown. It reads only the fields the public may read, and it hides and reports any condition it cannot check: an unknown operator or field, a protected field, or a value of the wrong type. Saving a page now refuses an unknown operator, and, when the schema is known, a field that is missing or protected and an operator or value that does not fit the field. A problem the stored page already held is reported as a warning, so existing pages stay savable. The renderer still leaves every conditioned block out of the page until it starts asking the evaluator.

  • #3643 550f90d Thanks @nextly-agent! - The page builder's "Visitors won't see this" mark now also covers a bound path into a related collection the public may read none of, such as author.email where users has no public field. Before, the canvas showed the author's value with no mark, while the published page showed the fallback. A badge near the canvas's left edge now stays wholly in view, as one near the right edge already did.

  • #3823 07cb43b Thanks @mobeenabdullah! - The count of what removing a breakpoint would drop no longer asks a second time for saved page titles after that read has run out of time. On a busy server its timer could fire a moment before the clock reached the deadline, so the locked-blocks list started a second read of the same titles after the first had been given up on.

  • #3563 82e2e22 Thanks @nextly-agent! - Settings no longer reports a breakpoint removal as done when it could not read the removal's status: it reads it again and keeps following the removal until it can. A removal found opened again at its end keeps being followed. The removal Settings makes at once (nothing was stored under the breakpoint) can no longer be cancelled once its save is out. An open Site tab now notices, within about ten seconds, a removal started from another tab, and holds editing the breakpoints while it runs.

  • #3566 f2d2cfb Thanks @nextly-agent! - A confirmed breakpoint removal now keeps what it takes out of the site, so it can be undone: every stored value it strips (a page's live row or working draft, a component, a pattern, a Layout, an entry) has a row in the page builder's new breakpoint_removal_fragments table holding the styles and hides it lost, written before the strip itself, and the shared styles have one for what the set's write took out of them. A strip whose row cannot be written is not made. Rows are deleted by the removal job 30 days after they were kept. Existing installs apply the new table with nextly migrate before deploying (the page builder's schema version is now 6).

  • #3610 72007d1 Thanks @nextly-agent! - An undo of a breakpoint removal now leaves the removal's claims on its breakpoints in place until its own set has been stored, so an undo refused by another save no longer lets pages the removal left (a pending draft) bring those breakpoints back early. An undo whose write cannot be confirmed stays preparing until its recorded set is seen stored, and is never walked unverified. What an undo could not put back counts each value once, however often the removal stripped it, and the values of a code-supplied shared style removed from the code since are reported as gone with it rather than as put back.

  • #3651 1f93392 Thanks @nextly-agent! - Saving a document now checks its bindings against the declared fields of what they read, and refuses a binding to a prop the block does not have, a field the source does not have, a field whose type does not fit the prop, an invalid format or an invalid fallback. A binding a schema change broke after the document was saved is kept, so the document still saves. nextly/runtime gains declaredFieldShapes and @nextlyhq/blocks-engine gains bindingSchemaIssues, both experimental.

  • #3416 bdd9024 Thanks @nextly-agent! - The inspector names three more choices the way an author thinks of them. A
    button's "type" is now "Acts as", and it is offered only while the button has
    no link, to a URL a page can follow or to an entry, since a link is then what
    the button does. A component can still expose it, for pages that clear the
    link. A container's tag is now
    "HTML tag", each option named in words ("Generic box", "Main content") with
    the tag itself shown muted beside it, and the row is hidden where a block has
    only one tag to offer, unless what is stored is another one. A component
    field exposing a choice now offers it in the block's words too, read through
    optionLabel, which @nextlyhq/blocks-engine now exports. "Visible on" draws its three devices as separate
    toggles with a dot on the device being edited.

  • #3738 7d50d9d Thanks @nextly-agent! - A public route answering a read the public is refused (an entry, a list or a Single it may not read) from the cache no longer fails to prerender under Cache Components with an error about reading the current time. cachedFind keeps the refusal and throws it again on every read of the entry; it now rebuilds that NextlyError without reading the clock. Its timestamp is the time the refusal was first made, kept with the cached entry, so logging or serializing the error reads no clock either, and its stack shows where it was thrown again. The thrown error is otherwise the same: its class, code, status, messages and data are unchanged. Cached refusals are now filed under a new key, so entries cached by an earlier version are read afresh once.

  • #3743 2ca423d Thanks @nextly-agent! - A library image chosen as an image binding's Fallback is named readably: the library button sits inside the chosen file's box, and a long file name in that row is cut in its middle with its extension kept. On the picker's tiles a name keeps its start and is cut at its end. The picker's search reads "Find an image, or paste an address".

  • #3406 ac6ba5e Thanks @nextly-agent! - On a page the site serves, a click on the site's own page around the canvas, such as below a short page, now clears the selection, as a click on the canvas's own background does. The site's layout decides how tall the canvas is there, so the canvas can end at its last block, and the click an author makes below it to let go of a block used to do nothing.

  • #3551 7b7e00f Thanks @nextly-agent! - A collection list can now filter, sort and window its entries, and show a related list. Filter rows (is, is not, more or less than, contains, any of, none of, has a value) narrow the entries, several sort keys order them with empty values last and ties in a stable order, and a limit of 1 to 100 and an offset skip and cut them. A list can show a to-many relation of the page's entry or of the outer list's item, in the order the relation stores them unless a sort is set; a sorted relation of more than 100 entries is read in parts and kept in the database's order. A date filter compares whole days in the site's time zone, inside a component too. When nothing matches, or the read fails, the list draws its own empty state, and an author previewing a draft is told why. Saving refuses an out-of-range limit or offset, a filter or sort on a field the collection lacks or visitors cannot see, a filter on a field holding several values, a filter whose operator or value its field's kind does not take (an order on text, a day on a number), and a related list nested more than one level deep. The page actions API gains set-list-query, judged by the same checks. A list stored before this renders as it did; one whose sort names a removed or hidden field lists in id order. In the Page Builder, the block is now named Collection list (its stored type stays core/collection-loop, so saved pages are unchanged), and its Content tab edits all of this: Source (a collection, or the page entry's or each outer item's related entries), Filters as one sentence per row that opens into its field, operator and value, Sort rows with a drag handle, Alt+↑ and Alt+↓ and each direction in words (Newest first, A–Z, Highest first), Number of items and Skip the first, and Canvas shows: Entries or When empty. Under Number of items the selected list says how many entries match and how many show ("4 entries match, so 3 show."), taken from the list's own read on the canvas. Only fields visitors can see are offered. The canvas draws each list with the entries a visitor would see, in the language being edited and within a published page's read allowance, tags a list showing its empty state, and says when its sort fell back or its read failed; a fallen-back sort's note has a Choose a field button that takes the author to the sort. A save's refusal names the collection as authors read it ("which Posts doesn't have"). Layers shows a list's Each entry and When empty regions.

  • #3576 0473854 Thanks @mobeenabdullah! - A collection list's query is now judged at save exactly as the page draws it and the editor offers it.

    • A list inside another list's "When empty" state shows the related entries of the item around that list, never of an entry the outer list did not find. The editor's Source menu offers the same.
    • A list of "this entry's" related entries is refused on a Single, whose page has no entry, and the editor says so.
    • A list's fields are judged in the language being saved, and the editor offers the fields visitors can see in the language being edited.
    • A filter or sort on a field the editor never offers is refused: a time of day, rich text or media, or a sort on a related entry.
    • A filter on a number field compares with a number, on every operator.
    • A list inside a placed component is judged as the page composes it, so a placement's value or variant cannot give it a sort or filter no list takes, or one on a field visitors can't see.
    • A component save is refused when it would break a list on a page placing it, such as by aiming a page's value at the list's sort. The server log names each page.
    • A list sorts by at most 20 fields, in at most 2,000 characters (LIST_MAX_SORT_KEYS and LIST_MAX_SORT_LENGTH in @nextlyhq/blocks-engine). The save, the canvas's read of a list's entries and the editor's Add sort all hold it to that.

    Pages already stored keep saving: a problem a stored page already had stays a warning.

  • #3605 0b82117 Thanks @mobeenabdullah! - A collection list is judged the same way in the editor and at save in more cases, and a Layout's header no longer has its badge drawn over its links.

    • The editor gives a list's fields the kind a save gives them, so it refuses a sort on a time of day and takes a filter on a field type a plugin adds, as the save does.
    • A component's list of "this entry's" related entries is judged by its shape when the component is saved, since the entries are those of the pages placing it. Before, the save judged it against the component store and refused a list that works on those pages.
    • A save no longer refuses a list problem when the stored page can't be read, or when the stored page's components can only be composed in part: the problem may be one the page already had. The server log says when a placed component's list problem was kept this way.
    • Checking a page's lists reads the fields of no more lists than the check visits.
    • On the canvas, a Layout region's lock sits outside the region, below a header and above a footer, so it never covers the region's content. Hover or focus shows "Header · from Layout"; a click, Enter or Space opens the tag with Edit Layout beside it. The lock is the region's one focus stop. Escape, a click elsewhere or a new selection closes the tag. Where outside has no room on screen, the lock is drawn inside, and at 100% it stays in the part of the canvas on screen.
  • #3202 a95deda Thanks @zeshan-rx! - A Schema Builder save of a collection now changes the database in development through the same schema apply as the schema dialog, under the schema lock. What changes for a save:

    • The lock. A save while nextly migrate, db:sync, a rename or another schema change holds the schema lock is refused with nothing written. A save that only changes labels or admin options never creates the lock's table where it is missing, since that is itself a schema change. The schema dialog's apply now takes the same lock, so it too is refused, with nothing written, while another schema change or a migration holds it.
    • The whole database. The save compares every table the Builder owns with what was recorded for it, as the dialog does. A table changed outside the Builder refuses the save, naming that table and the step that brings it in step.
    • MySQL failures. A statement MySQL refuses part-way through a save is reported as NEXTLY_MIGRATION_APPLY_FAILED with the database's own message, rather than "The database refused statement N of M of this schema change". MySQL keeps the statements that ran before it; saving again finishes the change from what the database holds. A failed apply from the schema dialog now carries the same code and message rather than a generic error.
    • Filling a Required field added over existing rows. The rows get the field's default where it has one, and otherwise its type's empty value, written as a bound value rather than spliced into the statement. A date or date-time field takes the moment of the save, read once for every row, rather than the database's own clock. A plugin field type takes the empty value its plugin declares. The column keeps no default afterwards.
    • Unique turned off drops the single-column unique index the field had, including one adopted from an earlier install.
    • An index name already taken by another index on the table refuses the save before anything changes, naming that index, rather than leaving the field recorded unique with nothing enforcing it.
    • SQLite. A table rebuild a failed save left part-way (a __new_<table> beside or instead of the table) is finished or undone before the next save.
    • MySQL indexes on long text. An index added to an existing table on a TEXT column is keyed by its first 191 characters, as a new table's indexes already were, so MySQL accepts it. This applies to the schema dialog and to migrate:create files too.
    • Many-to-many junctions on MySQL are created with their indexes inside the one CREATE TABLE IF NOT EXISTS, so a junction lands whole and a save retried after a part-way failure passes over it. Names are unchanged.
    • A column added outside the Builder is no longer dropped when a save adds a field it could be mistaken for: the save is refused instead.
    • Schema version. A save moves the collection's schema version on, so a schema dialog open beside it sees the change.

    Production is unchanged: a save writes the migration file and runs nothing. On SQLite, that file still does not make a field leaving translation NOT NULL when it is Required or Unique, although the database in development does. A save's migration file stays one combined file with no localization intent header, so history inference and nextly migrate's header-keyed checks don't read it.

  • #3317 72f9277 Thanks @nextly-agent! - The page builder refuses unpublishing a component that a Layout uses, as it already refused deleting one, and the refusal names the Layout. Unpublishing it would take it off every page drawn inside that Layout.

  • #3606 b13a66d Thanks @nextly-agent! - A component delete's rewrite now asks the person who started it only for what their own save would need. Each copy is written as that person, under every rule their update meets (update access to the entry or Single, the field's update rules, and the publish permission where the write publishes), and what the write expects to find is judged as the system that read it. A starter who may update a page but not read it, or whose field read rule closes the blocks field to them, no longer has the rewrite refused or stopped; one who may not update it is still refused.

    The rewrite also no longer saves a page's live content as a draft when the author discards the draft while the page is being read: the page is read again and written as it now stands. The same holds when the draft is published and a new one saved between the two reads: the row's version is compared across them.

    updateIfUnchanged (@experimental) takes a new identity, { caller, checkedBy: { overrideAccess: true } } (PluginSystemCheckedWrite, in PluginConditionalWriteIdentity), for a write whose expectation the system read: the update is the caller's and the expectation's read is the system's. Made as a caller alone, it still refuses a field they may not read, so nobody learns whether a value they supplied matches one.

    A person's conditional write is now refused with FORBIDDEN, writing nothing, when what it would persist, after every hook, does not hold each field it writes exactly as sent, or the field-access pass took one out (a field update rule refusing it, or a hook changing or putting back its value). An ordinary update drops such a field silently and writes the rest, so a conditional write could have been reported as made while its field never changed. A component delete's rewrite reports such a document as not permitted.

  • #3260 f48b906 Thanks @nextly-agent! - A designer exposes a component's fields in the component's own Page Builder
    view.

    Each property of a block inside the component has an "Expose to placements"
    switch and a name, and each block a "Let placements hide this" switch. With
    nothing selected, the inspector lists the component's exposed fields and slots
    to rename or remove. A removal asks first, naming every variant that loses a
    value. A property placements could not set, or one inside an area locked to its
    content, is refused with the reason.

    The engine gains an envelope op, so an exposure edit is one undo step like any
    other edit. BuilderOp (published by @nextlyhq/blocks-engine and re-exported by
    @nextlyhq/builder) gains this fifth member: code that builds or applies ops is
    unaffected, and an exhaustive switch over op.kind needs a case for
    "envelope" or a default. A new field's id stays clear of every id the component's live
    definition still uses or has retired, read from a new /component-facts
    route, which also counts the documents that place the component directly.

  • #3221 1e7cb13 Thanks @nextly-agent! - Edit an existing component's exposed fields from code. planExposeProperty, planRenameExposure, planRetargetExposure, planRemoveExposure and planRemoveExposedSlot (experimental) expose a block prop or a node's visibility, with its type inferred from the prop, then rename, re-point or remove it. A removed field's id is retired and never minted again. Its value is pruned from every variant in the same edit, and a type change gets a new id. A design prop inside a contentOnly area is refused when it is exposed. stripRetiredExposures takes a removed field's values and a removed slot's content out of any document that places the component. A variant left with no values is now a warning (variant-empty) rather than an error, and shows the component's defaults.

  • #3241 d252df1 Thanks @nextly-agent! - Page builder: a component save that narrows an exposed slot's allowed blocks is refused when a page placing the component already puts an excluded block in that slot, as a page save would refuse it.

  • #3244 ab2ba5d Thanks @nextly-agent! - The page builder remembers the fields a component stops exposing. When a component
    definition that drops an exposed field or slot is published, the field's id is
    retired: it is recorded in a plugin-owned table, never minted again, and every later
    write of a page, a Single or another component takes that field's placement values
    out before validation. A component save also drops its own retired fields from its
    exposed list, its slots and its variants, so restoring an earlier version cannot
    bring a removed field back. A draft save retires nothing: live pages keep the values
    the published definition still shows.

  • #3618 e3f9ea5 Thanks @nextly-agent! - updateIfUnchanged (@experimental) now refuses, with INVALID_INPUT and before anything is written, data naming a key no update stores: a system column no client writes (updatedAt, createdAt and the like), a column a schema hook contributed, or a field stored nowhere. A field group or a many-to-many, which an update stores in their own tables, is taken as before. The check runs in the update itself, once its access is judged and before any hook, so a caller who may not update the document is refused alike whatever the data names. A field kept in its own table is taken under its declared name only. An update drops such a key and writes the rest, so the conditional write would have landed in part while reported as made whole. The version (_rev) and overwrite (_overwrite) keys are still taken.

  • #3511 e099a0f Thanks @faisal-rx! - A deprecated surface now tells its user once per process, through one notice. nextly/deprecation-notice publishes noticeDeprecation (experimental): it names what is deprecated and what replaces it, and optionally the release it is removed in, and says each surface once however many copies of the module a bundle carries. The admin's notice for a sign-in challenge view that posts its own answer with pendingToken now goes through it, with the same words.

    The published deprecation policy changes: a deprecated @public plugin surface now keeps working for at least two minor releases after the one that deprecates it, and is removed only at the next major release after those, rather than after one major version.

  • #3237 1eee856 Thanks @nextly-agent! - A plugin's document view, the Page Builder among them, now fills the entry page's content area at every width. Below the desktop breakpoint the view was the window's height while the admin keeps its mobile header above the content area, so the view ran 56 px past it and the page scrolled underneath. PreviewSplit and PreviewPanes take a fill prop that hands a full-height screen the content area's height while the preview is closed.

  • #3774 738e6f4 Thanks @mobeenabdullah! - On Windows, nextly build --dry-run, nextly migrate:create --dry-run and nextly migrate:baseline --dry-run now name the files they would write with forward slashes, such as src/types/nextly-types.ts, as every other dry run and every other system already did.

  • #3217 462d94b Thanks @aqib-rx! - Duplicating a group or a repeater in the Schema Builder now gives the copy and every field inside it, at any depth, ids of their own. Before, the fields inside the copy kept the originals' ids. Because the Builder edits, deletes and adds by id, renaming or deleting a field inside the copy also renamed or deleted the original's field, and Save then saved the original with that change, so its existing entries stopped reading that field's values. Adding a field inside an inner container of the copy added it to the original too. The copy is now a field of its own all the way down.

  • #3324 d622214 Thanks @nextly-agent! - A plugin field validator inside a field group is handed the write as it was sent, as its own copy: an earlier field group's instance, prepared for storage in place, no longer shows through to a later one's validator, and a Single's publish-all no longer hands it the internal markers of its pending change.

  • #2994 3780014 Thanks @zeshan-rx! - A field moving between translated and shared keeps its values when the latest snapshot was written before snapshots recorded which fields are translated. Every snapshot now says that it records them (translatedFieldsRecorded), so one with no translated table is no longer mistaken for an older one. For an older snapshot, nextly migrate:create reads the translated fields from the localization migration files when they record them. When nothing records them, it refuses a change that could move a field, including a shared field added to a translated entity and turning a whole entity's translation off, names the fields, and writes nothing. The new nextly migrate:create --record-snapshot writes a migration that changes nothing, whose snapshot records the translated fields, so the change can go through after it. Before this, a field leaving translation lost its values, and one joining translation was handled as the whole collection becoming translated.

  • #3534 ea4db68 Thanks @zeshan-rx! - A form submission saved inside a transaction sends its notification email only once that transaction commits. A rolled-back submission sends nothing and records no delivery; a committed one sends and records the email once. Outside a transaction the email is sent at once, as before.

    Collection hooks gain an experimental afterCommit on their context: the effect it is handed waits for the outermost transaction the write runs in to commit, is dropped if it rolls back, and runs at once outside a transaction.

  • #3603 3bc6b24 Thanks @nextly-agent! - A save now refuses a second copy of a visibility condition or a collection list problem that the stored page already held: each stored problem keeps only one current problem as a warning. When the stored page cannot be read, such as a language whose store is not ready, these problems are left unjudged rather than refused. A page that newly places a component stored with a condition operator that conditions do not have is refused, naming the component.

  • #3349 bb8f143 Thanks @nextly-agent! - A held draft edit of a collection entry now judges the blocks fields inside its field-group instances when it is saved, as the draft it is: a composition past the depth limit, a component loop or a loosened lock is refused at the save rather than kept until someone publishes it.

  • #3418 256d09f Thanks @nextly-agent! - A held save of a field-group instance in a document with no languages of its own is judged in the language the save names, as an ordinary save is, rather than in the default.

  • #3499 2177bfa Thanks @faisal-rx! - An editor holding a document is told when someone else changes it, naming who and when, within one heartbeat and before they save. The document lock's claim and renewal accept the version the editor's copy started from (_rev), and answer changed when it moved, with the same rules as a refused save: who and when only to a caller who may read the document. With no unsaved edits the editor loads the current version at once; with edits it offers to load the current version, keeping the edits as a recovery point, or to keep editing. Taking a document back after it changed loads the current version before the form unlocks, and keeps the edits recoverable.

  • #3290 db5abc8 Thanks @nextly-agent! - A block locked in Layers now refuses every change to itself and to everything inside it, at the data layer. applyOp refuses updating a locked block or a block inside one (renaming included), removing or moving a block out of a locked one, and putting a block into one; changing only a block's lock is always allowed. A blocks field's save now judges the write against the stored document as well: a write through the API or by an agent that changes, moves or removes a block locked in what is stored is refused with the code layers-lock-changed, naming the block, unless the same write unlocks it; a locked block, or a block holding one, can't be deleted in the save that unlocks it. A write that sets a blocks field to null while the stored page holds a locked block is refused the same way, judged on the data every before* hook leaves, on Singles and imports too. A block locked inside a component holds on every page that places it: a placement's value for an exposed field, or its content for an exposed slot, that changes it is refused with the same code, naming the block, while a value the page already stores is kept. In nextly, a plugin field type can set validateEmpty: true (experimental) to have its validate handed a value a write empties (null or ""), which otherwise never reaches it. A translated field whose language store is not ready yet, and a blocks field inside a group or repeater, are saved unjudged and logged. The lock stays a convenience anyone who may edit the page can lift, not a permission. @nextlyhq/blocks-engine also exports layersLockBreak, lockedAncestorOf, layersLockChanges and an ApplyOptions type whose layersLocks: "ignore" is for system transforms (experimental). In the editor, every path refuses a locked block, a block holding one and a block inside one before it acts, and says why in one wording: Layers, the canvas drag and drop, the block toolbar and menus, the keyboard and the inspector, where a block inside a locked one is read-only and its rename is withheld. Layers rows and the block toolbar show "Locked" on a locked block and "Locked by" its name on every block inside it. A block the saved page still holds locked can't be deleted until its unlock is saved, and Delete says to save first. In @nextlyhq/builder, lockBlockingMove and lockBlockingDelete now also answer for a block that holds a locked block or sits inside one, and an editor's lockRefusalFor answers for a Layers lock too: its result is now LockRefusalFacts, a union of SlotLockRefusalFacts and LayersLockRefusalFacts, all exported from @nextlyhq/builder/shell. A consumer reading lock, holderType or code narrows first with isLayersLockFacts(facts), also exported there: true for a Layers lock (label, relation, verb), false for a slot lock as before. A block inside a locked one can be locked from the inspector, as from a multiple selection.

  • #3457 77df5f9 Thanks @nextly-agent! - Text decoration is drawn the way an author picks it: None, Underline,
    Strikethrough and Overline as icons, with the line's style, thickness and
    colour in a Style popover, read from and written as the CSS shorthand. A
    value it cannot read keeps the text field. Opacity's label now describes it
    in percent and its field names its unit for a screen reader, and the fit
    help lines speak of any media, not only an image.

  • #3732 7326358 Thanks @nextly-agent! - A link can now point at the entry a to-one relation names. Bind a link's entry to the relation's id, such as author.id, and set its collection to the relation's collection: a post's byline links to its author's page. The id is read from the related entry as visitors read it, so an author they may not read, or one not published, gives no link, and the block keeps its own address. A relation to many entries, or to entries of several collections, is still refused.

  • #3741 b6802ff Thanks @nextly-agent! - Saving a document now refuses a link whose entryId is bound to a related entry's id (for example author.id) while its Linked collection (entryCollection) is not the collection that relation points at, or is not set. Such a link would look the entry up in the wrong collection and silently draw no link. The refusal names both collections and the one to set. A stored page that already held one keeps saving, with a warning. @nextlyhq/blocks-engine gains the issue code binding-entry-collection-mismatch.

  • #3263 a7256b5 Thanks @nextly-agent! - Page builder: clicking a block that draws a link on the canvas, such as a Button or Heading with an address, now selects it and no longer follows the link out of the editor. A middle click opens no tab and Enter on a focused link goes nowhere. A form drawn on the canvas no longer submits.

  • #3751 94a1e48 Thanks @nextly-agent! - A link's picker now offers a related entry ("Author › Link to this entry") only where visitors may read it, and lists one whose collection has no page yet as disabled, saying "No page for yet". A link bound to a related entry is named by its relation ("Author · This post"). Unbinding it keeps the entry's reference, so the link keeps going to the same page whatever its address becomes, and the inspector says so, naming the entry's title where a visitor may read it. The page actions API's unbind answer gains entry for such an unbind, and @nextlyhq/blocks-engine exports ENTRY_LINK_PROPS.

  • #3593 9cae594 Thanks @nextly-agent! - A Collection list can be split into pages, each at its own address: the list on /news shows its first page there and page 2 at /news/page/2, with links to the previous and next pages and the page numbers under its entries. Turn on Split into pages in the list's How many group, or send paginate: true with set-list-query. /page/1 redirects permanently to the list's own address, a page past the last or a number spelled any other way is not found, the stored offset applies once before paging, and each page has its own canonical URL and is pre-rendered on a public route within staticParamsLimit. One list on a page may be split into pages; a second one, one inside another list, a list of related entries and a list in a component or a Layout region are refused at save, naming the reason. The content routes take experimental listPages and mountPath options and pass context.page and context.listPagePath to render and buildMetadata; nextly/runtime and nextly/route-path add the experimental listPageOf, listPageNumber, slugToPath and LIST_PAGE_SEGMENT.

  • #3730 ff038c1 Thanks @nextly-agent! - A list read now expands a related entry the way a read by id does, to the depth asked for. At depth 2 or more, a post's related author comes back with its own upload (an avatar, say) as the media object rather than a bare media id, and with its own relationships expanded to the remaining depth, each related entry still judged by its own collection's access and field rules. The list still reads each related collection once per level, whatever the number of entries. An unset to-many relationship still reads as [] at the top of a list, as before.

  • #3690 60e099d Thanks @nextly-agent! - A binding inside a collection list's entries is now checked against the list's items when the page is saved, as the page's own bindings already were: the entries of the collection the list shows, or the rows of its named query. A binding to a field those items don't have is refused; one a page already held keeps saving. The "Bindings to fix" report lists such bindings too, including after a named query's declared rows change.

  • #3668 8fe7618 Thanks @nextly-agent! - A collection list now reads its entries' relations and links to entries in batches, so what it costs to read no longer grows with its length. A list item's binding through a to-one relation (author.name) now shows the related entry's field. Each image is read once per page render, however often the page draws it. A page past its read limit still renders: a list it could not read draws its empty state, and the server logs one warning naming the page, the limit and the blocks drawn without their data. QueryBudget reports what a render read, by kind, for the editor.

  • #3653 0f89591 Thanks @nextly-agent! - A page whose Collection list could not hold its later pages when the site claimed its existing pages at start-up now waits for them, and holds them once the page in their way is unpublished, moved or deleted; the waiting report lists it at that later page. A list whose split into pages is bound to the entry holds its later pages too. A development reload no longer ends the start-up coordination of page saves before its own pass finishes. mayPaginateList in @nextlyhq/blocks-engine (experimental) answers whether a stored document may page a list.

  • #3461 e496309 Thanks @nextly-agent! - The inspector now offers a collection loop the site's collections as a menu, searchable once there are more than ten, and sorts it by a menu of the chosen collection's fields (dates first) with a direction toggle, instead of asking for a slug and a sort key by hand. An image's loading is now one switch, "Load immediately"; its source is one "Library | URL" choice showing only the chosen side; and its alt text is one "From library | Custom | Decorative" choice, with the library's words shown and a Custom field that grows with its words. Each choice that changes two props is one step to undo. A newly placed image no longer stores an alt of its own (it was placed with alt: "", read as decorative), so a library file picked for it is described by the library's alt text with no extra step; images already on a page are unchanged. A library file picked for an image that still holds its placeholder address replaces that address; an address an author typed is still kept as the file's fallback. Stored values do not change: a loop still stores the slug and the field or -field sort string, further sort keys are kept as stored, and a stored collection, field or image state that fits no option is still shown as it is.

  • #3674 2c85704 Thanks @nextly-agent! - The editor no longer stops drawing a page that places a component whose stored definition is malformed (nodes that are not a list, or an empty entry among them). The canvas hands such a definition on to the renderer, which repairs or refuses it as the published page does.

  • #3247 a380d69 Thanks @nextly-agent! - Page builder: the editor's repair notice now also repairs a page whose blocks sit where the placement rule refuses them, such as a Button inside a linked Card or a block in a slot its container does not declare. Each such block moves, with its id and everything inside it, to just after the nearest container that allows it; no block is removed, the steps are shown before anything changes, and the repair is one edit that undo takes back. Locks are repaired first, and a block with nowhere it may go stays where it is and the notice says so. The notice is now headed "Repair this page". The experimental engine API gains placementRepairRule, a cause on a repair's move step, and remainingPlacements on a repair plan.

  • #3735 fc98d95 Thanks @nextly-agent! - A public blocks page whose image names a media file that no longer exists no longer fails to prerender under Cache Components with an error about reading the current time. The route now reads its images through the same cache as the rest of the page, keeps a missing or refused image as no picture, and tags each read with the media collection and the file's id, so uploading, replacing or deleting the file refreshes the pages that show it.

  • #3650 cae665e Thanks @nextly-agent! - A Collection list whose source is a named query can be split into pages, as a collection list can: page n at <address>/page/n asks the query for the window that starts limit rows further on for each page before it, after the list's offset, the page links are counted from the query's total, and a page past the last is not found. Split into pages is refused at save, in the editor and through set-list-query on a list whose query is not declared with total: true; a page that already held it keeps saving with a warning. A query that stops returning a total draws the list's empty state, and the editor says why, rather than showing a guessed number of pages. A block in a custom source's list whose visibility condition reads the row is judged at save, and decided on the page, against the fields the query's rows declare. The editor's query listing and the composition manifest list a group's own row fields, however deep. A named query whose rows name both a collection and fields is refused at boot, and one drawn where nothing runs named queries no longer shows the item of a list around it.

  • #3734 1390729 Thanks @nextly-agent! - A bound prop inside a list fed by a named query now offers its Format row, as one in a collection's list does. The item's field types come from the query's rows: the fields it declares for rows of its own, or the fields of the collection its rows are entries of.

  • #3599 18ad2ff Thanks @nextly-agent! - A page's address may now hold several segments, such as docs/getting-started/install, so pages can sit beneath one another. Each segment is normalised as a one-segment slug is, and an address with an empty part, a . or .. part, a part with nothing left once normalised, and any address naming a reserved path or longer than 255 characters, is refused at save with the reason on the slug, never rewritten. It is an experimental per-collection option, db: { slugPaths: true }, which the page builder's Pages collection sets: a rule about the stored value only, with no schema change or migration, so every existing one-segment address is kept and other collections still strip /. previewUrlFromTemplate takes an experimental pathFields option naming the fields whose values are such paths: their slashes are kept and each segment encoded, so a nested page's Preview and address name its real address; every other value is encoded whole, as before. A copy of a nested page stays beside it, and the page's Settings say how to nest it.

  • #3627 d07cc3d Thanks @nextly-agent! - A published page now holds its address in the page builder's address store, and a page whose Collection list is split into pages holds that list's later pages too, written in the same transaction as the save. A save that would give two documents one address is refused with a conflict naming the other document (by id where the person saving may not read it): a page published among a paginated page's later pages, or a list split into pages over a published page. Unpublishing or deleting a page frees its address, turning pagination off frees the later pages, and a site upgrading claims its published pages in the background after start-up. In-transaction hook handlers receive an experimental transaction token for the collection service's in-transaction methods, closed once the call settles, and an experimental transactionKey that every call on one transaction shares. A page's address follows the host's pagePreviewPath where it is set. @nextlyhq/plugin-sdk now exports previewUrlFromTemplate and readableTitleText, both experimental, so a plugin fills a path template and reads a title as the core does.

  • #3629 5b53f34 Thanks @nextly-agent! - A published page reads only what its visibility conditions need. A list whose item conditions order a number, or match text or a yes-or-no, no longer reads the site settings for a time zone it doesn't use, so it keeps its share of the page's query budget. Page metadata counts the entry read a page's conditions make, so under a tight budget it describes the page the visitor gets. A Single's page has no entry for conditions to read, as the editor and the save already say, and the renderer now agrees.

  • #3647 c29178f Thanks @mobeenabdullah! - A block page shows the site settings of the Nextly instance its route is given. createBlocksPage, createPublicBlocksPage and the Single page factories read a page's site name, address, logo and time zone, which its dates and day filters use, through their nextly option, as they read its content. Before, they read the process's registered instance, so in a process serving several sites a page could show another site's name and time zone. A route given no nextly reads the process's instance as before. A reader of your own forwards publicSiteSettings from the instance (publicSiteSettings: async () => (await getNextly({ config })).publicSiteSettings()). One that does not keeps showing the process's registered instance's settings, so a single-site app is unchanged, and the route now warns once per reader, in every environment, that on a process serving several sites these are another site's.

    nextly adds publicSiteSettings() to the Nextly instance, and readPublicSiteSettings from nextly/runtime takes an optional instance to read from, with the PublicSiteSettingsSource type (all @experimental). Given none, it reads the process's registered instance as before.

  • #3673 75f0bc1 Thanks @nextly-agent! - The page builder's top bar now shows how many reads the page being edited makes when published, against its 500-read limit. It warns from 80% of the limit, and over it names each block a visitor would see without its data, with a way to select it. The canvas bindings route now reports what its reads cost.

  • #3223 535571b Thanks @nextly-agent! - A page's entry screen now shows the page large enough to read, at the editor's column width and up to 640 px tall (scrolling inside for the rest), with its sections listed beneath by number, block name and first line. Clicking a section, in the preview or in the list, opens the Page Builder with that section selected, shown in Layers and scrolled into view; each is a real link, so it also opens in a new tab. The builder's address gains an optional section key; an address naming a section the page no longer has opens with nothing selected. "Preview full page" opens the entry's own preview where the collection has one.

    For plugin authors: @nextlyhq/plugin-sdk/admin adds useDocumentPreview() (experimental), which returns the editor's own full-page preview opener, or null wherever the editor offers no Preview action. @nextlyhq/builder adds revealNode(root, id) (experimental) and an optional definition lookup on blockLabel and layerLabel; existing calls are unchanged. @nextlyhq/blocks-react adds prepareDocumentAsDrawn(document, args) (experimental), the tree PageRenderer walks with placeholders kept, for a surface listing a page's parts beside a picture of it. @nextlyhq/ui's TreeView now scrolls a selected row into view when the selection changes from outside the tree, once per change.

  • #3645 c797879 Thanks @nextly-agent! - A Collection list split into pages is counted, and pages, as the page draws it: where its number of items, entries to skip, collection or split into pages is bound to the page's entry, the route serves the pages the bound values make, so every page link under the list resolves. A list split into pages only by a bound value pages too. paginatedList in @nextlyhq/blocks-engine takes an optional reader of a list's props, so a caller judges a list as drawn.

  • #3630 4bd52cc Thanks @mobeenabdullah! - A paginated collection list that filters by a day now counts its pages with the same day inputs it renders with, so the page count and the pages agree when a list's filters depend on its blocks.

  • #3635 dd237c9 Thanks @mobeenabdullah! - A paginated collection list's page links register again: their parts are named page-link, current-page and page-gap, the lowercase slugs every block part must use, so a site using the page builder starts instead of refusing the collection list block at boot.

  • #3731 bd5217e Thanks @nextly-agent! - Saving a page that holds a paginated list no longer stalls on a database pool of one connection while the site is still claiming its pages' addresses at start: the pages its later pages could fall on are read on the save's own transaction.

  • #3622 de75450 Thanks @mobeenabdullah! - A plugin's panel section that finishes its work after the editor has moved to another document, switched language, or closed no longer acts on the document now shown. Its report of a change or a deletion refreshes only the document it was drawn for, and does not redirect away from the new one or treat the new document's next version as the author's own change: a newer version of the new document replaces its unsaved text as any other version would. The plugin SDK's stability notes now say advisory notices show on collection writes only, not yet on a Single's save.

  • #3568 8974f12 Thanks @nextly-agent! - A component placement's exposed rich text can now be edited directly on the canvas. Double-click the passage on a placement and type; the edit is stored on that placement only, as one undo step, exactly as the placement panel's field writes it. While the canvas has the passage open, the panel's field for it is held, saying it is being edited on the canvas.

  • #3537 6fb1da8 Thanks @faisal-rx! - A plugin can declare webhook event types in contributes.webhookEvents (experimental), each in its own namespace. Startup refuses a type outside the namespace, one of core's, one declared twice, or a malformed one. An endpoint may subscribe to a declared type, a subscription is judged against core's and every enabled plugin's types when it is written, and GET /admin/api/webhooks/event-types lists them for anyone who may read, create or update webhooks. A plugin cannot yet send an event of its own type.

  • #3298 b370b9b Thanks @nextly-agent! - A plugin field type can set the experimental validateEmpty: true to have its validate run when a write empties the field (sets it to null or an empty string), judged on the data the write's hooks leave. Without it, an empty value still never reaches validate, as before.

  • #3675 2016d1e Thanks @nextly-agent! - A plugin can find the host content that uses its field type inside a
    transaction it holds: ctx.services.ownCollections.listHostTypesInTransaction
    (experimental) answers each collection and Single holding a field of a type
    the plugin registered, at any depth, as services.collections.listCollections
    and services.singles.list list them. It reads on the transaction's
    connection, so on a pool of one connection it answers where those listings
    would wait for the connection the transaction holds.

  • #3681 145642f Thanks @nextly-agent! - A plugin can read a collection's record inside a transaction it holds:
    ctx.services.collections.getCollectionInTransaction (experimental) answers
    what getCollection answers, on the transaction's own connection, so on a pool
    of one connection it answers where getCollection would wait for the
    connection the transaction holds. The page builder reads whether a collection
    has a Draft/Published lifecycle with it inside an entry's save and a
    template's publish, so a save in a collection served at a template address no
    longer waits for a second pooled connection.

  • #3666 dc43a78 Thanks @nextly-agent! - A plugin can read host content that uses its field type inside a transaction
    it holds: ctx.services.ownCollections gains listHostEntriesInTransaction,
    findHostEntryByIdInTransaction and getHostSingleInTransaction
    (experimental). They read a collection or Single the plugin did not declare,
    only when it holds a field of a type the plugin registered, at any depth
    (groups, repeaters, components), decided at each call from the schema as it
    stands. They read as the own in-transaction reads do: on the transaction's
    connection, as the system, past that content's read hooks, with rows locked
    for share or, with lock: "update", for update. Anything else is refused
    before its rows are read.

  • #3232 d44a678 Thanks @nextly-agent! - A plugin can read the collections it declared without the site's read hooks reshaping
    the answer, through ctx.services.ownCollections (@experimental). The read skips
    every configured read hook (collection beforeOperation, beforeRead and afterRead,
    including * globals and the plugin's own, stored hooks, field hooks set in config, and
    the collections.listQuery filter). It keeps what a field's type does to make a stored
    value readable. It runs as the system only, offers listEntries, findEntryById,
    count and group, and refuses any collection the plugin did not declare, a dependency's
    included, before anything is read. Related rows keep their own collection's hooks. Use
    it for a plugin's own bookkeeping; never return its result to a person.

  • #3659 ca9eaed Thanks @nextly-agent! - A plugin can read its own content inside a transaction it holds:
    ctx.services.ownCollections gains listEntriesInTransaction,
    findEntryByIdInTransaction and getSingleInTransaction (experimental).
    They take the token collections.withTransaction hands its work, or an
    in-transaction handler's transaction, and read on that transaction's own
    connection, so they see its uncommitted writes and no longer wait for a
    second connection on a pool of one. On PostgreSQL and MySQL the rows they
    read are locked for share until the transaction ends; a list's total is not.
    getSingleInTransaction reads a Single the plugin declared, past its read
    hooks, and writes nothing. The adapter's select takes forShare.

  • #3661 1371c6e Thanks @nextly-agent! - A plugin's reads of its own collection on a transaction it holds (listEntriesInTransaction, findEntryByIdInTransaction) take lock: "update" (experimental) to read their rows for update on PostgreSQL and MySQL, for a read that goes on to write them, so two transactions doing so take turns instead of one being refused.

  • #3695 cf30707 Thanks @nextly-agent! - A plugin's reads on a transaction it holds (listEntriesInTransaction, findEntryByIdInTransaction, getSingleInTransaction and their host forms) take lock: "none" (experimental): a plain read on the transaction's connection that takes no row lock on PostgreSQL and MySQL, so a plugin holding a lock of its own can read rows another write is changing without the two waiting on each other until the database refuses one.

  • #3572 a74781c Thanks @faisal-rx! - A plugin records events of the webhook types it declares with ctx.webhooks.record (experimental), in its own transaction with tx or on its own, and they are delivered to the endpoints subscribed to them or to *. A type the plugin does not declare is refused by name before anything is written. The event is stored in the existing columns, as kind plugin with the plugin's admin slug, so no migration runs; the delivery log shows it as the plugin's, never as a collection of the same name.

  • #3352 7d25b54 Thanks @nextly-agent! - A plugin route can now ask a type-level permission question: ctx.caller.can(action, resource, { anyEntry: true }) answers whether the caller may perform the action on any entry at all. It is the same access decision as plain can, except that a rule limiting the action to the entries a row filter matches answers yes for a write as it already did for a read. Plain can still answers no there, since it names no entry. The option's type, PluginRouteCanOptions, is exported from @nextlyhq/plugin-sdk and nextly. It decides nothing about an entry: the write itself is still judged on its entry. The page builder's site style route uses it, so an author who may update only their own entries of a collection the builder opens can now draw the canvas.

  • #3536 5529dd8 Thanks @zeshan-rx! - A plugin's ctx.settings.set inside its own ctx.db.transaction is now refused on every dialect, with an error naming the call and the fix: write the setting after the transaction has finished. Before, it committed on a connection of its own on PostgreSQL and MySQL and survived the transaction's rollback.

    This deliberately removes SQLite's former behaviour, where the setting joined the transaction as a savepoint and rolled back with it; a plugin that wrote a setting inside a transaction now writes it after. Outside a transaction a settings write is unchanged.

  • #3589 b2bbf33 Thanks @mobeenabdullah! - A plugin can now change one collection's document screen through contributes.admin.views[slug], from @nextlyhq/plugin-sdk. documentActions hides the built-in Delete or Unpublish there, or keeps the action's row and opens the plugin's own component in its place; the permission it needs, a colleague holding the document and a past version on screen still hold it. panelSections adds sections to the document panel after Details, drawn under the panel's own heading. Both are experimental and apply to collections only. The app refuses to start on an action that cannot be overridden, an override or section with nothing to draw, or two plugins overriding one action on one collection.

    A save the server refuses with a reason about a field now shows that reason on the field, and keeps the author's edits. Reasons no field on the form shows are said in the toast, rather than a bare "Validation failed.".

    recordAdvisoryNotice is exported from @nextlyhq/plugin-sdk (experimental), so a plugin's hook can tell the person saving something true about what their write leaves behind; it is shown beside the save's success as core's own notices are.

  • #3667 5fadd8b Thanks @nextly-agent! - A plugin can take part in deleting a collection: ctx.hooks.onCollectionDelete
    (experimental) says what the delete takes with it, which the admin's delete
    dialog now lists under the plugin's name before the confirm, and removes it
    inside the delete's own transaction, so a plugin's throw refuses the delete
    and nothing it holds is left naming a collection that no longer exists. The
    page builder uses it: deleting a collection deletes its template with it.

  • #3548 365f2fb Thanks @faisal-rx! - A plugin can translate its admin strings: contributes.translations (experimental) holds them by interface language and key, and usePluginTranslate() from @nextlyhq/plugin-sdk/admin reads them in the interface language, then English, then the key itself. Every key lies in the plugin's own namespace, and startup refuses one outside it, a malformed key or language, a value that is not text, and a key another plugin declares. The admin's own strings now begin with nextly., so a plugin slugged nextly can declare none. Plugin strings are served to signed-in readers only.

  • #3595 f620f2b Thanks @nextly-agent! - Plugins can now write in an entry's own transaction (experimental). ctx.hooks.onInTransaction(collection, handler) runs a handler last inside a collection create, update or delete, before the commit, with the plugin's db bound to that transaction: what it writes commits or rolls back with the entry, a handler that throws aborts the write with its own status, and a retried attempt runs it again, keeping only the result that commits. A write with no such handler is unchanged.

  • #3424 3706d47 Thanks @nextly-agent! - Plugins can read the stored form of a document's fields and write a field only if it is unchanged, through two new @experimental exports of @nextlyhq/plugin-sdk.

    readStoredFields(identity, { ...document, fields, form, locale }), where the document is { collection, id } or { single }, returns the values as stored, for the live row (form: "published") or the working draft a preview shows (form: "draft"), in one language, with no afterRead hook of the collection or of a field and no population. It reads fields of a plugin field type stored as JSON, and refuses any other, and any field a field-level read rule governs. The person must be able to read the collection or Single; the draft form also needs them to be able to update the document.

    updateIfUnchanged(identity, { ...document, data, locale, expect }) makes the ordinary update as that person, under access rules. expect names a field, the form it was read in and storedValueHash of the value read. The update reads the field again inside its own transaction once it holds the entry's row lock (SELECT ... FOR UPDATE on PostgreSQL and MySQL; SQLite's write transaction already serializes writers), and is refused with a CONFLICT error, changing nothing, when the value no longer hashes to what was read. With noPendingDraft: true it is refused as well when a working draft is pending, which a publish would otherwise put live. The expectation names a top-level field: one inside a named group is refused with INVALID_INPUT, because an update writes the group's whole value. The read, and the update gate for the draft form, are judged in the language read, as ordinary reads are. A published read whose live row, in the language read, is in a state the workflow does not call public answers absent unless the person may update the document, as an ordinary read would not show it to them. The live row's state and its values are read in one snapshot. The read resolves its language once, as an ordinary read does (a language the site does not configure reads as the default), and refuses a selector such as all.

  • #3261 d56384f Thanks @nextly-agent! - nextly/runtime exports createPublicReader (@experimental): the read a published
    page's lists should go through. It takes a list's query as data (typed filter rows, sort
    keys, limit, offset, page, select) and fixes the access options:
    published entries only, the anonymous visitor's read rules, no field the public may not
    read, and unknown sort keys refused. Any option that would widen the read is refused by
    name, and the read runs detached from any request in flight. find answers the canonical
    { items, meta }; count answers a number.

    A collection read also takes unknownSort: "refuse" (@experimental), which refuses a
    sort key that names no sortable field, naming each one, instead of dropping it with a
    warning.

  • #3746 6106801 Thanks @nextly-agent! - A public or editor read of a Single now asks the Single read for only the fields it selects, with the
    id, the same way a list read already does. The answer is unchanged: it still holds only those fields.

  • #3608 1b9ab4e Thanks @nextly-agent! - A published page now shows a block whose visibility conditions hold. The route reads the entry it shows, once and as an anonymous visitor reads it (its published values, and only the fields the public may read), and decides each block against it: one whose conditions hold is served, and one whose conditions do not hold, or cannot be checked, is left out of the HTML, its styles and the page metadata. A block inside a collection list is decided for each entry the list draws. Conditions that cannot be checked are logged by the route, beside bindings that show a fallback. BindingIssuesHandler now receives PageIssue values, a binding issue or a condition issue (kind: "condition"), and isBindingIssue tells them apart.

  • #3240 0c41751 Thanks @nextly-agent! - A collection read sorts by several keys and starts at any offset. sort takes
    an array or a comma-separated string (["-featured", "createdAt"],
    ?sort=-featured,createdAt), and find takes offset (a whole number from 0,
    refused together with page), with hasNext and hasPrev following it.

    Two behaviour changes for sorted reads: entries tied on every sort key now come
    back in id order, so a page never shifts between reads; and an entry with no
    value for a key now sorts last in both directions on every database. Empty
    values move in a descending sort on PostgreSQL and in an ascending sort on
    MySQL and SQLite, which each put them first there before. A read with no sort and
    no offset is unchanged. Sorting a field held per language with fallback off
    now works on SQLite.

  • #3771 6700652 Thanks @mobeenabdullah! - A list whose stored sort names a field the collection no longer has, or one visitors cannot read, now shows its entries in id order on a published page. Under Cache Components it drew nothing. In the page builder, a list's "Choose a field" now takes focus to the sort, look tiles keep their contrast in the dark admin, and usage counts become exact on a site whose field groups hold no blocks field, judged by each group as it is defined now, so a group that gains a blocks field after the site starts keeps its styles and variables from being deleted as unused.

  • #3657 08d39a5 Thanks @nextly-agent! - Removing a variable or a shared style while a page is saved can no longer leave that page using something the site does not define. Whichever finishes first wins: a page saved first makes the removal refuse it as in use, with nothing removed; a removal finished first makes the page save refuse its new use. Every way of removing one is covered, including saving the whole Variables section, an undo and an import. If the site styles cannot be checked in time, the save or removal is refused with a message to try again. A removed variable is no longer briefly taken out and put back when a page started using it during the removal. The same holds for a shared style starting to use a variable while that variable is removed: the shared style's save is refused, or the removal is refused as in use. On a database pool of one connection, a page save is no longer refused for want of a second connection while the site styles are checked.

  • #3660 87701b4 Thanks @nextly-agent! - The Page Builder keeps a report of the documents whose bindings no longer fit what they read: each document is judged again when it is saved, and every document once a collection's or a Single's fields, or a block's props, change. Read it through GET …/plugins/@nextlyhq/plugin-page-builder/bindings-to-fix, for people who can update pages.

  • #3580 e273902 Thanks @nextly-agent! - The zod schema generate:types writes for an icon field now refuses "" when the field is required by validation: { required: true }, the Schema Builder's spelling, as well as by required: true. Before, only the top-level spelling counted, so the generated schema accepted a cleared value that the server's own entry validator refuses as missing.

  • #3434 1e9176c Thanks @zeshan-rx! - An access rule or a field's access rule that queries the database, and whose query waits out the pool's bound for a connection (pool.connectionTimeoutMs), now ends the request with a new error, RULE_COULD_NOT_RUN (503). It names the collection or Single whose rule it is, and the field for a field's rule, and carries the same retry hint as DATABASE_BUSY. Before, the wait read as the rule refusing: a publish was refused as forbidden, a field was silently left out of a read or a write, a related document read as missing, and a dashboard, a widget, release readiness or the capabilities answer quietly left the entity out. A publish that meets it rolls back and keeps its pending change, and a retry asks the rule again. A rule that throws for any other reason still refuses, as before. On SQLite, which keeps one connection, the same answer comes when a rule's own work queues behind a held transaction past pool.connectionTimeoutMs.

    Every way in answers it the same: the Direct API returns or throws it, REST answers 503 with Retry-After and the request id, including when the route's own gate asked the rule, and findByID with disableErrors throws it rather than answering null. A dashboard widget's slot that meets it carries code: "RULE_COULD_NOT_RUN" with the subject, since a streamed batch has already answered. The refusal log records it with status 503, the code and the rule's subject.

  • #3775 4d1e362 Thanks @mobeenabdullah! - Saving an entry keeps each repeater row's id, so a row moved before the save keeps its identity and anything addressed to it, such as its blocks field in the page builder, stays with it. A template on a collection made in the Schema Builder can bind the entry's title and slug, which its published pages now show rather than the fallback. The field picker says "an image's" rather than "a image's".

  • #3205 5290d41 Thanks @aqib-rx! - A running server no longer writes to a collection, Single or field group it has not registered — one a newer deploy added or changed after it started. A collection create (single, in a caller's transaction, or batched), a field group's instances, and in production a Single's update are refused with the not-registered answer (ENTITY_NOT_MIGRATED, 409, naming nextly migrate and a restart) and write no row. Before, the create and the field-group save still wrote, and an update of a field group whose table was unregistered could add a second instance beside the stored one. In development a Single is still recovered on a read or a write, as a second dev worker needs. The CLI commands that take the schema lock (migrate:resolve, migrate:baseline, migrate:down, upgrade, plugin install and uninstall) keep working on a database whose lock row is not yet seeded.

    Compatibility: an adapter used without a table registry (no setTableResolver) now refuses transaction inserts, as it already refused transaction updates, deletes, selects and upserts — inserts were the one write that still went through, so this makes them consistent rather than adding a new refusal. Code that builds its own adapter and calls the schema-lock APIs must install a registry resolver first (for example installRegistryResolver, which the CLI now does for every command).

  • #3685 ab1219a Thanks @nextly-agent! - A page's share image now matches the picture it draws for an image bound to a list item but placed outside any list: the binding's fallback, or the block's own media, never the address typed beside it.

  • #3208 1f0369d Thanks @zeshan-rx! - A Single's schema save on SQLite now makes a column NOT NULL when Required is turned on, and nullable when it is turned off, including a Required field leaving translation. SQLite can't alter a column, so the save rebuilds the table in the same transaction as its other statements, with foreign keys off, keeping every row, key, index, translation and one-to-one's UNIQUE. A table with a trigger is refused unchanged.

  • #3544 2bdb227 Thanks @nextly-agent! - A site's edit of a block type's own look, such as a button's Primary, now
    reaches every block of that type. The edit is stored as a look in the site's
    class library, marked isDefault, and laid over the block's base styles
    property by property, so every default value the site didn't change is kept. A
    look, a shared style and the block's own values still win over it, and under
    the Classic spacing model it sits over the frozen base. The page builder does
    not offer a control that edits it yet.

    blockOwnLooks() gives each block's own look with no edits, and the plugin
    seeds them in the code tier, so a site stores one only once it changes it.
    blockLooks() still gives only the looks a block can wear. An own look is
    never written as a class, so no block can wear it or refer to it. A variation
    that is its block's own look and also states styles is no longer read as a
    look.

    Published pages and the canvas read the same edits, from the class library they
    already receive. A route that states classes of its own keeps them, with the
    site's own looks carried in. overlaidStyles(), the layering the editor uses
    for Detach, now lives in the engine and also lays an own look over its base.
    A second own look for one block type is reported (duplicate-own-look) instead
    of being ignored silently, and a stored shared style may share an own look's
    name. Own looks are read under an allowance of their own, so seeding
    them never pushes a worn look past the look cap, and a block's own look is kept
    whatever its variation is named.

    An own look stays with its site. A page builder export never carries one, and
    an import leaves out any a file holds, so importing an item never changes the
    target site's own looks. The item draws with them instead.

    Nothing to migrate: stored libraries without own looks compile byte for byte as
    before.

  • #3259 3cb6f24 Thanks @nextly-agent! - The page builder gives every site one default Layout (experimental). Pages gain a Layout field (empty uses the site default) and a No header or footer switch, which always wins. The default is recorded in a new page-builder-settings Single and is chosen only through POST /layouts/:id/make-default on the plugin, which requires the new manage-page-builder-site permission plus update and publish on Layouts, and accepts only a published Layout. The default Layout cannot be deleted or unpublished. A new site gets a published "Default (site)" Layout as its default; an authored Layout with that name is never taken over, and a job repairs the default if it goes missing. effectiveLayoutFor (experimental) answers which Layout a stored page gets by that rule.

    Existing sites get the new page columns and the Single through a migration: run nextly migrate:create and then nextly migrate (or nextly db:sync in development).

  • #3257 686cd63 Thanks @nextly-agent! - The Page Builder's device buttons show Desktop and the site's two widest breakpoints; a site with more breakpoints puts the rest in a "More devices" menu beside them, whose button names the device being styled while it is one of those. The buttons never change places, and the menu is its own button, outside the device radio group.

  • #3753 ad3bdcc Thanks @nextly-agent! - On SQLite, nextly db:sync and the dev auto-sync no longer refuse a whole push that drizzle-kit applies, such as one adding a plugin collection's fields, over two changes the push never asked for:

    • the media table's retired sizes column is kept, as it is until nextly media remove-sizes --apply --drop, instead of being planned as a drop;
    • a field-group table is no longer rebuilt over a column default. Its runtime table now declares the defaults its CREATE writes, and a rebuild of a table an earlier release created, which would only copy every row and column onto the same columns, is left out with a warning naming the table.

    Any other rebuild or drop the push did not plan is still refused.

  • #3493 18fefbd Thanks @faisal-rx! - An update that changes only a document's status is judged by publish or unpublish even when it also sends _overwrite. Before, the overwrite choice made it read as an edit: a person or key who may publish but not update was refused ("You can't edit") on an update by query and in a batch, and a caller who may neither publish nor edit was refused in the words of edit, not publish, on a REST save and a bulk update by ids. A write that names any field beside the status is still an edit.

  • #3274 25e4c1c Thanks @nextly-agent! - Undoing or redoing a shared style change in the Page Builder holds its surfaces until the server's read holds the replayed value: a failed re-read keeps them waiting and asks again, rather than unlocking on the value the replay replaced. While it settles, creating or renaming a class from the inspector or the class manager is refused with a plain message, and an undo or redo queued behind a save that is then refused writes nothing.

  • #3236 2050739 Thanks @faisal-rx! - Taking over a document someone else is editing is now recorded in that document's history: who took over, from whom and when. The takeover and its event are written together, so a takeover whose event cannot be written is refused and the previous editor keeps the document. Claiming, renewing, asking for access, releasing and a lapsed claim record nothing. History names the previous editor by their current name, read when history is read, never by email.

  • #3686 c6eeda9 Thanks @nextly-agent! - A template can draw the entry's own blocks content with the new Entry content block (core/entry-content), offered under Entry in the Add panel while a template is open. Its Field menu chooses one of the collection's top-level blocks fields; the canvas draws the previewed entry's content read-only, with an at-rest mark and notes for no entry, an empty field and a removed one, and the published page draws the field as the public reads it, or nothing. A template holds one, and one anywhere else, an entry's own blocks field included, is refused at save, as is a field the collection doesn't have; a template whose field was removed keeps saving. The page actions route gains place-entry-content and set-entry-content-field. The engine exports composeEntryContent and the block's rules, PageContext gains entryContentCanvas, and @nextlyhq/builder/shell exports usePreviewedCollection, all experimental. Also: a template's preview reads the canvas again with the entry when the window regains focus, and BuilderShell draws no band for a canvasStrip that draws nothing (null or false).

  • #3665 1b5b66a Thanks @nextly-agent! - A template is edited against a real entry of the collection it draws. A Previewing strip pinned above the canvas names the entry and its status, and opens a picker of the entries the author may read, drafts included, newest first and searchable, with New to make one in a new tab. Shift+Alt+Down and Shift+Alt+Up step through the list. The canvas's bindings, lists and conditions read the previewed entry as the author, and with no entry to preview they draw their fallbacks. A template's lists and conditions are judged at save against the collection it draws. BuilderShell gains a canvasStrip slot, and @nextlyhq/builder/shell exports PreviewedEntryProvider, usePreviewedEntry and PREVIEWED_ENTRY_KEYS, all experimental.

  • #3694 dddc6fd Thanks @nextly-agent! - A collection entry's page stops serving once the public may no longer read the entry. The content route (createContentPage, createPublicContentPage) now answers not found for an entry the public is refused (a denial, or a visitor asked to sign in), as it does for an unpublished one, where it used to answer 200 with a rendering error; any other failure still throws.

    cachedFind keeps a read refused by access as its answer, rethrowing the refusal on each read of the entry. Next keeps a cached entry's earlier answer when reading it again throws, so a read the public was allowed before an owner took its permission away went on being served until some write expired one of its tags. And a change to what a role grants (its permissions, inheritance, slug or deletion) or to a permission row (an edit, or boot's seeding) now expires every collection's and Single's cache tags, as a change to the site's languages does, so a page shows the change promptly rather than at the end of its cache lifetime. A refusal is a denial (FORBIDDEN) or a visitor asked to sign in (AUTH_REQUIRED); another 403, such as an unverified email, is not one.

    nextly/runtime exports isReadRefusal, the test the content routes use to tell a refusal from a fault, and deferToRequest. The access-enforced content route waits for the request before its uncached address lookup, so a Cache Components prerender no longer reports reading the current time there.

  • #3378 e4693ac Thanks @zeshan-rx! - A translated field added to a collection, Single or field group that is already translated is recorded in its migration: nextly migrate:create writes a file that adds the field's column to the translations table, and nextly migrate:down removes it. Before, it wrote nothing, and the column appeared only when nextly migrate later reconciled the translations table. The file is a new kind of localization migration, so it needs this version of Nextly or a newer one to run.

  • #3319 5c8f2c6 Thanks @nextly-agent! - Deleting a component that pages still use is getting closer: the page builder can now turn every copy of a component into the plain blocks it draws, on every page, working draft, language, Single, component and pattern, before the component goes. While that runs, a save that would add a new copy of the component is refused, judged against what the page stores at that moment; a page that already holds a copy can still be saved, and is converted again from what was saved. Each conversion writes only the blocks field and is checked against what was read, so an edit made in the meantime is converted rather than overwritten. A published page with unpublished changes has its draft converted and is reported, so its author can publish or discard them first. Pages whose blocks sit inside a repeater or a named group, and Layouts naming the component, are reported rather than changed. The deleting itself, and the dialog, come next.

    The rewrite is generic: other changes to every page placing a component plug in a step (stored value, form) => unchanged | rewritten | refuse, and share the fence, the check and the progress. It is offered as the componentDeleteRewrite service, @experimental.

    This adds two tables of the page builder's own (page_builder__component_deletions and page_builder__component_deletion_hosts). Run nextly migrate when upgrading a production site.

  • #3067 61036c3 Thanks @faisal-rx! - A validation refusal no longer tells its caller about a field they may not read. A publish judges every stored value, so a refusal used to name a hidden field and say what was wrong with its value: "must be at most 10" told the caller the hidden value was over 10, "is required" that it was empty, and a field's own validate message could carry the value itself. Each issue on a field the caller may not read, or on a row inside one, now reaches them as one issue with no path, code UNREADABLE_FIELD and the message "A field you can't see doesn't pass validation." The write is still refused with a 400, and issues on the fields they may read are told as before. This holds for a collection entry and a Single, for a save, a publish of one language or of every language, the Direct API and a release's readiness check, and for the fields of a field group, whether held inside the document or saved as its own instance. A caller who may not read the entry at all is told no field of it, a password is never named, and where a field afterRead hook could change what a read rule decides, an issue on a field with a read rule is withheld. Trusted code (overrideAccess: true) is told every issue, and the server log records which paths were withheld, not their messages.

  • #3343 e3b4637 Thanks @nextly-agent! - A field inside a named group is now read back exactly as the group stored it: a JSON-backed field holding a string such as "123" no longer comes back as a number.

  • #3486 0fcfeb0 Thanks @faisal-rx! - An update that hands back its _rev is now judged the same way however it arrives (experimental):

    • A version a read gave while a collection's or Single's translations were not set up yet names no language. Sending it back with a save in the default language is now accepted, judged on the document's own row; before, it was refused with 400.
    • In updateMany and the in-transaction updates, a version from another language's read is refused with 400 before any hook runs, as a single save's is.
    • Who changed a refused document and when are now told only to a caller whom the collection's or Single's own read rule lets read it, a rule that answers a filter included. Before, any signed-in caller who could update it was told.
    • A save in a language other than the default, while translations are not set up yet, is refused with 400 before any hook runs.
  • #3051 bee3ff9 Thanks @faisal-rx! - A write that changes more than one language asks its access rule once in each language it changes, and goes ahead only where every answer allows it. A delete is asked in each language its entry holds, so under delete: ({ locale }) => locale !== "de" an entry with German content can no longer be deleted, while one with English content alone still can; before, the rule was told no language and allowed both. A delete of several entries, by ids, by query or in a batch, judges each entry by its own languages, and a rule answering a filter in each language deletes only an entry each of those filters matches. An update by query writes the default language and is now asked in it. This holds on the Direct API, a plugin service and REST, where a delete's route now checks the grant and leaves the rule to the delete. An admin screen's delete offer for a collection is a hint, shown where some language allows a delete.

  • #3562 4e6b671 Thanks @zeshan-rx! - A release's page has Add documents, for an ordinary release you may add to. It opens a picker across every collection and Single with a Draft/Published lifecycle that you may publish or unpublish, with a search, a collection filter and Has unpublished changes. Pick several documents and add them in one step, going live or coming down; the release takes all of them or none.

    A document already in the release, or one you may not publish (to go live) or unpublish (to come down), is listed but cannot be picked, with the reason beside it; changing the action judges the list again.

    Once documents are added to go live, the dialog lists the documents they link to that will not be live when the release runs, and offers to add them to go live too. Not now adds nothing more. Documents added to come down are offered nothing.

  • #3619 249c74c Thanks @nextly-agent! - The page builder's address store keys an address as the content route serves it, so a composed and a decomposed letter are two addresses rather than one, and it indexes the kind of each claim, which the waiting report reads by. The report names a document by its collection's title as the admin does, a nominated number included.

  • #3725 b2cb31a Thanks @nextly-agent! - Fix two page builder address-claim failures.

    On MySQL, releasing a document's address while another save was recording a
    wait for it could deadlock, and the release failed with "An unexpected error
    occurred." A release now reads the document's claims without a lock to learn
    which address locks to take, takes them, and only then reads the claims again
    under them, so the two saves take turns instead.

    A template saved for a collection with no address now finds the entries
    holding addresses there on its own transaction, rather than through a second
    pooled connection, which on a pool of one connection waited for the connection
    the save already held and failed as "The database is busy."

  • #3523 e3360b2 Thanks @nextly-agent! - The page builder keeps a store of who holds each served address, so two documents can't be given the same one. A claim is taken in the same transaction as the save it belongs to, spelled one canonical way (a trailing or doubled slash, percent-encoding and Unicode forms all name one address), and held per language. A paginated list holds all of its later pages (/news/page/2, …) as one claim, so a page can't be published among them, and a list can't paginate over a page that's already there. A document whose address is taken can wait for it and is served there once it's released. A new API route lists the documents waiting for an address and what holds each one, naming documents the caller can't read by id only. The store isn't yet called by page saves; that follows separately.

  • #3684 20807c5 Thanks @nextly-agent! - The admin builds again: the table's held plugin registrations export states its type, as declaration emit requires.

  • #3766 0ab7d79 Thanks @mobeenabdullah! - The admin loads less up front: the entry editor, history panel, relationship modals, email provider form and common-password list now arrive when they are first needed, so the shared shell and the document, version and email screens download less on a first visit.

  • #3506 85cd7cd Thanks @faisal-rx! - Admin pages now have named places a plugin can add to (experimental).

    • Core names nine: dashboard, collection.list, collection.edit, single.edit, entry.form, settings, user.detail, account and login. They are exported as CORE_ADMIN_PLACES, with the AdminPlaceId type, from @nextlyhq/plugin-sdk, nextly and nextly/config.
    • A plugin declares places of its own in contributes.admin.places, each named with its slug and a dot ("acme-billing.invoice"). It types them by augmenting AdminPlaces from @nextlyhq/plugin-sdk, so a misspelled place does not compile.
    • The app refuses to start, naming the plugin and the place, on a place:
      • outside the plugin's namespace;
      • under a segment core reserves, including a plugin whose own slug is one;
      • that is malformed;
      • that is declared twice.
    • Nothing renders at a place yet.
  • #3310 572d7ed Thanks @nextly-agent! - A collection update that runs in a transaction (updateMany,
    updateEntryInTransaction) and is held as a working draft now hands its
    after-hooks the draft it wrote, as the ordinary update does. Before, afterUpdate
    hooks, code-defined and stored alike, and the fields' afterChange hooks were
    handed the unchanged live row, with no sign that the edit was a draft: a hook
    reading status saw a publish, and read the old content as the new.

    The hooks now get the pending draft marked _isWorkingDraft: true, with
    originalData the prior draft on a repeat save, and the update answers with
    the same marked document.

  • #3754 11fb131 Thanks @nextly-agent! - An image bound to a field now says what its alt text will be by the field's type: a picture bound to an upload field is described by its library file's alt text, and one bound to an address field has none, so the inspector asks for Custom. While the field isn't known, it says both.

  • #3555 69f8db5 Thanks @nextly-agent! - An accordion's sections can now have a heading for a title, and the accordion has an icon of its own. On an accordion, Titles as (Content) draws every section's title as text or as a heading from level 2 to 6, inside its summary, so screen readers and search engines find each question in the page's outline. Icon (Style) offers Chevron, Plus, None or Browser default, and Position puts the icon before or after the title. Both are style values, so each can differ per device. The icon is drawn in the title's colour; the chevron turns and the plus becomes a minus while a section is open. It works with no script, and the browser's own keyboard and focus handling stay. New accordions show a chevron after the title. Sites on the classic spacing model keep the browser's triangle. @nextlyhq/blocks-engine's exported StyleGroup union gains "disclosure": code that switches over every style group, or keeps a Record<StyleGroup, …>, maps the new group.

  • #3215 c6e029d Thanks @aqib-rx! - An applied app migration now carries the checksum of its file's whole text, down section included: nextly migrate, migrate:baseline and migrate:resolve --applied all record it. When an applied file no longer matches, nextly migrate (and the boot migrate step) stop before changing anything, name every edited file, and exit with code 2 (MIGRATION_TAMPERED, as the migrations guide documents); restore the file and put the change in a new migration, or, where the edit is intended and the database already matches it, accept it with nextly migrate:resolve --applied <file>, which records the new checksum. migrate:status shows a file as "Applied (modified)" only when it differs from a recorded checksum, so a file recorded by migrate:resolve --applied no longer reads as modified.

    Checksums for existing rows. Rows recorded without a checksum (by migrate:resolve --applied, or by an earlier version) are taken as matching. The next run records the current file's checksum and lists those files. Edits made before the upgrade to those files are not detected. A project whose applied rows already carry a checksum (recorded by a recent nextly migrate) and whose applied files were edited since will see the first run of this release stop with exit code 2, naming those files; the boot migrate step logs it, keeps serving, and applies nothing until it is resolved. Restore each file, or accept the edit with nextly migrate:resolve --applied <file>.

  • #3488 2c9bf55 Thanks @faisal-rx! - The admin now sends the version an editor's copy started from with every save of an entry or a Single: a save, a working-draft save, publish, unpublish, publishing every language, a restore, discarding a pending change, taking shared values live, and a list's bulk actions. The form builder and the form submissions list send it too. A save refused because someone changed the document since opens a conflict dialog that names who changed it and when, keeps the edits, and offers to load the current version (the edits stay recoverable), to save anyway after a confirm, or to compare the two versions. A recovery point keeps the version its edits began from, and its offer says when the document changed since.

  • #3255 6d89981 Thanks @faisal-rx! - An editor who gains a document they were kept out of now starts from the copy
    saved while they waited. When a colleague leaves the document, their claim runs
    out, or the editor takes it over, the entry editor, a Single, a custom edit view
    and the Page Builder load the latest version before the form unlocks. Until it
    arrives the form stays read-only and says it is loading. If it cannot be loaded,
    the form stays read-only, says it couldn't load the latest version, and offers
    "Try again". Before, the form unlocked over the copy read while the colleague
    held it, so the editor's next save could put that older copy back over the
    colleague's work.

    The first claim on opening a document still unlocks at once, and an editor who
    takes back a document they were displaced from keeps their unsaved changes on
    screen as before.

    Any failed read of a document already on screen, such as the read after a save,
    now keeps the editor and its unsaved changes, read-only with "Try again",
    instead of replacing it with the page's "couldn't be loaded" error. That error
    now shows only when the document never loaded.

  • #3655 d2b59d2 Thanks @nextly-agent! - An entry can be given a design of its own: give-entry-design copies its collection's published template into a draft that names the entry, and remove-entry-design takes it away, through the page builder's template actions route, the composition service and @nextlyhq/builder/ops. An entry has at most one own design, held by a unique key on every dialect; it is deleted with its entry. Own designs are stored in the templates collection with an empty collection, so a collection's template is still found by its collection, and the collection field is no longer required by the schema (the guard requires it of a collection's template).

Notes truncated to stay within GitHub's release body limit. The complete changelog for every package is in its CHANGELOG.md at v0.0.2-alpha.74.

Packages

  • @nextlyhq/adapter-drizzle
  • @nextlyhq/adapter-mysql
  • @nextlyhq/adapter-postgres
  • @nextlyhq/adapter-sqlite
  • @nextlyhq/admin
  • @nextlyhq/admin-css
  • @nextlyhq/blocks-engine
  • @nextlyhq/blocks-react
  • @nextlyhq/builder
  • @nextlyhq/eslint-plugin
  • @nextlyhq/plugin-form-builder
  • @nextlyhq/plugin-mcp
  • @nextlyhq/plugin-page-builder
  • @nextlyhq/plugin-sdk
  • @nextlyhq/plugin-seo
  • @nextlyhq/storage-s3
  • @nextlyhq/storage-uploadthing
  • @nextlyhq/storage-vercel-blob
  • @nextlyhq/ui
  • create-nextly-app
  • nextly