# 0.0.2-alpha.74

11 Nov 2026 · Before you upgrade: No steps listed

- [An editor is told when someone else changes the document they hold, and a save over a newer copy opens a conflict dialog instead of overwriting it.](https://github.com/nextlyhq/nextly/releases/tag/v0.0.2-alpha.74)
- [Documents can be added to a release from inside it, across every collection and Single.](https://github.com/nextlyhq/nextly/releases/tag/v0.0.2-alpha.74)
- [nextly migrate checks each applied migration file against the checksum it recorded, and stops before changing anything when one was edited.](https://github.com/nextlyhq/nextly/releases/tag/v0.0.2-alpha.74)

Published: 11 Nov 2026
Changes: 126 changes
Notes: [On GitHub](https://github.com/nextlyhq/nextly/releases/tag/v0.0.2-alpha.74)

## Before you upgrade

These notes list no steps.

## What's changed

<!-- release-notes -->

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

### Patch Changes

- [#3728](https://github.com/nextlyhq/nextly/pull/3728) [`0beb16e`](https://github.com/nextlyhq/nextly/commit/0beb16e016c0ef99b6b2970adc4b6fee96722e3d) @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](https://github.com/nextlyhq/nextly/pull/3616) [`0dc0951`](https://github.com/nextlyhq/nextly/commit/0dc0951b44906061585d5b4676bf00e6cf689503) @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](https://github.com/nextlyhq/nextly/pull/3312) [`23e8831`](https://github.com/nextlyhq/nextly/commit/23e8831661c55852b5d1173c69966be58ed78861) @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](https://github.com/nextlyhq/nextly/pull/3333) [`9c6c948`](https://github.com/nextlyhq/nextly/commit/9c6c9483806569b9759cd746ca3955ffd072a42e) @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](https://github.com/nextlyhq/nextly/pull/3583) [`369155b`](https://github.com/nextlyhq/nextly/commit/369155bed9d7d65301b46a99b980b79cd91d99c2) @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](https://github.com/nextlyhq/nextly/pull/3643) [`550f90d`](https://github.com/nextlyhq/nextly/commit/550f90d2d397364a3d8915a3557bc4f77184a69c) @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](https://github.com/nextlyhq/nextly/pull/3823) [`07cb43b`](https://github.com/nextlyhq/nextly/commit/07cb43bcb0f11d319be7ba059e36810082fa775c) @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](https://github.com/nextlyhq/nextly/pull/3563) [`82e2e22`](https://github.com/nextlyhq/nextly/commit/82e2e22f96e6fa1e7048b1872b40049acb2f454f) @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](https://github.com/nextlyhq/nextly/pull/3566) [`f2d2cfb`](https://github.com/nextlyhq/nextly/commit/f2d2cfb0299d297b4dc4401164b87fe5aa4b464d) @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](https://github.com/nextlyhq/nextly/pull/3610) [`72007d1`](https://github.com/nextlyhq/nextly/commit/72007d14062f746545633ae88ea34c27c223a6d8) @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](https://github.com/nextlyhq/nextly/pull/3651) [`1f93392`](https://github.com/nextlyhq/nextly/commit/1f933920eef1a0d548822859223e85b2908035bb) @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](https://github.com/nextlyhq/nextly/pull/3416) [`bdd9024`](https://github.com/nextlyhq/nextly/commit/bdd9024c3b42ffd656002414322851831061f0e4) @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](https://github.com/nextlyhq/nextly/pull/3738) [`7d50d9d`](https://github.com/nextlyhq/nextly/commit/7d50d9d5f1e3d1674e8a11be108c49d22ab5377d) @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](https://github.com/nextlyhq/nextly/pull/3743) [`2ca423d`](https://github.com/nextlyhq/nextly/commit/2ca423dc3ba092ae8187aabfc1e5fbebb5810449) @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](https://github.com/nextlyhq/nextly/pull/3406) [`ac6ba5e`](https://github.com/nextlyhq/nextly/commit/ac6ba5e45eb83fe3a1d9874294e793c651dba21e) @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](https://github.com/nextlyhq/nextly/pull/3551) [`7b7e00f`](https://github.com/nextlyhq/nextly/commit/7b7e00ffe681fd6b1d3ca63fceafe2e4e6586bdf) @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](https://github.com/nextlyhq/nextly/pull/3576) [`0473854`](https://github.com/nextlyhq/nextly/commit/04738540f028b90223c98c627dff0f2446598656) @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](https://github.com/nextlyhq/nextly/pull/3605) [`0b82117`](https://github.com/nextlyhq/nextly/commit/0b82117221f837790cd005f1fa151dff85ea2551) @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](https://github.com/nextlyhq/nextly/pull/3202) [`a95deda`](https://github.com/nextlyhq/nextly/commit/a95dedaa544e306b85bc97afe69a045468932796) @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](https://github.com/nextlyhq/nextly/pull/3317) [`72f9277`](https://github.com/nextlyhq/nextly/commit/72f9277fa29e48b6a6ba5312741340a72e0fa5de) @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](https://github.com/nextlyhq/nextly/pull/3606) [`b13a66d`](https://github.com/nextlyhq/nextly/commit/b13a66dc888c5d37f49db0b52e56c42cc851308c) @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](https://github.com/nextlyhq/nextly/pull/3260) [`f48b906`](https://github.com/nextlyhq/nextly/commit/f48b90635bb9efb60cba355bd16fe3db08974d47) @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](https://github.com/nextlyhq/nextly/pull/3221) [`1e7cb13`](https://github.com/nextlyhq/nextly/commit/1e7cb134087310c22f02f6c6d6ffd96c0625227b) @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](https://github.com/nextlyhq/nextly/pull/3241) [`d252df1`](https://github.com/nextlyhq/nextly/commit/d252df1462adaac2daae1b699fb0004b74999b51) @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](https://github.com/nextlyhq/nextly/pull/3244) [`ab2ba5d`](https://github.com/nextlyhq/nextly/commit/ab2ba5d00fd99fb26c520b76bf416c947f8b8017) @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](https://github.com/nextlyhq/nextly/pull/3618) [`e3f9ea5`](https://github.com/nextlyhq/nextly/commit/e3f9ea5475fcdcff7193e94bada5f74efbd59013) @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](https://github.com/nextlyhq/nextly/pull/3511) [`e099a0f`](https://github.com/nextlyhq/nextly/commit/e099a0fd12a5df82ca5f3f2f0e22f6f236a530e5) @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](https://github.com/nextlyhq/nextly/pull/3237) [`1eee856`](https://github.com/nextlyhq/nextly/commit/1eee8561aa39b359947188dda9768c1db8531248) @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](https://github.com/nextlyhq/nextly/pull/3774) [`738e6f4`](https://github.com/nextlyhq/nextly/commit/738e6f4b7bb15d6012d1374d3f9904c4dc22d58d) @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](https://github.com/nextlyhq/nextly/pull/3217) [`462d94b`](https://github.com/nextlyhq/nextly/commit/462d94b24749b369106870fd9a5e7f787c23b555) @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](https://github.com/nextlyhq/nextly/pull/3324) [`d622214`](https://github.com/nextlyhq/nextly/commit/d622214812e9c46c957b78515811090d981bee33) @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](https://github.com/nextlyhq/nextly/pull/2994) [`3780014`](https://github.com/nextlyhq/nextly/commit/3780014e53b4dece766a132c330a48fcb306dd6d) @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](https://github.com/nextlyhq/nextly/pull/3534) [`ea4db68`](https://github.com/nextlyhq/nextly/commit/ea4db681aea0088f3f88cd217bf2017819d12e7f) @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](https://github.com/nextlyhq/nextly/pull/3603) [`3bc6b24`](https://github.com/nextlyhq/nextly/commit/3bc6b24d4347e1dd1532827e4a3c24aa8ff423a6) @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](https://github.com/nextlyhq/nextly/pull/3349) [`bb8f143`](https://github.com/nextlyhq/nextly/commit/bb8f143bdd6dbae93aa70df53e028ac7717575a8) @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](https://github.com/nextlyhq/nextly/pull/3418) [`256d09f`](https://github.com/nextlyhq/nextly/commit/256d09fd0310b013210943bb25622c0b139a4ab6) @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](https://github.com/nextlyhq/nextly/pull/3499) [`2177bfa`](https://github.com/nextlyhq/nextly/commit/2177bfa1260c1d50bdd518007436c4fa3b0788a5) @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](https://github.com/nextlyhq/nextly/pull/3290) [`db5abc8`](https://github.com/nextlyhq/nextly/commit/db5abc88e603e7e51d89e7e21dd4c27249cecc81) @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](https://github.com/nextlyhq/nextly/pull/3457) [`77df5f9`](https://github.com/nextlyhq/nextly/commit/77df5f9b88ae802a7699c56bdf91fd403b0cf2a7) @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](https://github.com/nextlyhq/nextly/pull/3732) [`7326358`](https://github.com/nextlyhq/nextly/commit/73263585c5875a5d0eca290332e7c542789cc850) @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](https://github.com/nextlyhq/nextly/pull/3741) [`b6802ff`](https://github.com/nextlyhq/nextly/commit/b6802ff124b99e8f41674b491c857567306f781c) @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](https://github.com/nextlyhq/nextly/pull/3263) [`a7256b5`](https://github.com/nextlyhq/nextly/commit/a7256b53dbce3d7f8ce83a6526e84b4f3f1cdaf5) @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](https://github.com/nextlyhq/nextly/pull/3751) [`94a1e48`](https://github.com/nextlyhq/nextly/commit/94a1e48b940151b63df871d0c96f2384fec0a88e) @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 <collection> 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](https://github.com/nextlyhq/nextly/pull/3593) [`9cae594`](https://github.com/nextlyhq/nextly/commit/9cae594f53cb77d76465d0ff0c4530abb57441ac) @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](https://github.com/nextlyhq/nextly/pull/3730) [`ff038c1`](https://github.com/nextlyhq/nextly/commit/ff038c177d4de7ee415f946280c692b563263d95) @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](https://github.com/nextlyhq/nextly/pull/3690) [`60e099d`](https://github.com/nextlyhq/nextly/commit/60e099d8b0700dfa5b0326885c48ae0be2d019ce) @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](https://github.com/nextlyhq/nextly/pull/3668) [`8fe7618`](https://github.com/nextlyhq/nextly/commit/8fe76184133ef3ab030d00b769fcf4d73205e63d) @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](https://github.com/nextlyhq/nextly/pull/3653) [`0f89591`](https://github.com/nextlyhq/nextly/commit/0f89591a29db951e88e4a5addc51cc1693775a0e) @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](https://github.com/nextlyhq/nextly/pull/3461) [`e496309`](https://github.com/nextlyhq/nextly/commit/e4963093989ba023037a04a3c29d7fd227077281) @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](https://github.com/nextlyhq/nextly/pull/3674) [`2c85704`](https://github.com/nextlyhq/nextly/commit/2c857041e20b6ac1822f85c7badbd9f9b194bc05) @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](https://github.com/nextlyhq/nextly/pull/3247) [`a380d69`](https://github.com/nextlyhq/nextly/commit/a380d69517ed39ffbe25f6a987a2cb0307fc86ea) @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](https://github.com/nextlyhq/nextly/pull/3735) [`fc98d95`](https://github.com/nextlyhq/nextly/commit/fc98d95b4704d9b4d4eb440c2762423ae569d26b) @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](https://github.com/nextlyhq/nextly/pull/3650) [`cae665e`](https://github.com/nextlyhq/nextly/commit/cae665e02b52aa1cd18ddb39cb303de9dc76e256) @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](https://github.com/nextlyhq/nextly/pull/3734) [`1390729`](https://github.com/nextlyhq/nextly/commit/139072955891049c9d3d4e6f78e3768e36897bc1) @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](https://github.com/nextlyhq/nextly/pull/3599) [`18ad2ff`](https://github.com/nextlyhq/nextly/commit/18ad2ffe0b4f65eef336d1d42e58bd85e6f80a86) @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](https://github.com/nextlyhq/nextly/pull/3627) [`d07cc3d`](https://github.com/nextlyhq/nextly/commit/d07cc3d5ba81f86eff57c8be5bd784792aa8a582) @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](https://github.com/nextlyhq/nextly/pull/3629) [`5b53f34`](https://github.com/nextlyhq/nextly/commit/5b53f34c210e8ae2a9f34a8aed9547c994b81c96) @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](https://github.com/nextlyhq/nextly/pull/3647) [`c29178f`](https://github.com/nextlyhq/nextly/commit/c29178f7709f831db5198abb42a98f27ea9d1cde) @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](https://github.com/nextlyhq/nextly/pull/3673) [`75f0bc1`](https://github.com/nextlyhq/nextly/commit/75f0bc142bfd2ae529954df5b6acab91e547742d) @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](https://github.com/nextlyhq/nextly/pull/3223) [`535571b`](https://github.com/nextlyhq/nextly/commit/535571bdaaf96566c086c443b1bc2513513f5c97) @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](https://github.com/nextlyhq/nextly/pull/3645) [`c797879`](https://github.com/nextlyhq/nextly/commit/c79787922ec744f5dd4c2a38c7c7bcd0cddb2856) @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](https://github.com/nextlyhq/nextly/pull/3630) [`4bd52cc`](https://github.com/nextlyhq/nextly/commit/4bd52cc60543f8826ceabea4272d7fc8c570a4f9) @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](https://github.com/nextlyhq/nextly/pull/3635) [`dd237c9`](https://github.com/nextlyhq/nextly/commit/dd237c945994bf9290aa623eba34190df1a592c1) @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](https://github.com/nextlyhq/nextly/pull/3731) [`bd5217e`](https://github.com/nextlyhq/nextly/commit/bd5217ea988a36ba4fda185c6994d3902ba5ece8) @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](https://github.com/nextlyhq/nextly/pull/3622) [`de75450`](https://github.com/nextlyhq/nextly/commit/de75450b5d79f6619cca5073c7ce6393a3b87be9) @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](https://github.com/nextlyhq/nextly/pull/3568) [`8974f12`](https://github.com/nextlyhq/nextly/commit/8974f128f3fabdea4db22f0141ec15ac8c197b7d) @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](https://github.com/nextlyhq/nextly/pull/3537) [`6fb1da8`](https://github.com/nextlyhq/nextly/commit/6fb1da8565d507874edd8db9346d8442bf7ffc4a) @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](https://github.com/nextlyhq/nextly/pull/3298) [`b370b9b`](https://github.com/nextlyhq/nextly/commit/b370b9b14c5f00556e0bf0def23a258aa7585ffb) @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](https://github.com/nextlyhq/nextly/pull/3675) [`2016d1e`](https://github.com/nextlyhq/nextly/commit/2016d1e37a6841b5c6464412d5c8f15592242402) @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](https://github.com/nextlyhq/nextly/pull/3681) [`145642f`](https://github.com/nextlyhq/nextly/commit/145642f7356176196db7d9246702de9ed05242ef) @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](https://github.com/nextlyhq/nextly/pull/3666) [`dc43a78`](https://github.com/nextlyhq/nextly/commit/dc43a786d589516ae242930fa86071fe8ad2ae8e) @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](https://github.com/nextlyhq/nextly/pull/3232) [`d44a678`](https://github.com/nextlyhq/nextly/commit/d44a6788aa31bb4eb4424c3e76406c1817305ad6) @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](https://github.com/nextlyhq/nextly/pull/3659) [`ca9eaed`](https://github.com/nextlyhq/nextly/commit/ca9eaed78e3b0a9b4a1c8fa81049fac68f0c0dca) @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](https://github.com/nextlyhq/nextly/pull/3661) [`1371c6e`](https://github.com/nextlyhq/nextly/commit/1371c6edbf33b9c3e2c52d04f56483f4b08d7bf8) @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](https://github.com/nextlyhq/nextly/pull/3695) [`cf30707`](https://github.com/nextlyhq/nextly/commit/cf3070798c96cb9e66e0d96acff4b7e53872d210) @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](https://github.com/nextlyhq/nextly/pull/3572) [`a74781c`](https://github.com/nextlyhq/nextly/commit/a74781c0a800aa4c509176f323df6123d1db8a6f) @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](https://github.com/nextlyhq/nextly/pull/3352) [`7d25b54`](https://github.com/nextlyhq/nextly/commit/7d25b54ced237fcace58ed2ce98df4e7f61b87cd) @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](https://github.com/nextlyhq/nextly/pull/3536) [`5529dd8`](https://github.com/nextlyhq/nextly/commit/5529dd8e3d0024b7f47ca0189ae29afb394e1deb) @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](https://github.com/nextlyhq/nextly/pull/3589) [`b2bbf33`](https://github.com/nextlyhq/nextly/commit/b2bbf330f4d35e0543f7737a91d2eb3a90a53fbc) @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](https://github.com/nextlyhq/nextly/pull/3667) [`5fadd8b`](https://github.com/nextlyhq/nextly/commit/5fadd8b99fe2cc59e9b9552dece293099074cf05) @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](https://github.com/nextlyhq/nextly/pull/3548) [`365f2fb`](https://github.com/nextlyhq/nextly/commit/365f2fb5fb5c89cfe2061c01d70916bd7b014a4d) @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](https://github.com/nextlyhq/nextly/pull/3595) [`f620f2b`](https://github.com/nextlyhq/nextly/commit/f620f2b2d546462cb9549b03a5940a4bc5d99a9c) @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](https://github.com/nextlyhq/nextly/pull/3424) [`3706d47`](https://github.com/nextlyhq/nextly/commit/3706d47ce54fe653788f84cd6b0bf647af4867f7) @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](https://github.com/nextlyhq/nextly/pull/3261) [`d56384f`](https://github.com/nextlyhq/nextly/commit/d56384f3dc0fc42fb1bf75aca166f5db5890148f) @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](https://github.com/nextlyhq/nextly/pull/3746) [`6106801`](https://github.com/nextlyhq/nextly/commit/6106801525192a5a70fea00e119f7dbfbc9578b0) @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](https://github.com/nextlyhq/nextly/pull/3608) [`1b9ab4e`](https://github.com/nextlyhq/nextly/commit/1b9ab4e43084e961037e2de89a71b902c7eda631) @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](https://github.com/nextlyhq/nextly/pull/3240) [`0c41751`](https://github.com/nextlyhq/nextly/commit/0c417514ce146f7dbcef6d6b091c0c3a40a3688e) @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](https://github.com/nextlyhq/nextly/pull/3771) [`6700652`](https://github.com/nextlyhq/nextly/commit/67006521ec5fd209c5c1c2ca0d3169929c4b0d92) @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](https://github.com/nextlyhq/nextly/pull/3657) [`08d39a5`](https://github.com/nextlyhq/nextly/commit/08d39a546ce5ec3e9d507c823a6571aa8f44fb39) @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](https://github.com/nextlyhq/nextly/pull/3660) [`87701b4`](https://github.com/nextlyhq/nextly/commit/87701b42e97857e1f4703b6947ca2209fd9ca074) @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](https://github.com/nextlyhq/nextly/pull/3580) [`e273902`](https://github.com/nextlyhq/nextly/commit/e2739025c83c13ef1fdb360984f342d47982df72) @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](https://github.com/nextlyhq/nextly/pull/3434) [`1e9176c`](https://github.com/nextlyhq/nextly/commit/1e9176c316688a192d68694ace3a03fac7223be2) @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](https://github.com/nextlyhq/nextly/pull/3775) [`4d1e362`](https://github.com/nextlyhq/nextly/commit/4d1e36272c41eaa8676e89a4949f9f5c7fc3cf2f) @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](https://github.com/nextlyhq/nextly/pull/3205) [`5290d41`](https://github.com/nextlyhq/nextly/commit/5290d4159b56c1f4f7572de9049c33851dd37a8f) @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](https://github.com/nextlyhq/nextly/pull/3685) [`ab1219a`](https://github.com/nextlyhq/nextly/commit/ab1219ab61f062dc27de986e2500851341c7ba6b) @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](https://github.com/nextlyhq/nextly/pull/3208) [`1f0369d`](https://github.com/nextlyhq/nextly/commit/1f0369d7ef4e4dd860250065f57475617aa89bf6) @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](https://github.com/nextlyhq/nextly/pull/3544) [`2bdb227`](https://github.com/nextlyhq/nextly/commit/2bdb22776a8a39dd184ad029d2c2f8713523cdf9) @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](https://github.com/nextlyhq/nextly/pull/3259) [`3cb6f24`](https://github.com/nextlyhq/nextly/commit/3cb6f2404703882cae857e34efaf1930d18f0f98) @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](https://github.com/nextlyhq/nextly/pull/3257) [`686cd63`](https://github.com/nextlyhq/nextly/commit/686cd633a91599706883bc96a799ccefaad02693) @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](https://github.com/nextlyhq/nextly/pull/3753) [`ad3bdcc`](https://github.com/nextlyhq/nextly/commit/ad3bdccc5744312ca11b1618498118bd648fc192) @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](https://github.com/nextlyhq/nextly/pull/3493) [`18fefbd`](https://github.com/nextlyhq/nextly/commit/18fefbd4f7dc7b7c902d79d125c5562bb322a966) @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](https://github.com/nextlyhq/nextly/pull/3274) [`25e4c1c`](https://github.com/nextlyhq/nextly/commit/25e4c1caa9c71f7e81f0d49555b884651b5878b9) @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](https://github.com/nextlyhq/nextly/pull/3236) [`2050739`](https://github.com/nextlyhq/nextly/commit/20507398d35da30dae5030f5681c654bf0fef8bc) @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](https://github.com/nextlyhq/nextly/pull/3686) [`c6eeda9`](https://github.com/nextlyhq/nextly/commit/c6eeda964fe8befcd3cbd52b1cdcdf74881a1748) @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](https://github.com/nextlyhq/nextly/pull/3665) [`1b5b66a`](https://github.com/nextlyhq/nextly/commit/1b5b66a67810d2458e2e9b5b9a8806eec6c2895c) @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](https://github.com/nextlyhq/nextly/pull/3694) [`dddc6fd`](https://github.com/nextlyhq/nextly/commit/dddc6fd47521e226a4b5e9d49b6c731056ae911d) @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](https://github.com/nextlyhq/nextly/pull/3378) [`e4693ac`](https://github.com/nextlyhq/nextly/commit/e4693ac08cbdfb490beb1ea9f0c42140f4403dc7) @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](https://github.com/nextlyhq/nextly/pull/3319) [`5c8f2c6`](https://github.com/nextlyhq/nextly/commit/5c8f2c69281275402ce616ca00279a533dc8ca97) @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](https://github.com/nextlyhq/nextly/pull/3067) [`61036c3`](https://github.com/nextlyhq/nextly/commit/61036c3adb95156c2c32fb0b705a7c6ac364370d) @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](https://github.com/nextlyhq/nextly/pull/3343) [`e3b4637`](https://github.com/nextlyhq/nextly/commit/e3b4637a305f4263458831f12c6e0e29449655c6) @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](https://github.com/nextlyhq/nextly/pull/3486) [`0fcfeb0`](https://github.com/nextlyhq/nextly/commit/0fcfeb0d5b0f13addc3bd2778852c2ccd99bb93f) @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](https://github.com/nextlyhq/nextly/pull/3051) [`bee3ff9`](https://github.com/nextlyhq/nextly/commit/bee3ff958d59a189a6dd62d16e4793b6069ec5bd) @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](https://github.com/nextlyhq/nextly/pull/3562) [`4e6b671`](https://github.com/nextlyhq/nextly/commit/4e6b671f339d80ab63627cae3526278aba11e6ab) @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](https://github.com/nextlyhq/nextly/pull/3619) [`249c74c`](https://github.com/nextlyhq/nextly/commit/249c74c6463fc8120c1ceb3137afb5b6a77671b9) @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](https://github.com/nextlyhq/nextly/pull/3725) [`b2cb31a`](https://github.com/nextlyhq/nextly/commit/b2cb31ae6d5d9f9aad6c24eb449de874c07bb268) @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](https://github.com/nextlyhq/nextly/pull/3523) [`e3360b2`](https://github.com/nextlyhq/nextly/commit/e3360b2ddefe5125d584041ea29ec13641d5471a) @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](https://github.com/nextlyhq/nextly/pull/3684) [`20807c5`](https://github.com/nextlyhq/nextly/commit/20807c5122f4e8fc869bd441086fa6211c0dcca0) @nextly-agent: The admin builds again: the table's held plugin registrations export states its type, as declaration emit requires.

- [#3766](https://github.com/nextlyhq/nextly/pull/3766) [`0ab7d79`](https://github.com/nextlyhq/nextly/commit/0ab7d7980c67c0effeea7337be2a38a75676c0b5) @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](https://github.com/nextlyhq/nextly/pull/3506) [`85cd7cd`](https://github.com/nextlyhq/nextly/commit/85cd7cd5086c3c93e0c4933280a7cd1ca3329dac) @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](https://github.com/nextlyhq/nextly/pull/3310) [`572d7ed`](https://github.com/nextlyhq/nextly/commit/572d7eda3762e75e1aace8f21ecc730ef057de0a) @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](https://github.com/nextlyhq/nextly/pull/3754) [`11fb131`](https://github.com/nextlyhq/nextly/commit/11fb131ffeee127dd4ca6a1bfa7bf02a3aabea43) @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](https://github.com/nextlyhq/nextly/pull/3555) [`69f8db5`](https://github.com/nextlyhq/nextly/commit/69f8db58fd0e83dfd4b9ec52491f321ed456cb4c) @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](https://github.com/nextlyhq/nextly/pull/3215) [`c6e029d`](https://github.com/nextlyhq/nextly/commit/c6e029d169c484e73dc772c281545cffedc3699a) @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](https://github.com/nextlyhq/nextly/pull/3488) [`2c9bf55`](https://github.com/nextlyhq/nextly/commit/2c9bf55465057a2f2d849a0727266b2ea150bb08) @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](https://github.com/nextlyhq/nextly/pull/3255) [`6d89981`](https://github.com/nextlyhq/nextly/commit/6d899819c3c4669753e5adc36a39e9e55dda13ea) @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](https://github.com/nextlyhq/nextly/pull/3655) [`d2b59d2`](https://github.com/nextlyhq/nextly/commit/d2b59d273149a2a7075e86d5b5a204ee68f06354) @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](https://github.com/nextlyhq/nextly/tree/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`

<!-- /release-notes -->

Previous release: [0.0.2-alpha.73](https://nextlyhq.com/changelog/0.0.2-alpha.73) · Next release: [0.0.2-alpha.75](https://nextlyhq.com/changelog/0.0.2-alpha.75)

## Earlier releases

Releases before 0.0.2-alpha.66 are listed in [Nextly's changelog on GitHub](https://github.com/nextlyhq/nextly/blob/main/packages/nextly/CHANGELOG.md).
