provident-storeroom 1.3.0 → 1.5.0

package/README.md

@@ -29,6 +29,10 @@ package's repository at
 `https://github.com/LittleKingsguard/Provident-Storeroom/blob/main/docs/guides/package-use.md`, which is where
 an edit belongs.
 
+**⟶ AND THE ONE FIGURE THIS PAGE CAN BE RIGHT ABOUT IS GENERATED AND ASSERTED, 2026-10-28 — `DEF-AC`'s third part, and `D-57`'s one surviving figure.** `RCA-8(g)` ANNOTATE-BESIDE: **every clause above stands BYTE-FOR-BYTE and is read THROUGH this one; nothing above moves.** **THE DEFECT THIS CLOSES: THIS PAGE DECLARED NO VERSION AT ALL** — a shipped document a consumer reads first, saying nothing about which release it describes — **so `scripts/publish.sh --figures` now GENERATES the line below from `bindings/js/package.json`'s `version` and REFUSES when it disagrees, exactly as it does at the guide's and the change list's own marked lines: three shipped documents, three version lines, one generator, one assertion.** **AND THE CUT-STATE IS NOT STATED HERE, OR ANYWHERE ELSE IN THIS PACKAGE'S DOCUMENTS** (`D-57`, the architect verbatim: *"Drop the cut-state"*): a document is sealed before the tag that would make its cut-state true, so **the cut-state is not a document's to state**; the record of what has been cut is the change list's, and it is past tense. **EVERY OTHER CLAIM OF THIS PAGE STANDS EXACTLY AS IT STOOD.**
+
+PUBLISH-README-VERSION-LINE: THE VERSION THIS README DESCRIBES IS `1.5.0`.
+
 ## The one entry
 
 ```js
@@ -66,6 +70,17 @@ reached INTERNALLY by the package's own resolution step and is not an entry poin
 | `removeConstraint(pair)` | `undefined` — **the one act that deletes an identity** |
 | `constraints()` | the registered pairs, `{address, id}` only — **no function, no order, no `enabled`** |
 
+**⟶ AND THE `delete` ROW'S ANSWER HAS A SECOND NON-ENUMERABLE MEMBER, 2026-10-29 — ITS COMMIT RECORD.** The row above
+names the `discarded` witness and stops there; **a `delete` is an editing verb with its own attempt, its own pass and
+its own commit, so the receipt ALSO carries `commit`, a NON-ENUMERABLE own member holding the same four-member
+`CommitRecord` a `K-2` returns — `attempt` · `op` · `triggered` · `pending` — and `null` on the arm that removed
+nothing.** **Measured on this checkout: `Object.keys(receipt)` reads `["address","tiers","triggered","op"]` — four —
+while `Object.getOwnPropertyNames(receipt)` reads six, `commit` and `discarded` being the two it does not list** — so
+a spread or `Object.assign` copy of a receipt loses BOTH, and nothing throws when it does. **Read either off the
+receipt itself.** **No member is added to the FOURTEEN and no enumerable shape moves.** (`D-57`; `D-55` item `3`;
+`index.d.ts`'s `DeleteRecord.commit`; the long-form reading — the adoption, the `pending` residue, the `file`-tier
+save and `K-4`/`K-5` by reference — is the shipped guide's `§7.8`, which is where those four follow-ons are stated.)
+
 **THE RECEIVER IS THE STORE, SO NO CALL CARRIES AN `instance` POSITION** (`surface.md §2.1` (e) item 3):
 `store.write(address, tier, value)` is the shape every method takes, and a leading `instance` is a SUPERSEDED
 SPELLING — wrong, not redundant. **AND NO OWN MEMBER IS A DATA MEMBER:** there is no `store.data`, no `state`
@@ -110,8 +125,10 @@ try {
 with an object literal, not `defineProperty`, not a getter, not on a prototype and not behind a `Symbol` — and
 **`Object.keys(caught)` reads exactly its three members in the form's own order, `["status","message","log"]`,
 length `3`, on EVERY arm.** **`[]` is its declared value where the failure's cause has no attempt at all, and
-every failure whose attempt exists carries that attempt's own entries — the kernel's six-member `LogEntry`
-records, with the `outcome` entry's `state` carrying the `KC` token where the constraint pass produced one**
+every failure whose attempt exists carries that attempt's own entries — the kernel's FIVE-member `LogEntry`
+records, with the `outcome` entry's `state` carrying the `KC` token where the constraint pass produced one** **⟶ AND IT IS
+FIVE SINCE `D-65`: `kind` · `id` · `opId` · `message` · `state` — the `seq` member is GONE, because a log entry's position
+IS its array index and a member restating the index was a second copy of a fact the array already carried.**
 (`index.d.ts`, `LogEntry`; `surface.md §2.5` items 3–4). **The `message` is generated from the code and the
 failing trigger's arguments**, never hand-authored at a call site.
 
@@ -126,6 +143,19 @@ JOURNAL ORDINAL.** `JournalOp.seq` orders the store's own record; this `seq` ord
 the two differ by design (a refusal's entry can carry `seq` `1` while the store's journal counter reads `41`). **The
 kernel's `state` token set is `KC-1`…`KC-9`, `KC-9` being the save arm's own; the store's status set has not moved.**
 
+**⟶ AND THE SECOND OF THOSE TWO THINGS IS WITHDRAWN AT THE MEMBER, 2026-10-28 — `D-65`: `LogEntry` CARRIES NO `seq`,
+AND AN ENTRY'S POSITION IS ITS ARRAY INDEX.** `RCA-8(g)` ANNOTATE-BESIDE: **every byte above stands BYTE-FOR-BYTE as
+the reading of its own date and is read THROUGH this clause — the withdrawn sentence is *"AN ENTRY'S `seq` IS THE
+POSITION OF THE ENTRY IN THAT LIST … the two differ by design"*, and it described a member that no longer exists.**
+**THE RULING, THE ARCHITECT, ONE WORD: *"Drop it"*** — `seq: log.length + 1` WAS the index of the entry being
+appended, a second copy of a fact the array already carries. **WHAT YOU READ NOW: FIVE members, `kind` · `id` ·
+`opId` · `message` · `state`** (declared at the same place the clause above declares them, and stated there beside
+its `seq` retirement), **and the position of an entry is `log.indexOf(entry)` or the index of the loop you are
+already in.** **`JournalOp.seq` IS STILL THE STORE'S OWN APPEND ORDINAL, so the distinction the sentence above drew
+has not disappeared — only the member that could be confused with it has**, and the two are now impossible to
+confuse for that reason. **So do not read `entry.seq` for an ordering, and do not read its absence as an entry that
+lost its place: the list's order is the commit's append order and the index is the place.**
+
 ## The status set is TWENTY, and open by design
 
 **`StoreStatus` carries TWENTY members, ranked `1`…`20`, plus the open escape arm `(string & {})`** — the union
@@ -199,9 +229,14 @@ repair failed on the re-run (`D-40`).
 
 **Durability is produced by a successful `file`-TIER WRITE ONLY** (`DD-28`, `D-32`). **So a BARE `file`-tier
 write persists**: `store.write(['k'], 'file', 1)` commits with no kernel attempt in the path, and a fresh
-`storeCreate` over the same `filePath` resolves the address. **A `delete` and a `rollback` perform no file I/O
-at any tier scope**, so a durable version deleted in memory stands again after a re-boot — that re-boot is the
-store's declared boot and not a defect.
+`storeCreate` over the same `filePath` resolves the address. **⟶ A `DELETE` NOW SAVES AND A `ROLLBACK` STILL DOES NOT, 2026-10-28.** The sentence this replaces said **both**
+performed no file I/O at any tier scope — **and that was measured false for a `delete` once it became an editing
+verb with its own attempt**: a `file`-tier delete's save is the terminal arm's at the record's own op, so
+**`delete(['k'], 'file')` followed by a fresh `storeCreate` over the same `filePath` answers `AddressNotFound`
+rather than the version it removed** (measured `{"a":1}` → `{}`, boot `1` → absent). **A `ROLLBACK` still performs no
+file I/O at any tier scope** — **a reversal appends no journal op (`M-9`), so its terminal arm has no op of its own
+to save at** — **and a durable version a reversal removed in memory therefore stands again after a re-boot, which is
+the store's declared boot and not a defect.**
 
 **A kernel-driven write's `file`-tier save is a DIFFERENT save of a different scope**: it is the package's
 terminal arm, performed on the passing arm alone, before any delivered listener body runs, keyed by the

package/RELEASE-NOTES.md

@@ -14,6 +14,12 @@ TAG ON IT.** **So this file now carries a section for the tree that is not cut (
 the section for the release that is (`§1.2.0`).** **No version is bumped, no manifest moves, and nothing in `§MAIN`
 claims to be installable.**
 
+**⟶ AND THE CUT-STATE IS DROPPED FROM THIS FILE, 2026-10-28 — `D-57`, THE ARCHITECT VERBATIM: *"Drop the cut-state."*** `RCA-8(g)` ANNOTATE-BESIDE: **the title line and every dated paragraph of this file stand BYTE-FOR-BYTE as the reading of their own date, THIS clause is the one that reads them, and not one byte is deleted.** **THE REASON IS STRUCTURAL AND IT WAS MEASURED THREE TIMES: A SHIPPED DOCUMENT IS SEALED BEFORE THE TAG THAT MAKES ITS CUT-STATE TRUE**, so every release packed before its tag ships a document denying itself, and a guard running in that release's own preflight can only ever confirm *"not cut"* — `1.2.0` shipped *"NOT CUT"*, `1.3.0` shipped *"`v1.3.0` DOES NOT EXIST"*, and this file's own head was stale within minutes of the tag that falsified it. **SO EVERY SENTENCE BELOW THAT CLAIMS WHETHER SOME VERSION IS OR IS NOT CUT — *"PREPARED — NOT CUT"*, *"no `v1.3.0`"*, *"nothing in this section is cut"*, *"the release is not cut"*, *"what is installed today is still `1.1.0`"*, and each reading printed beside them — IS READ THROUGH THIS CLAUSE: the cut-state is not a document's to state.** **WHAT SURVIVES IS THE ONE FIGURE A SHIPPED DOCUMENT CAN BE RIGHT ABOUT, AND IT IS GENERATED FROM THE MANIFEST AND ASSERTED BY THE PREFLIGHT:**
+
+PUBLISH-NOTES-VERSION-LINE: THE VERSION THIS CHANGE LIST DESCRIBES IS `1.5.0`.
+
+**AND THE TAG SET SURVIVES AS A RECORD OF RELEASES — PAST TENSE, A LIST OF WHAT HAS BEEN CUT, NEVER A CLAIM ABOUT THE CURRENT ONE** (the record stands in `§1.4.0` below — the section this file's head called `§main` until it was re-cut to name the version it prepares, 2026-10-28 — beside the section for the tree this file describes). (`D-57`; `DEF-AC` (b) — `scripts/publish.sh --figures` generates that line from `bindings/js/package.json`'s `version` and refuses on any disagreement, in this file, in `bindings/js/README.md` and in the shipped guide: three documents, three version lines, one generator, one assertion.)
+
 **THE ONE THING THIS DOCUMENT IS FOR: `1.1.0` IS A MINOR, AND THIS IS WHERE ITS BREAKING CHANGES ARE
 DECLARED.** `1.0.1` was published as a PATCH and it carried behaviour changes a patch may not carry. The
 architect ruled the remedy a MINOR — *"the next release is `1.1.0`"* (`strata/decisions.md` · `D-42` item `1`)
@@ -47,7 +53,63 @@ the value to assert against, not the crate's own `Cargo.toml` version.
 
 ---
 
-## §1.3.0 · **PREPARED — NOT CUT** — what `1.3.0` carries, ten commits past `v1.2.0`
+## §1.4.0 · **CUT AND PUBLISHED — tag `v1.4.0`** — what that release carries: the seven commits on `main` past `v1.3.0`, and the one figure this section states
+
+**⟶ THE HEADING THAT STOOD HERE WAS *"`## §1.4.0 · **PREPARED** — what `1.4.0` carries: the seven commits on `main` past `v1.3.0`, and the one figure this section states`"*, AND IT IS CORRECTED AT ITS OWN LINE, 2026-10-28.** `RCA-8(g)` ANNOTATE-BESIDE: **the withdrawn bytes are quoted above, every paragraph of this section below stands BYTE-FOR-BYTE as the reading of its own date, and nothing is deleted.** **THE DEFECT IS THE `DEF-AC` CLASS AT ITS THIRD ITERATION AND AT ITS SHARPEST: A HEADING THAT DENIED THE RELEASE ITS OWN TAG NAMES.** The tag set at this date reads `v1.0.0` · `v1.0.1` · `v1.1.0` · `v1.2.0` · `v1.3.0` · `v1.4.0`; **the tag `v1.4.0` names a tree whose `bindings/js/package.json` reads `"version": "1.4.0"` at its own bytes**, its five `optionalDependencies` pins read `1.4.0` with it, and the five platform manifests' `version` fields read `1.4.0` with them; and **a reader opening this file met *"PREPARED"* over a version the registry carries.** **SO THE HEADING NOW READS `CUT AND PUBLISHED — tag `v1.4.0``, which is a PAST-TENSE RECORD OF A RELEASE AND NOT A CLAIM ABOUT THE TREE YOU ARE READING** — the tag set is the record of what has been cut, and the state of the current tree's version is not a document's to state (`D-57`, and the head clause of this file, which stands). **AND WHAT THE SECTION BELOW DECLARES IS UNMOVED BY THE CORRECTION: the ancestor set (`D-56`), the `delete`'s own attempt and its `CommitRecord` (`D-57`), the five smaller items of `D-55`, and the one shipped sentence that all of it falsified — those are `1.4.0`'s content, they travelled in its tarball, and a consumer who installed `1.4.0` has them.** (`D-57`; the head clause of 2026-10-28 above; `git tag --list` and `bindings/js/package.json` read at their own bytes this date.)
+
+**⟶ THIS SECTION IS RE-CUT FROM THE HEADING IT STOOD UNDER, 2026-10-28, AND ITS FIGURES MOVED WITH THE ELEVEN CELLS.** `RCA-8(g)` ANNOTATE-BESIDE: **the heading that stood here was *"`## §main · **PREPARED** — the seven commits on `main` past `v1.3.0`, and the one figure this section states`"*, the withdrawn bytes are quoted there, and the four numbered items below stand BYTE-FOR-BYTE as the reading of their own date and are read THROUGH this clause.** **THE HEADING NOW NAMES THE VERSION THIS SECTION PREPARES — `1.4.0` — because the section below it, `§1.3.0`, is the change list of a release that IS cut, and a prepared section must say which version it prepares.** **AND IT STILL STATES THE VERSION AND NOT THE CUT-STATE, BECAUSE THE SECOND IS NOT A DOCUMENT'S TO STATE (`D-57`).**
+
+**THE VERSION THIS TREE CARRIES IS `1.3.0` AT ELEVEN SITES** — `bindings/js/package.json`'s `version`, its five `optionalDependencies` pins, and the five `bindings/js/platforms/*/package.json` `version` fields — **the artefact is stamped from that manifest by `bindings/js/build.rs`, so `version()` answers `1.3.0`, and no version bump is in any of the commits listed here.** **THE RECORD OF RELEASES, PAST TENSE — the tags this repository has cut, and nothing about the tree you are reading:** `v1.0.0` · `v1.0.1` · `v1.1.0` · `v1.2.0` · `v1.3.0`.
+
+**⟶ AND THE PARAGRAPH ABOVE IS CORRECTED AT THIS LINE, 2026-10-28 — ITS FIGURE WAS `1.3.0` AND IS NOW `1.4.0`.** `RCA-8(g)` ANNOTATE-BESIDE: **the paragraph above stands BYTE-FOR-BYTE as the reading of its own date (`v1.3.0`'s tag) and is read THROUGH this clause; not one byte of it is deleted.** **`bindings/js/package.json`'s `version` now reads `1.4.0`, its five `optionalDependencies` pins read `1.4.0` five times, and the five `bindings/js/platforms/*/package.json` `version` fields read `1.4.0` — ELEVEN CELLS, ONE VERSION, moved TOGETHER in this act — and `npm run build` stamps the artefact from that manifest, so `version()` answers `1.4.0` at the built artefact and at a package installed from it.** **AND THE TREE NOW STANDS NINE COMMITS PAST `v1.3.0`** — `git describe` reads `v1.3.0-9-gf579a5a` — **of which the two beyond the seven below change no behaviour**: `23ac519` regenerates the guide's cut-state sentence and `f579a5a` DROPS the cut-state from the shipped face, because `D-57` drops it. **THE TAG SET IS NOT TOUCHED BY THIS ACT AND REMAINS A RECORD OF RELEASES, PAST TENSE:** `v1.0.0` · `v1.0.1` · `v1.1.0` · `v1.2.0` · `v1.3.0`. **AND NOTHING IN THIS SECTION CLAIMS WHETHER `1.4.0` IS CUT: the cut-state is not a document's to state, and `D-57` is why.** **AND THE PARAGRAPH BELOW — *"THE TREE STANDS EIGHT COMMITS PAST THAT TAG"* — STANDS AS THE READING OF ITS OWN DATE AND IS READ THROUGH THIS CLAUSE TOO: the count is NINE, and the two beyond the seven are `23ac519` and `f579a5a`.**
+
+**THE TREE STANDS EIGHT COMMITS PAST THAT TAG** — `git describe` reads `v1.3.0-8-g8c0e671` — **and SEVEN of them change what this package does or what it declares.** **The eighth is `23ac519`'s regeneration of the guide's cut-state sentence, which is the sentence `D-57` drops and the reason it is dropped.** **THE SEVEN, DERIVED FROM THE TREE THEY LANDED ON, EACH STATED FOR A CONSUMER:**
+
+**1 · ★ A PAIR IS ASKED FOR ACTS BELOW IT — THE PASS'S SET WIDENED TO THE ACT'S ANCESTORS (`D-56`), BECAUSE THE VALUE READ AT A PREFIX CONTAINS ITS SUBTREE.** **The architect, verbatim: *"A listener/constraint should fire when the descendants of its targeted address node change, because the descendants become part of the object that is read from that address."*** **WHAT A CONSUMER SEES: a pair standing at `['tabs']` is now asked for a `delete` at `['tabs','landingPage']`** — it is handed the ACT's `address`, `tier` and `value`, so a refusal crosses as it would at its own address and the commit rolls back — **and the membership rule reads once: your pair is asked when THE ACT'S ADDRESS IS AT OR BELOW YOUR PAIR'S ADDRESS.** **A pair at a DESCENDANT of the act is still NOT asked, and its address then reads as absent.** **AND THE CONSEQUENCE THAT IS UNMISTAKABLE: a passing write now EMPTIES `pending`** — the pass's set now EQUALS the store's `triggered` set, which is exactly what the earlier exact-address rule refused to allow — **measured `1` → `0` on a passing write.** (`D-56`; `HL-8` item 1 and attempt-lifecycle `§2.4` item 5 (iv) are annotated beside in the guide, not rewritten.)
+
+**2 · A `delete` IS AN EDITING VERB — ITS OWN ATTEMPT KIND, ITS OWN PASS, AND A DELIVERY AFTER THE JUDGEMENT.** **WHAT A CONSUMER SEES:** the `delete`'s receipt now carries a **non-enumerable `commit` member** — the same four-member `CommitRecord` a write's `K-2` mints (`attempt`, `op`, `triggered`, `pending`) — **so a delete can be read back through `K-4` and `K-5`, which now answer BY REFERENCE where they refused `NO-REF` before**; the record is **ADOPTED** by the entry, which stands the delete's own receipt in the leg slot for the pass and restores the enclosing leg in a `finally`; the **`pending` residue is one entry** (the returned set minus the handles the delete's own pass checked off), and the delivery fires **THE RESIDUE** rather than the whole returned set; and a `file`-tier delete **SAVES** — the terminal arm saves the delete's own op, so a fresh boot answers `AddressNotFound` where the bytes used to stand. **A DELETE THAT REMOVES NOTHING MINTS NOTHING** (`D-3`), **and a `rollback` keeps no attempt**, because a reversal appends no journal op and a fabricated ref would be a lie. **THE COMMIT IS A SCOPE, A LOG'S HOME, A SAFE-STATE UNIT AND A RECORD — NOT A KERNEL ITEM** (`D-57`'s second half: the kernel's surface stays `K-1`…`K-6`, and `K-7` `commitRemoval` is owed only if a consumer must drive a delete's attempt directly, which none can). (`D-57`; `D-3`; `D-44`; `D-53`; `DEF-AN`.)
+
+**3 · FIVE SMALLER ITEMS, EACH A THING A CONSUMER SEES.** **A THROWN MESSAGE'S FORM IS IN THE LOG** (`D-55` item 1 · `DEF-AK`): the value a pair threw is PRINTED in the attempt's one `outcome` entry, named rather than silently stringified, and the crossed `message` stops claiming the value crosses. **AN ENTRY IS NEVER SHIPPED WITH AN EMPTY ADDRESS LIST** (`D-55` item 2 · `DEF-AH`). **A CLOSED RECORD IS SEALED AT HANDOFF** (`D-55` item 6 · `DEF-AO`): what a consumer holds is final. **THE DRAIN JUDGES THE STANDING STATE** (`D-55` item 6 · `DEF-AP`, and `D-54`'s withdrawn sentence): where two of your listeners each reverse inside one commit, the check judges the state the commit STANDS AT — both raises — and a pass that ends by throwing reaches the same judgement at the state the pass left. **AND A REFUSED EDIT UNDOES THE WHOLE COMMIT** (`D-55` · `DEF-AN`): a constraint-refused edit rolls back to the previous safe state with ALL edits in the commit undone — including a delete's. (`D-55`'s six clarifications; the four rows `dfa9fc7` settled; `strata/decisions.md` `D-55`.)
+
+**4 · AND A SHIPPED SENTENCE WAS FALSIFIED BY ALL OF IT, AND IS CORRECTED AT ITS OWN HOME.** **The package's `README.md` said a `delete` and a `rollback` both perform no file I/O at any tier scope.** **A `delete` SAVES NOW** — a `file`-tier delete left the bytes standing and a fresh boot read the old value; the terminal arm saves the delete's own op, and a failed save is the write's arm with `KC-9`. **A `rollback` still performs no file I/O, because it has no op of its own to save at** — and that half of the sentence was never in doubt. (`1090e1e`; `bindings/js/README.md`'s own 2026-10-28 clause.)
+
+## §1.5.0 · **PREPARED** — what `1.5.0` carries: the twenty-seven commits on `main` past `v1.4.0`, derived from the tree
+
+**⟶ THE HEADING THAT STOOD HERE WAS *"`## §1.5.0 · **PREPARED** — what `1.5.0` carries: the eleven commits on `main` past `v1.4.0`, derived from the tree`"*, AND ITS COUNT IS CORRECTED AT ITS OWN LINE, 2026-10-29.** `RCA-8(g)` ANNOTATE-BESIDE: **the withdrawn bytes are quoted above, every paragraph of this section below stands BYTE-FOR-BYTE as the reading of its own date, and nothing is deleted.** **THE COUNT MOVED BECAUSE THE TREE DID**: the section was written when `git describe` read `v1.4.0-11-g90f810c`, and **the sixteen commits after that reading — `c3c61ab` through `a3312b7` — carry the rulings and the code changes this section's items `5` through `8` declare.** **A HEADING THAT UNDERCOUNTS THE COMMITS IT PREPARES IS THE `DEF-AC` CLASS AT ITS MILDLEST AND IS CORRECTED RATHER THAN ANNOTATED AROUND, because the count is the one figure this section's own arithmetic prints.** (`D-57`; `git describe` at `v1.4.0-27-ga3312b7`.)
+
+**⟶ THIS SECTION IS NEW, 2026-10-28, AND IT STATES THE VERSION AND NOT THE CUT-STATE.** `RCA-8(g)` ANNOTATE-BESIDE: **no byte above moves and no byte of the sections below moves; this section is added beside them and is read through the same head clause as the rest of this file.** **THE FIGURE THIS SECTION MAY BE RIGHT ABOUT, AND ITS GENERATOR:** the version line at this file's head is generated from `bindings/js/package.json`'s `version` and asserted by `scripts/publish.sh --figures` in three shipped documents — **`1.4.0`, at eleven cells that move together and never singly**: the main manifest's `version`, its five exact `optionalDependencies` pins, and the five `bindings/js/platforms/*/package.json` `version` fields; and `bindings/js/build.rs` stamps the artefact from that manifest, so the built artefact's `version()` answers `1.4.0`. **AND THE TREE IS ELEVEN COMMITS PAST THE TAG THAT NAMES THOSE CELLS:** `git describe` reads `v1.4.0-11-g90f810c`, `git rev-list --count v1.4.0..HEAD` reads `11`, and **no version bump is in any of the eleven** — the manifest still reads `1.4.0` after all of them. **THE TAG SET IS A RECORD OF RELEASES, PAST TENSE, AND NOT A CLAIM ABOUT THIS TREE:** `git tag --list` answers `v1.0.0` · `v1.0.1` · `v1.1.0` · `v1.2.0` · `v1.3.0` · `v1.4.0`. **AND NOTHING IN THIS SECTION CLAIMS WHETHER `1.5.0` IS CUT: the cut-state is not a document's to state** (`D-57`; the head clause of this file; the `§1.4.0` correction above, which is the same defect met one section higher).
+
+**⟶ AND THAT PARAGRAPH'S TWO FIGURES ARE RE-READ AT THE TREE THIS SECTION PREPARES, 2026-10-29 — THE TREE IS TWENTY-SEVEN COMMITS PAST `v1.4.0`, AND THE ELEVEN CELLS READ `1.5.0`.** `RCA-8(g)` ANNOTATE-BESIDE: **the paragraph above stands BYTE-FOR-BYTE as the reading of its own date (`v1.4.0-11-g90f810c`) and is read THROUGH this clause; not one byte of it is deleted.** **THE COUNT:** `git rev-list --count v1.4.0..HEAD` reads `27` and `git describe` reads `v1.4.0-27-ga3312b7`, so its *"ELEVEN COMMITS"* is read as TWENTY-SEVEN. **THE VERSION: `bindings/js/package.json`'s `version` now reads `"1.5.0"`, its five exact `optionalDependencies` pins read `1.5.0` five times, and the five `bindings/js/platforms/*/package.json` `version` fields read `1.5.0` — ELEVEN CELLS, ONE VERSION, moved TOGETHER in this act — and `npm run build` stamps the artefact from that manifest, so `version()` answers `1.5.0` at the built artefact AND at a package installed from it.** **SO ITS SENTENCE *"no version bump is in any of the eleven — the manifest still reads `1.4.0` after all of them"* IS THE READING OF ITS OWN DATE, and the bump is THIS preparation's.** **AND THE TAG SET IS UNMOVED BY THE BUMP AND STILL A RECORD OF RELEASES, PAST TENSE:** `git tag --list` answers `v1.0.0` · `v1.0.1` · `v1.1.0` · `v1.2.0` · `v1.3.0` · `v1.4.0` — **no `v1.5.0` among them** — **and nothing in this section claims whether `1.5.0` is cut** (`D-57`; the head clause of this file).
+
+**THE ELEVEN, DERIVED FROM THE TREE THEY LANDED ON, EACH STATED FOR A CONSUMER — AND THE HONEST SHAPE OF THE ELEVEN IS `3 + 8`.** **THREE OF THEM MOVE THE PACKAGE**: `d862448` carries `D-58` (*"No insight into a running commit, and nothing retained after the handoff"*), `85b0174` carries `D-63` (*"Bump the mark when a sweep ends valid: the restore target is the last validated state"*), and `90f810c` carries `D-65` (*"Drop seq from the log entry: the array index is the position"*). **THE OTHER EIGHT RECORD RULINGS AND MOVE NO BEHAVIOUR** — `e5acd49` (`D-58`), `9b58c4a` (`D-59`), `0f113bf` (`D-60`), `e152c0b` (`D-61`), `15444fd` (`D-62`), `8dd2593` (`D-63`), `47ec840` (`D-64`), `b9936ac` (`D-65`) — each of which is a ruling written down beside the code that implements it, and none of which a consumer can observe except by reading them.
+
+**⟶ AND THE SAME ARITHMETIC IS DONE AGAIN FOR THE WHOLE TWENTY-SEVEN, 2026-10-29 — THE HONEST SHAPE IS `6 + 16 + 5`.** `RCA-8(g)` ANNOTATE-BESIDE: **the paragraph above stands BYTE-FOR-BYTE as the reading of its own date and is read THROUGH this clause; its `3 + 8` is kept and its METHOD is reused rather than replaced — each of the twenty-seven is read at the paths it touched and sorted by what those paths are.** **SIX OF THE TWENTY-SEVEN MOVE THE PACKAGE** — a line under `bindings/js/src/` or `src/store.rs` changes, so a consumer can observe it: `d862448` (`D-58`: the log reader's live arm refuses, and the closed record is dropped to its four members), `85b0174` (`D-63`: the restore mark bumps when a sweep ends valid), `90f810c` (`D-65`: `seq` leaves `LogEntry`), `c3c61ab` (`D-66`: the pass asks a descendant the act touched), `3384d2e` (the touched set made symmetric: a path that disappears changed as surely as one that appears), and `6fd15a7` (`D-69`: the registration is restored, so the store's `triggered` names both kinds and the pass FILTERS it instead of walking its own registry). **SIXTEEN ARE RECORD RULINGS AND MOVE NO BEHAVIOUR** — each writes `strata/decisions.md` and no other path: `e5acd49` (`D-58`), `9b58c4a` (`D-59`), `0f113bf` (`D-60`), `e152c0b` (`D-61`), `15444fd` (`D-62`), `8dd2593` (`D-63`), `47ec840` (`D-64`), `b9936ac` (`D-65`), `535b56a` (`D-66`), `948dcde` (`D-67`), `5fa84e6` (`D-68`), `c37adae` (`D-69`), `2ba405e` (`D-70`), `aaedc73` (`D-71`), `5331993` (`D-72`) and `92d2ec6` (`D-73`). **AND FIVE CARRY DOCUMENTS AND MOVE NO CODE** — the guide, this change list and the `docs/L1` records: `7e81e7f` (this change list, the guide and the L1 declarations regenerated to the tree), `a1c65d9` (`D-70`'s rule of use declared), `80c2ca7` (the reach's two readings reconciled and the three asymmetries declared), `fc81fd3` (`D-71`'s independence and `D-72`'s nesting declared) and `a3312b7` (`D-73`'s throw and its consequence declared). **`6 + 16 + 5 = 27` ✓ — the count is the whole of the twenty-seven past `v1.4.0`, and no commit is counted twice.**
+
+**1 · ★ THE RESTORE MARK BUMPS WHEN A SWEEP ENDS VALID — THE RESTORE TARGET IS THE LAST VALIDATED STATE, NOT THE STATE THE COMMIT OPENED AT (`D-63`).** **THE ARCHITECT, VERBATIM: *"After the constraint sweep ends in a valid state, bump the restore mark. The passing constraint state marks the new next valid state."*** **`AT `1.4.0`:** a refused edit rolled the commit back to the state it OPENED at — every edit the commit made was undone, a successful write's included. **NOW:** the restore is told a POSITION and the position MOVES FORWARD — it starts where the commit opened and it moves to the store's own journal position at every constraint sweep that ends valid, **before the listeners are delivered.** **WHAT A CONSUMER SEES, IN THE THREE ARMS THE RULING'S TERM OF ART MAKES DIFFERENT: a VALIDATED EDIT STANDS against a later refusal; a REPAIR'S WRITE does not stand**, because a repair's write is atomic with the write that asked for it and the sweep that follows judges the pair together — **and a LISTENER'S WRITE SURVIVES**, because the delivery runs after the bump and the sweep that validated it is the sweep the mark now names. **So *"the state it opened at"* is now the answer to exactly one case — a commit whose constraint sweep never passed — and it is `1.4.0`'s behaviour there and stays.** (`D-63`; `D-38`'s restore; the `DEF-AN` measurement, whose pair refuses on the FIRST check so nothing moves the mark and its reading is unchanged; `tests/e2e/discard-witness.mjs`'s `W12` arms `DW-12.1`–`DW-12.4`, with the re-derived readings in `tests/e2e/in-commit-restart.test.mjs`, `tests/e2e/direct-pass-restart.test.mjs`, `tests/e2e/downstream-claims.test.mjs` and `tests/e2e/def-ae-restore-mark.test.mjs`.)
+
+**2 · ★ `seq` IS DROPPED FROM `LogEntry` — SIX MEMBERS TO FIVE, `kind` · `id` · `opId` · `message` · `state`, AND THAT IS A BREAKING SHAPE CHANGE FOR A TYPED CONSUMER.** **THE RULING, THE ARCHITECT, ONE WORD: *"Drop it"*** (`D-65`) — and `DEF-AI`'s own demand had offered the route: *"mint `seq` from the attempt's counter, **or omit the member**."* **THE REASON IS THE ONE THIS FILE KEEPS MEETING AT A SMALLER SCALE: `seq: log.length + 1` IS THE INDEX OF THE ENTRY BEING APPENDED, a second copy of a fact the array already carries** — the same class as a hand-maintained allowlist, a hand-named runner chain or a hand-transcribed census. **WHAT A CONSUMER SEES:** a log entry carries **five** own members and **`entry.seq` is `undefined`**; **the position survives as the index and is asserted rather than assumed** — `log[0]` is the entry, `log.indexOf(entry)` answers its position, and a commit's entries run `0..n-1` continuously across its attempts. **A TYPED CONSUMER READING `entry.seq` MEETS A COMPILE ERROR, WHICH IS THE HONEST FORM OF THIS CHANGE**; a JavaScript consumer reading it meets `undefined`, and **`JournalOp.seq` IS UNMOVED** — the store's own append ordinal is a different subject and is now impossible to confuse with the commit's, because the commit's no longer has a member to be confused with. (`D-65`; `index.d.ts`'s `LogEntry`; `bindings/js/README.md` and the shipped guide each carry the retirement at their own home.)
+
+**3 · NO INSIGHT INTO A RUNNING COMMIT, AND NOTHING RETAINED AFTER THE HANDOFF (`D-58`).** **THE ARCHITECT, VERBATIM: *"The client does not need any insight into the current state of a commit/attempt before it completes. Don't expose any of it. After a commit/attempt resolves/rejects, the store does not need to retain the message log or other client-returned data. Don't retain it."*** **WHAT A CONSUMER SEES, IN TWO PARTS. (i) `K-4` REFUSES A LIVE ATTEMPT WITH `KC-7`**, the same member `K-5` already used, in the same shape and the same message family — so an in-flight list is no longer a thing you can read at all. **(ii) THE CLOSED RECORD IS `{attempt, ops, outcome, rollback}` AND THE LOG IS LET GO**: the record a commit resolves or rejects with carries those four and no message list, and the entries on the refusal you caught (or on `report`'s return) are **the only copy** — sealed at the handoff. **WHAT THAT COSTS, SAID PLAINLY:** on an arm whose handoff carries no list at all — a repair body that throws, and a PASSING `write`, whose answer is `{op, watched, triggered}` and has never carried one — the entries are no longer readable after the call. **That is the ruling's price and not a defect.** (`D-58`; `d862448`; `tests/e2e/discard-witness.mjs`'s `DW-11.1`–`DW-11.4`, each RED under its own revert.)
+
+**4 · AND THE TWO HEADLINES A CONSUMER MEETS THAT ARE NOT THE ELEVEN'S, NAMED SO NOBODY ATTRIBUTES THEM TO `1.5.0`.** **`D-56`'s ancestor set and the `delete`'s own attempt with its `CommitRecord` are `§1.4.0`'s content and travelled in the `1.4.0` tarball** — `4449a93`, `1d23abc` and `1090e1e` are all ancestors of the tag `v1.4.0`, and the section above declares them in full. **THEY ARE RESTATED HERE ONLY AS THE FACTS A `1.5.0` READER STILL MEETS, WITH THEIR TWO CONSEQUENCES NAMED BECAUSE THEY ARE THE ONES A CONSUMER TRIPS OVER:** **① a pair is asked for acts at or below its own address — so a pair at `['window','tabs']` IS asked for a `delete` at `['window','tabs','landingPage']`**, because the value read at a prefix contains its subtree; **and because the pass's set now EQUALS the store's `triggered` set, a passing write now EMPTIES `pending`** (measured `1` → `0`) — the handles the pass checked off are exactly the handles the record carried. **② a `delete` is an editing verb with its own attempt, its own pass and its own `CommitRecord`**, whose four follow-ons are the record's ADOPTION by the entry, the `pending` residue, the `file`-tier SAVE, and `K-4`/`K-5` answering a delete's record BY REFERENCE where they refused `NO-REF` before. **AND NO KERNEL ITEM IS OWED FOR IT: `K-7` `commitRemoval` is owed only if a consumer must drive a delete's attempt directly, and none can — the verb is the surface** (`D-57`'s second half; the kernel's surface stays `K-1`…`K-6`). (`D-56`; `D-57`; `D-3`; `D-44`; `D-53`; `§1.4.0`'s items 1 and 2, which declare both in full.)
+
+**5 · ★ ONE REGISTRATION, ONE REACH — A CONSTRAINT AND A LISTENER ARE THE SAME MECHANICAL THING TO THE STORE, `triggered` NAMES BOTH KINDS IN ONE LIST, AND THE PASS FILTERS IT RATHER THAN WALKING A REGISTRY OF ITS OWN (`D-56` · `D-66` · `D-67` · `D-68` · `D-69`).** **THE ARCHITECT, VERBATIM** (`D-68`): *"a constraint is mechanically the same as a listener from the perspective of the rust store triggers. The distinction is whether it is registered as a constraint (and thus run in the constraint loop and expecting the constraint signature format) or as a listener (and thus running after constraints and not being confined to the constraint signature)"*. **WHAT A CONSUMER SEES, IN FOUR SENTENCES.** **(i) ONE PREDICATE, COMPUTED WHERE THE VERSIONS LIVE:** a registration fires when **its address is a PREFIX of the act's OR the act TOUCHED it** — the touched set being the written value's paths unioned with what it replaced, and, for a `delete`, the whole subtree it removed — so **a listener bound at a strict descendant of a deleted address FIRES** where the prefix-only rule never reached it, and a pair standing there is ASKED. **(ii) ★ A PAIR AT AN ANCESTOR IS ASKED FOR A DESCENDANT'S ACT, AND SO IS A LISTENER:** a pair at `['window','tabs']` is asked for a `delete` at `['window','tabs','landingPage']`, and its refusal crosses and rolls the delete back — because the value read at a prefix contains its subtree (`D-56`, whose `1.4.0` half is `§1.4.0` item 1) — **while a LISTENER bound at that ancestor fires for the same act, which the prefix rule never had to be taught.** **WHAT THIS RELEASE ADDS TO THAT DIRECTION IS THE REVERSE ONE**: `D-67` measured the listener SILENT on a touched descendant while the pass asked the pair standing there, and `D-69`'s restored registration closed it — **so the two kinds now share ONE reach, computed in Rust where the per-tier versions live.** **(iii) A PAIR AT A DESCENDANT IS ASKED ONLY WHEN THE ACT TOUCHED IT:** `write(['a','b'], {c,d})` asks `['a','b','c']` and `['a','b','d']` and **not** `['a','b','e']` — the criterion is TOUCHED and not "descendant" (`D-66`). **(iv) AND THE ELEMENT CARRIES NO KIND**, because **a registration is a HANDLE AND A BODY and a constraint already has both** — its `id` is the handle (`D-29`) and its `constraint` is the body (`D-26`), so the inert listener body the old `store.register(home, noopListener)` fabricated does not return (`D-69`). **WHAT THAT MEANS FOR YOU: `triggered` and `pending` name listener handles AND constraint `id`s in ONE list, and which is which is your own registry's answer.** (`D-56`; `D-66`; `D-67`; `D-68`; `D-69`; `6fd15a7`; `c3c61ab`; `3384d2e`; the guide's `§6.3` item 2, `§6.4` and `§7.6`–`§7.9` clauses of the same date; `tests/e2e/discard-witness.mjs`'s `DW-13`/`DW-14` cells.)
+
+**6 · ★ `pending` EMPTIES ON A PASSING WRITE — BECAUSE THE PASS'S SET NOW EQUALS THE STORE'S FIRED SET.** **WHAT MOVES:** `record.pending` is seeded whole from the store's `triggered` set and every handle the pass EVALUATES is checked off by identity, so **the CONSTRAINTS the store named leave `pending` as the pass passes them and the member reads `[]` on an arm whose fired set is constraints only** — *measured `1` → `0`* — **and a LISTENER's handle is the one element that STAYS, because the pass evaluates constraint rows and a listener is the DELIVERY's work (measured at `K-2` `['anc-pair','watch-child']` → after the pass `['watch-child']`).** **WHAT IT MEANS, SAID PLAINLY: `pending` IS NO LONGER A LIST OF "WHAT I STILL OWE A DELIVERY TO" — IT IS THE LIST OF HANDLES THE PASS DID NOT EVALUATE.** A non-empty `pending` therefore means one of two things and only two: **the write FAILED** (the record's `pending` is the whole returned set, because a failing arm checks nothing off), **or a handle stands in `triggered` that the pass holds no row for** — the one reachable state being a registration whose own body refused it at the registration instant (`ConstraintRefusedAtRegistration`, state `2`), which leaves the store-side entry standing, fires nothing, silently. **AND AT `K-2` THE MEMBER NOW CARRIES BOTH KINDS**: a write whose pair stands at a TOUCHED descendant and whose listener stands at an ancestor carries **`2`** elements at `K-2` where the prefix-only composition carried **`1`**, and **`1`** after the pass (the listener's handle, which is the delivery's work and never the pass's). (`D-56`; `D-69`; `6fd15a7`; the guide's `§6.4` clauses of the same date; `tests/e2e/discard-witness.mjs`'s `DW-14.3`/`DW-14.4`.)
+
+**7 · ★ A DERIVED ADDRESS IS NOT AN ADDRESS — AN INDEX INSIDE A COLLECTION IS DERIVED, AND A REGISTRATION THERE IS A REGISTRATION ON A VALUE THE STORE NEVER WROTE (`D-70`).** **THE ARCHITECT, VERBATIM:** *"A constraint/listener that cares about a derived value like the vec index should listen to the vec, not the contained node"*. **WHAT A CONSUMER SEES:** `delete(['v',0])` moves `{b:2}` from `['v',1]` to `['v',0]`, **and a listener at `['v',1]` does not fire** — correctly, because **the store wrote `['v',0]` and replaced nothing at `['v',1]`**, and the `triggered` list is right to be empty. **THE RULE: register at the CONTAINER (`['v']`) and READ what you care about** — a container listener fires once, is handed the ACT's address `['v',0]`, and its body's read at `['v']` answers the renumbered collection. **AND THE TWO KINDS HAVE DIFFERENT JOBS, WHICH IS THE SENTENCE TO CARRY AWAY: IF YOUR CALLBACK CHANGES THE STORE IT IS A CONSTRAINT OR A REPAIR; IF IT TELLS THE WORLD IT IS A LISTENER** — *"Functions that automatically produce changes in the stored data should be written as constraint/repair, not as listeners, because constraint/repair has loop guards while listeners don't"*, and *"The use case for listeners is for updating external code with new data"*. **NO MEMBER, STATUS, KERNEL ITEM OR BOUND MOVES: this is a rule of USE over a surface already measured.** (`D-70`; `a1c65d9`; `80c2ca7`; the guide's `§7.9` of the same date; `tests/e2e/discard-witness.mjs`'s `DW-15.1`–`DW-15.3`.)
+
+**8 · ★ A LISTENER IS INDEPENDENT OF YOUR COMMIT, AND DELIVERY NESTS — its refusal is CONTAINED, its THROW is NOT, and the windows are nested synchronous calls on one thread (`D-71` · `D-72` · `D-73`).** **THE INDEPENDENCE, VERBATIM** (`D-71`): *"A listener is independent of the commit record of the triggering caller. The caller does not need to know about the outcome of the listeners."* **SO: a listener runs in its own commit, its OUTCOME IS THAT COMMIT'S, and a listener's refusal does NOT fail the write that fired it** — your write already passed every constraint and already answered before the delivery ran. **AND THE THROW IS THE EXCEPTION, BY RULING** (`D-73`, verbatim: *"Keep the throw so that the client can log errors cleanly"*): **a listener that throws makes YOUR write throw the listener's own error, identity equal, and ANSWER NOTHING — while its DATA HAS ALREADY LANDED** (the commit resolved before its delivery ran; what the throw takes away is the answer, not the write). **THE PRACTICAL HAZARD, WRITTEN: a client that retries on error RE-APPLIES A WRITE THAT ALREADY SUCCEEDED**, and the error carries no depth, handle or address — *"A contained throw is an error nobody can log"* is the ruling's reason, and **a listener body's own `catch` is the only containment arm there is.** **AND THE NESTING** (`D-72`): `outer write → its commit → its pass → its delivery → listener A → A's write (a NEW commit) → A's pass → A's delivery → listener B → …` — **windows live at once, NESTED, every level a synchronous call**, so *"interleaving"* is **nested suspension**: A's whole chain runs to completion before the window that fired it invokes its next listener. **FOUR PROPERTIES, NONE DECLARED ANYWHERE UP THE STACK:** **depth is UNBOUNDED** (no counter, no cap, no instrument); **the CROSS-WINDOW ORDER is real and undeclared** (a nested chain precedes the window's next listener — the machine provides it and no clause promises it); **RE-ENTRANCY IS UNAVOIDABLY OPEN** (a listener that writes at the address it was delivered for fires itself again); **and NOTHING ABOVE SEES BELOW** — a chain that fails at depth three is indistinguishable, to the original caller, from one that never ran, **except by the throw, which crosses every hop as the same error object.** **MEASURED 2026-10-29 ON THIS CHECKOUT, THROUGH THE PUBLISHED ENTRY, ALL THREE WAYS:** the throw (`write(['a'])` threw the listener's `Error`, `===` true, and answered `undefined`, with `['a']` reading `1`); the containment beside it (a listener's refused write crossed nothing, the caller's record carried no status and no `log`, and `['b']` read ABSENT, while the same caller writing `['b']` directly WAS refused); and the depth-two throw (surfacing first at the inner write, then reaching the original caller with identity preserved, and the original write unanswered — while a listener body that catches instead leaves the original write ANSWERING ITS OWN RECORD). (`D-71`; `D-72`; `D-73`; `fc81fd3`; `a3312b7`; the guide's `§6.5`, `§6.5a` and `§6.6` of the same date.)
+
+**NO VERSION BUMP IS PROPOSED BY THIS SECTION AND THE ELEVEN VERSION CELLS STAY AT `1.4.0` — AND WHETHER `1.5.0` IS CUT IS NOT WRITTEN HERE, BECAUSE IT IS NOT A DOCUMENT'S TO WRITE.**
+
+**⟶ AND THE FIRST OF THOSE TWO CLAUSES IS SUPERSEDED BY THIS PREPARATION, 2026-10-29 — THE BUMP IS MADE, THE SECOND CLAUSE IS NOT, AND THE THREE ARE NOW SIX.** `RCA-8(g)` ANNOTATE-BESIDE: **the paragraph above stands BYTE-FOR-BYTE as the reading of its own date and is read THROUGH this clause; its second half — *"whether `1.5.0` is cut is not written here, because it is not a document's to write"* — is UNMOVED and governs every clause of this section.** **SUPERSEDED: *"NO VERSION BUMP IS PROPOSED BY THIS SECTION AND THE ELEVEN VERSION CELLS STAY AT `1.4.0`"* — the bump IS this preparation's, and the eleven cells read `1.5.0`** (the clause at this section's head states the manifest, the pins, the five platform manifests and the rebuilt artefact's `version()`; `scripts/publish.sh --figures` asserts the one generated line in three shipped documents). **AND ITS LAST SENTENCE IS RE-READ TOO: *"THE THREE COMMITS THAT MOVE THE PACKAGE"* reads SIX** — `d862448`, `85b0174`, `90f810c`, `c3c61ab`, `3384d2e` and `6fd15a7` — **because the arithmetic above re-sorts all twenty-seven and six of them change a line the package ships.** **The honesty the paragraph declares is unmoved: a consumer can read every commit that moves the package before installing a release that carries them.** **The three commits that move the package are declared here so that a consumer can read them before installing a release that carries them, and so that no reader has to infer them from a tarball's contents** — the `DEF-AC` honesty this whole file has been corrected toward, and the same honesty the corrected heads above owe.
+
+---
+
+## §1.3.0 · **CUT AND PUBLISHED — tag `v1.3.0`** — what that release carries, ten commits past `v1.2.0`
+
+**⟶ THE HEADING THAT STOOD HERE WAS *"`## §1.3.0 · **PREPARED — NOT CUT** — what `1.3.0` carries, ten commits past `v1.2.0``"*, AND IT IS CORRECTED AT ITS OWN LINE RATHER THAN ANNOTATED AROUND, 2026-10-28.** `RCA-8(g)` ANNOTATE-BESIDE: **the withdrawn bytes are quoted above, the section's body below stands BYTE-FOR-BYTE as the reading of its own date, and every reading in it that says the release is not cut is read THROUGH the head clause.** **THE DEFECT: the heading denied the release the tag names — `git tag --list` answers `v1.3.0`, the tag names a tree whose `bindings/js/package.json` reads `"version": "1.3.0"` at its own bytes, and the registry carries `1.3.0` — so a reader opening this file met *"PREPARED — NOT CUT"* over a published version.** **That is the `DEF-AC` class one level in, and it is the third iteration of the same class; `D-57` is the ruling that ends the recurrence.** (`D-57`; the head clause above.)
 
 **★ THIS SECTION DESCRIBES A TREE NOTHING CAN INSTALL, AND IT IS MARKED BEFORE IT SAYS ANYTHING ELSE, BECAUSE A MARK
 ADDED AFTERWARDS IS THE DEFECT THIS FILE JUST CORRECTED ONE SECTION DOWN.** **THE PUBLISHED RELEASE IS `1.2.0`**: `git

package/index.d.ts

@@ -337,9 +337,10 @@ export type StoreStatus =
   | (string & {});
 
 /**
- * **THE KERNEL'S OWN LOG ENTRY** — *"exactly six members — `seq` · `kind` · `id` · `message` · `opId` ·
- * `state`"* (`docs/specs/storeroom-constraints/kernel-surface.md §2.5` item 1, whose member set is CLOSED:
- * *"a seventh member of `LogEntry` … is not a variation, it is a different shape"*). **DECLARED HERE ONLY
+ * **THE KERNEL'S OWN LOG ENTRY** — *"exactly FIVE members — `kind` · `id` · `message` · `opId` · `state`"*
+ * (`docs/specs/storeroom-constraints/kernel-surface.md §2.5` item 1's shape, read through `D-65` of 2026-10-28;
+ * its member set is CLOSED: *"a seventh member of `LogEntry` … is not a variation, it is a different shape"*).
+ * **DECLARED HERE ONLY
  * AS THE ELEMENT SHAPE OF THE FAILURE'S `log` MEMBER, AND MINTED BY NO CLAUSE OF THIS UNIT**: an attempt's
  * message log entries are the KERNEL'S records, carried VERBATIM, and no flattening is declared — a client
  * that reads one reads the kernel's own entry.
@@ -352,20 +353,21 @@ export type StoreStatus =
  * uses the new commit's message log. Constraints/Repairs should always use the same commit. Listeners should open
  * a new commit, because the triggering commit already passed constraints"*** (`strata/decisions.md` · `D-53`).
  * **SO ONE COMMIT'S WORK IS ONE LIST**: a write, the constraint passes that judged it, a repair's own write and
- * the re-run after it all append to the same array, `seq` is *"the ordinal of the list it stands in"* and it runs
- * `1..n` CONTINUOUSLY across those attempts, and **the `log` a refusal crosses with IS that array** — which is what
+ * the re-run after it all append to the same array, **each entry standing at its own INDEX** and the list running
+ * `0..n-1` CONTINUOUSLY across those attempts, and **the `log` a refusal crosses with IS that array** — which is what
  * `DEF-AK`'s *"one inner refusal, two hosts"* measures and what `D-52`'s merge question dissolved into. **A
  * LISTENER'S WRITE IS THE ONE THAT STARTS A FRESH LIST**, because the commit that triggered it has already passed
  * its constraints and what the listener does is a new question.
  *
- * **⟶ AND WHAT `seq` IS TRUE OF IS SAID PLAINLY HERE, 2026-10-28 — `DEF-AI`, MEASURED.** **`seq` is the position
- * of the entry in the commit's own message log; it is not the store's journal ordinal, and the two differ by
- * design.** The kernel mints it as `log.length + 1` on the one list its commit appends to
- * (`bindings/js/src/entry/kernel-foundations.mjs`), so a refusal's entry can carry `seq` `1` while the store's
- * own journal counter reads `41`. **READ THE TWO AS TWO ORDINALS WITH TWO HOMES**: `JournalOp.seq` is the
- * STORE's append ordinal and orders the store's record; this `seq` orders the COMMIT's message log and nothing
- * else. **A consumer that compares them compares two different subjects, and no reading of this declaration
- * says the first equals the second.**
+ * **⟶ AND THE MEMBER THAT USED TO CARRY THAT POSITION IS GONE, 2026-10-28 — `D-65`: THE ARRAY INDEX IS THE
+ * POSITION.** `RCA-8(g)` ANNOTATE-BESIDE: **the clause below stands BYTE-FOR-BYTE as the reading of its own date
+ * and is read THROUGH this one; what it said of `seq` is RETIRED, not rewritten.** **THE RULING, THE ARCHITECT,
+ * ONE WORD: *"Drop it"*** (`strata/decisions.md` · `D-65`) — and `DEF-AI`'s own demand had offered the route:
+ * *"mint `seq` from the attempt's counter, **or omit the member**."* **THIS DECLARATION OMITS IT.** A log entry
+ * no longer carries `seq`: **the member is gone, the position is the array index, and there is no second copy of
+ * it to disagree with the journal's ordinal.** **`JournalOp.seq` IS UNMOVED AND IS STILL A DIFFERENT SUBJECT** —
+ * the store's own append ordinal, ordered in the store's record — **and the two are now impossible to confuse,
+ * because the one that named the commit's list is no longer there to be read.**
  *
  * **AND `state`'S DOMAIN IS `KC-1`…`KC-9`, NOT `KC-1`…`KC-8`.** **`D-53`'s THIRD RULING — *"Open the token
  * set"* — gives the SAVE ARM a token of its own (`KC-9`)**, so that a `file`-tier save that fails at the terminal
@@ -375,7 +377,6 @@ export type StoreStatus =
  * never `status`, exactly as every `KC` token does, so the closed status set keeps its `20` members and its ranks.
  */
 export interface LogEntry {
-  readonly seq: number;
   readonly kind: 'constraint-check' | 'repair-run' | 'commit' | 'outcome';
   readonly id: string | null;
   readonly message: string;
@@ -520,14 +521,49 @@ export interface DeleteRecord {
    * journal entry, so there is no op to carry: **nothing is named because nothing was destroyed.**
    */
   readonly op: JournalOp | null;
+  /**
+   * **⟶ ADDED 2026-10-29 — THE COMMIT RECORD THIS ACT MINTED, THE IDENTITY THE WHOLE COMMIT'S MACHINERY IS
+   * KEYED BY** (`D-55` item `3`; `kernel-surface.md §2.1` item `2`; `A112`).
+   *
+   * **IT IS THE SAME FOUR-MEMBER `CommitRecord` A WRITE'S `K-2` RETURNS** — `attempt` · `op` · `triggered` ·
+   * `pending` — minted by the delete's own commit act, held by the entry for adoption, and handed here on the
+   * receipt. **THE FOUR READINGS THAT FOLLOW FROM IT, EACH A MEASUREMENT THIS RELEASE PRINTED:**
+   *   * **`pending` IS THE DELETE'S RESIDUE** — the store's returned set, WHOLE at the landing, minus the
+   *     handles this delete's own pass checked off as it passed. **IT IS THE SET THE DELIVERY FIRES**: this
+   *     act delivers `pending`, not the whole `triggered` list, exactly as a write does;
+   *   * **A `file`-TIER DELETE SAVES ITS OWN OP** — the terminal arm names `op.opId` to the store's
+   *     `commit_file` on the act's PASSING arm, so the bytes describe the state the delete left (`§2.11`
+   *     clause 2, the same act a `file`-tier write gets). **THE STORE'S `delete` VERB STILL COMMITS NOTHING**
+   *     (`DD-28`; `native contract.md §7.2` item 5): the save is the ARM's, at the record's own op, and a
+   *     WHOLE-TARGET delete's op stands at no tier, so that arm serializes nothing;
+   *   * **THE LOG AND THE REPORT ARE ANSWERABLE BY REF** — `K.log(store, record.attempt)` and
+   *     `K.report(store, record.attempt)` answer the delete's own attempt after it passed, not only from a
+   *     refusal's `log` (`attempt-lifecycle.md §2.4` item 1: those items take an `AttemptRef` or its `id`);
+   *   * **AND IT CAN BE HANDED BACK** — a nested `write(address, tier, value, record)` names this commit at its
+   *     fourth position and JOINS it (`D-46`), the same object `write`'s own position accepts.
+   *
+   * **`null` IS THE `D-3` ARM** — an act that removed nothing opens no attempt, so there is no record: the member
+   * is PRESENT and says so rather than being absent (`D-21`).
+   *
+   * **AND IT IS A NON-ENUMERABLE OWN `data` PROPERTY**, the device `discarded` below declares for the same
+   * reason: `Object.keys(receipt)` and every deep-equality over the receipt read the four enumerable members
+   * they read before, while a caller reads the record **by its name** (`receipt.commit`). A spread or
+   * `Object.assign` copy does not carry it — read the member off the receipt itself.
+   */
+  readonly commit: CommitRecord | null;
   /**
    * **THE DISCARD'S WITNESS — THE REVERSALS THIS ACT'S OWN DELIVERY RAISED AND THE PACKAGE THREW AWAY**
    * (`strata/decisions.md` · `D-49`, the architect, verbatim: *"Make discard observable"*; `DEF-AH`).
    *
-   * **WHY THIS MEMBER EXISTS.** A `delete`'s listener delivery **runs no constraint pass** — there is no attempt
-   * for one to run over — so a `rollback` a listener body issues inside it raises a **restart request with no
-   * consumer**, and the fail-state is honest only if the caller learns it happened (`D-43` item 2's fail-state
-   * and both exits stand; `D-49` owes the witness and nothing else). **A listener at `window.tabs` fires for a
+   * **WHY THIS MEMBER EXISTS.** A `delete`'s listener delivery stands **after the pass's own drain** (`D-55`
+   * item `3` put the delivery after the judgement), so a `rollback` a listener body issues inside it raises a
+   * **restart request with no consumer left in this act**, and the fail-state is honest only if the caller learns
+   * it happened (`D-43` item 2's fail-state and both exits stand; `D-49` owes the witness and nothing else).
+   * **⟶ AND THE GROUND MOVED BY ONE FACT ON 2026-10-29, SAID PLAINLY:** this member's clause read *"a `delete`'s
+   * listener delivery runs no constraint pass — there is no attempt for one to run over"*, and from `D-55` item
+   * `3` the delete DOES run a pass. **WHAT IS UNMOVED IS THE READER'S FACT**: the delivery is outside that pass,
+   * its drain has already run, and a request raised here is still discarded — so the witness still has its
+   * subject and still reports it. **A listener at `window.tabs` fires for a
    * delete at `window.tabs.landingPage`** — the triggered set's membership rule is the address prefix — **and the
    * check it runs there is exactly the act the window discards**; this member is where that caller reads it.
    *

package/index.mjs

@@ -89,8 +89,8 @@ import { encodeAddress, encodeFilePath, encodeJournalLength, encodeOpId, encodeT
 import { admittedConstraintBatch, constraintAddress, decodeBaseState, decodeJournalOp, decodeSegments, decodeValue, encodeConfig, spellConstraintAddress } from './src/entry/frame.mjs';
 import { addressSpelling } from './src/entry/kernel-foundations.mjs';
 import { FORGET_PAIR, INSTANCES, STORE_INDEX, STORE_RETIREMENT, TERMINAL_ARM, carryRefusal, closeCommit, crossTriggered, currentWindow, entryOf, homeAddressKey, installAttemptSeam, isStoreReceiver, openCommit, writeRefusal } from './src/entry/state.mjs';
-import { commitPositionRefusal, constraintOverwrittenByListen, deliver, listenerStandingAt, registerOn, terminalArm } from './src/entry/delivery.mjs';
-import { ARGUMENT_POSITION_FIRST, addressSetKey, carryConstraint, constraintDetached, constraintPairKey, constraintRefuse, constraintSite, constraintUncarried, constraintWrite, constraintsKernel, enumerateConstraints, judgeReversal, registrationCrossing, restoreHeldPair, reversalWatch, unionAddressSets, withEmptyLog, witnessDiscardedReversal, withdrawStanding } from './src/entry/constraints.mjs';
+import { commitPositionRefusal, constraintOverwrittenByListen, deliver, installRegistrationSeam, listenerStandingAt, registerOn, terminalArm } from './src/entry/delivery.mjs';
+import { ARGUMENT_POSITION_FIRST, addressSetKey, carryConstraint, constraintDetached, constraintPairKey, constraintRefuse, constraintSite, constraintUncarried, constraintDelete, constraintWrite, constraintsKernel, enumerateConstraints, judgeReversal, registrationCrossing, restoreHeldPair, reversalWatch, unionAddressSets, withEmptyLog, witnessDiscardedReversal, withdrawStanding } from './src/entry/constraints.mjs';
 const require_ = createRequire(import.meta.url);
 const ADDON_PATH = join(dirOf(fileURLToPath(import.meta.url)), 'build', 'Release', 'storeroom_js_binding.node');
 
@@ -239,6 +239,14 @@ export function storeCreate(cfg) {
   // a member of the product.
   const state = {
     home: [], registry: new Map(), constraints: new Map(), leg: null, receiver: null, establishing: null,
+    // **⟶ AND THE RESIDUE'S DELIVERER, ADDED 2026-10-29 — A PRIVATE FACT ABOUT WHICH ACT OWNS A LEG'S
+    // DELIVERY.** The terminal arm performs `surface.md §2.7` item 7's delivery for a kernel-driven WRITE
+    // (`delivery.mjs`'s `terminalArm`), and it is the delete's OWN member that performs it (`D-49` declared that
+    // delivery the window whose check never ran, and this build does not move it). **IT IS A VALUE OF THE
+    // PACKAGE'S OWN STATE AND NOT A MEMBER OF ANY RECORD** (`surface.md §2.1` (e) item 1: a record, a commit
+    // and a Map are never own members of the product): `'arm'` on every path that does not say otherwise, and
+    // `'member'` for the instant a `delete` stands in, restored in the same `finally` as the leg itself.
+    legDelivery: 'arm',
   };
   // **⟶ THE RECEIVER IS THE STORE OBJECT ITSELF, AND THE INTEGER THE PACKAGE USED TO HAND ACROSS IS NOT
   // HANDED AT ALL** (`receiver-and-refusal.md §1`; `js-unwrap.md §4`). The addon resolves its store from the
@@ -484,12 +492,37 @@ export function storeCreate(cfg) {
     /// delete at `window.tabs.landingPage`, and the check it runs there is exactly the kind of act the
     /// `delete`-delivery window throws away**).
     ///
-    /// **`delete` IS THE ONE ACT WHOSE DELIVERY RUNS NO PASS AND WHOSE ANSWER SURVIVES TO TELL** (`D-43` item
-    /// 2's other window is a registration, whose answer is an opaque identity and carries nothing). So the
-    /// request a listener body raises inside THIS window — a `rollback`, stamped with this commit's identity by
-    /// `reversalWatch` — is read at the end of the delivery and reported **BESIDE** the record's four members, by
-    /// the one rule `D-49` sets: **the act still answers what it answered, no status is minted, and the witness
-    /// is not a refusal.**
+    /// **⟶ AND IT RUNS A PASS FROM 2026-10-29 — `D-55` ITEM 3, `DEF-X`. THE RULING, THE ARCHITECT, VERBATIM:
+    /// *"A delete is an editing verb and must pass constraints. This includes all of the relevant commit and
+    /// message logic."*** **THE BYTES THIS PARAGRAPH REPLACES READ *"`delete` IS THE ONE ACT WHOSE DELIVERY RUNS
+    /// NO PASS"*, AND THEY WERE TRUE OF `1.3.0` AND FALSE OF THIS TREE**: a delete opens its own commit, and
+    /// **⟶ AND THE SET IT ASKS IS NOW THREE-PART, `D-66` (2026-10-28): every ANCESTOR of the delete's address (`D-56`), the
+    /// address itself, and EVERY DESCENDANT THE DELETE TOUCHED — for a delete, the whole subtree, because removing it
+    /// changes what a read there returns (absent where it stood). A pair at an address the act did NOT touch is still
+    /// not asked, which is the criterion: TOUCHED, not descendant.** **the delete-shaped attempt
+    /// `constraints.mjs`'s `constraintDelete` builds asks every pair standing at the
+    /// delete's own address **⟶ AND AT EVERY ANCESTOR OF IT, `D-56` (2026-10-28): THE PAIR'S ADDRESS BEING A PREFIX OF
+    /// THE ACT'S IS THE MEMBERSHIP TEST NOW, because the value read at a prefix CONTAINS its subtree and a change at a
+    /// descendant changes what that read returns** — against THE STATE THE DELETE LEFT**, appends the attempt's terminal entry to the
+    /// commit's one list, and — where a pair refuses — undoes the delete before it refuses (`D-55` item 5's safe
+    /// state). **NO PROBE WRITE IS LANDED TO HAVE SOMETHING TO JUDGE**: the thing judged is the delete's own
+    /// journal op, whose after-state is absence.
+    ///
+    /// **AND THE DELIVERY MOVED WITH IT — IT NOW SITS AFTER THE PASS.** At `1.3.0` the `deliver` call stood
+    /// immediately after the addon's return, so a listener fired by a delete saw a state no constraint had
+    /// approved and that a refusal was about to undo. **A LISTENER FIRED BY A DELETE NOW SEES A JUDGED STATE**,
+    /// and a refused delete delivers nothing at all. **THE POSITION IS THE WRITE'S OWN** (`surface.md §2.7` item
+    /// 6: *"the surface runs the write's TRIGGERED CONSTRAINTS FIRST, and THE OTHER LISTENERS ARE REACHED ONLY
+    /// ONCE EVERY CONSTRAINT HAS PASSED"*), and the delivery still stands inside this act's commit window, so a
+    /// listener body's own verbs open their own commits (`D-46`).
+    ///
+    /// **WHAT THE WITNESS STILL SPEAKS FOR, SAID NARROWLY.** The request a LISTENER BODY raises inside the
+    /// delivery — a `rollback`, stamped with this commit's identity by `reversalWatch` — is raised AFTER the
+    /// pass, so nothing in this act judges it: it is read at the end of the delivery and reported **BESIDE** the
+    /// record's four members, by the one rule `D-49` sets (`D-43` item 2's second window is a registration, whose
+    /// answer is an opaque identity and carries nothing). **A request a PAIR BODY raises INSIDE the pass is no
+    /// longer discarded**: it is consumed by the pass's own restart drain and judged at the state the delete
+    /// left (`D-42`; `D-54` (b)) — the third host `D-54` measured and named undeclared.
     ///
     /// **THE MEMBER IS A NON-ENUMERABLE OWN `data` PROPERTY, AND THE CHOICE IS DECLARED.** It is **visible to the
     /// caller by its name** (`record.discarded`) and declared in `index.d.ts`, while the record's **enumerable
@@ -503,8 +536,8 @@ export function storeCreate(cfg) {
     /// — the id the reversal named (the store's own echo) and **the addresses the refused act MOVED**, measured
     /// at the reversal's own instant (`constraints.mjs`'s `movedStanding`), not the whole watched registry:
     /// **a witness names what moved, because what did not move was not the act's** (`DEF-AM`, 2026-10-28).
-    /// **NO PASS RUNS, NO BODY IS INVOKED, NO JUDGEMENT IS TAKEN AND THE BEHAVIOUR OF THE WINDOW IS
-    /// UNMOVED**: the request is consumed (reported) and its effect still stands.
+    /// **THE WITNESS RUNS NO PASS OF ITS OWN, INVOKES NO BODY AND TAKES NO JUDGEMENT**: the request is consumed
+    /// (reported) and its effect still stands.
     delete(address, tier) {
       // **⟶ `§4.1`: `delete` OPENS ONE.**
       const opened = openCommit(instance);
@@ -516,29 +549,78 @@ export function storeCreate(cfg) {
         // `delete`'s tier is read as a VALUE and not by an arity fold: an ABSENT position is the whole-target
         // removal, and a supplied `undefined` answers row 4's `AddressMalformed` (`crossing.md §1.3`).
         appendOwn(args, encodeTier(tier, arguments.length >= 2, false, 'first argument'));
-        // THE ENTRY IS INVOKED BY `Reflect.apply`, NOT BY A SPREAD — see `read`'s clause of 2026-10-24 above.
-        const answer = carryRefusal(() => Reflect.apply(entryOf().delete, this, args), args);
-        const receipt = {
-          address: decodeSegments(answer.address),
-          tiers: answer.tiers,
-          triggered: crossTriggered(state, answer.triggered),
-          op: answer.op === null ? null : decodeJournalOp(answer.op),
-        };
-        // `A43`: a delete FIRES its own triggered set, on the same window as a write (`docs/specs/storeroom-js/surface.md §2.7` item 2).
-        deliver(state, receipt.triggered, answer.triggeringAddress);
-        // **⟶ `D-49`: THE WITNESS, READ AFTER THE DELIVERY AND REPORTED BESIDE THE RECORD** — the delivery is
-        // the only body-invoking instant this act has, so a request standing after it is one this window raised.
-        // **ONLY A DELETE THAT OPENED ITS OWN WINDOW REPORTS**: a call that joined an enclosing commit has no
-        // window of its own to witness, and any request under that identity belongs to the act that opened it
-        // (`witnessDiscardedReversal` clears a request of the window handed in and of no other).
-        const discarded = opened === true ? witnessDiscardedReversal(instance, window) : null;
-        Object.defineProperty(receipt, 'discarded', {
-          value: discarded === null ? [] : [discarded],
-          enumerable: false,
-          writable: false,
-          configurable: true,
-        });
-        return receipt;
+        // **THE STORE'S OWN LEG, THE DELETE-SHAPED ATTEMPT AND THE PASS, IN ONE CALL** (`constraints.mjs`'s
+        // `constraintDelete`): the attempt is opened with this commit's list in hand and the address held, the
+        // thunk below is INVOKED AS ITS STORE LEG — the addon's own `delete`, crossed exactly as it always was —
+        // and the pass that follows asks every pair standing at THE DELETE'S OWN ADDRESS against the state the
+        // delete left. **NO PROBE WRITE PRECEDES THE JUDGEMENT** (`K-2`'s store leg is a `write` and this act's
+        // is not). **A REFUSAL LEAVES BY THROW, FROM INSIDE THAT CALL**, with the store already back at the
+        // state this commit opened at (`D-55` item 5) — so nothing below is reached and nothing is delivered.
+        let answer;
+        // **⟶ THE ADOPTION, 2026-10-29 — `K-2`'S OWN SEMANTICS REACHED BY THE DELETE'S OWN ROUTE.** A write's
+        // record reaches the entry at `write`'s FOURTH POSITION and that member stands it in `state.leg`, the
+        // slot the TERMINAL ARM reads for the triggering address and for the `file`-tier save's own op. **A
+        // delete's arity is the declared `delete(address, tier)`, so it has no such position** — the adoption is
+        // therefore taken HERE, at the instant the store's own verb returned and BEFORE the pass, which is the
+        // same instant and the same slot: the delete's own returned receipt stands where a write's record
+        // stands, so the terminal arm saves the DELETE's op and delivers at the DELETE's address.
+        // **AND THE ENTRY'S OWN LEG IS PUT BACK, BESIDE `closeCommit` AND IN THE SAME `finally`**: a leg left
+        // standing would be read by an ENCLOSING write's terminal arm (`state.leg` is one slot and a nested act
+        // is reached from a body — `D-53`), and the delete's record must not become the enclosing commit's.
+        const standing = state.leg;
+        const standingDelivery = state.legDelivery;
+        // THE LEG'S DELIVERY IS THIS MEMBER'S FOR THE DURATION (`D-49`'s window, unmoved): the arm saves the
+        // delete's op and delivers nothing, so the residue reaches each listener ONCE — from `deliver` below.
+        state.legDelivery = 'member';
+        try {
+          const receipt = constraintDelete(instance, address, arguments.length >= 2 ? tier : undefined, () => {
+            // THE ENTRY IS INVOKED BY `Reflect.apply`, NOT BY A SPREAD — see `read`'s clause of 2026-10-24 above.
+            answer = carryRefusal(() => Reflect.apply(entryOf().delete, this, args), args);
+            const crossed = {
+              address: decodeSegments(answer.address),
+              tiers: answer.tiers,
+              triggered: crossTriggered(state, answer.triggered),
+              op: answer.op === null ? null : decodeJournalOp(answer.op),
+            };
+            // THE ADOPTION ITSELF — one assignment, at the verb's own return.
+            state.leg = crossed;
+            return crossed;
+          });
+          // **⟶ AND THE DELIVERY NOW READS THE RECORD'S `pending` RESIDUE, 2026-10-29 — THE FOURTH MEMBER'S
+          // OWN ACT, `K-2`'s SEMANTICS REACHED BY THE DELETE'S OWN INSTANT.** The delivery's position is
+          // UNMOVED (`D-55` item `3` put it after the pass, and `D-49` declares this delivery the window whose
+          // check never ran — a request raised here is the witness's, not the drain's, and this build changes
+          // neither). **WHAT MOVES IS WHAT IT DELIVERS**: before the record existed this call handed the
+          // store's WHOLE returned set, and it now hands `record.pending` — that set MINUS the handles this
+          // delete's own pass checked off as it passed (`releasePending`), which is the write's own delivered
+          // set (`surface.md §2.7` item 7 (a)). **A `D-3` DELETE HAS NO RECORD**, so it falls back to the
+          // receipt's own `triggered` — the arm's set, empty by the store's own declaration.
+          const owed = receipt.commit === null || receipt.commit === undefined
+            ? receipt.triggered
+            : receipt.commit.pending;
+          // **THE RULE IS THE WRITE'S OWN** (`surface.md §2.7` item 6): constraints first, then the other
+          // listeners. `A43`: a delete FIRES its own triggered set, on the same window as a write.
+          deliver(state, owed, answer.triggeringAddress);
+          // **⟶ `D-49`: THE WITNESS, READ AFTER THE DELIVERY AND REPORTED BESIDE THE RECORD** — the delivery is
+          // the act's remaining body-invoking instant, so a request standing after it is one this window raised
+          // from a LISTENER BODY. **A REQUEST A PAIR BODY RAISES INSIDE THE PASS IS NOT THIS WITNESS'S**: it is
+          // consumed and judged by the pass's own restart drain (`D-42`; `D-54` (b)), and by the time this line
+          // runs it has either passed or refused the delete outright.
+          // **ONLY A DELETE THAT OPENED ITS OWN WINDOW REPORTS**: a call that joined an enclosing commit has no
+          // window of its own to witness, and any request under that identity belongs to the act that opened it
+          // (`witnessDiscardedReversal` clears a request of the window handed in and of no other).
+          const discarded = opened === true ? witnessDiscardedReversal(instance, window) : null;
+          Object.defineProperty(receipt, 'discarded', {
+            value: discarded === null ? [] : [discarded],
+            enumerable: false,
+            writable: false,
+            configurable: true,
+          });
+          return receipt;
+        } finally {
+          state.leg = standing;
+          state.legDelivery = standingDelivery;
+        }
       } finally {
         closeCommit(instance, opened);
       }
@@ -1556,6 +1638,12 @@ export function storeCreate(cfg) {
   // `§4.2` item 4). **IT IS INSTALLED AFTER THE BATCH ROUTES ABOVE**, so a `listen` the construction itself
   // performs is not counted as a commit the caller opened and leaves the count at `0` on the return.
   installAttemptSeam(instance);
+  // **⟶ AND `D-69`'S REGISTRATION CHANNEL, ONCE, BY THE SAME RULE — 2026-10-29.** The registration entry admits a
+  // body of EITHER kind, and the kernel's `K-1` hands the pair's own constraint function through this channel after
+  // `listen` has written the home entry. **IT IS INSTALLED HERE BECAUSE THE REGISTRY IT FILLS IS THIS FACTORY'S
+  // `state`** (`delivery.mjs`'s `installRegistrationSeam` states the shape and the two places the kinds part
+  // company), **and it is symbol-keyed, so the product's FOURTEEN own members are unmoved** (`A117` (D6)).
+  installRegistrationSeam(instance, state);
   return instance;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "provident-storeroom",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "U-STOREROOM-PUBLISH: the published Node ESM binding for the native Rust store of Provident-Storeroom — the entry resolves the scoped per-target platform package first, the checkout's own module-relative addon second, and answers the store's single declared absent-addon form when neither loads",
   "type": "module",
   "license": "AGPL-3.0",
@@ -41,11 +41,11 @@
     "src/constraint-kernel.mjs"
   ],
   "optionalDependencies": {
-    "@auspicion/provident-storeroom-js-linux-x64-gnu": "1.3.0",
-    "@auspicion/provident-storeroom-js-linux-arm64-gnu": "1.3.0",
-    "@auspicion/provident-storeroom-js-darwin-x64": "1.3.0",
-    "@auspicion/provident-storeroom-js-darwin-arm64": "1.3.0",
-    "@auspicion/provident-storeroom-js-win32-x64-msvc": "1.3.0"
+    "@auspicion/provident-storeroom-js-linux-x64-gnu": "1.5.0",
+    "@auspicion/provident-storeroom-js-linux-arm64-gnu": "1.5.0",
+    "@auspicion/provident-storeroom-js-darwin-x64": "1.5.0",
+    "@auspicion/provident-storeroom-js-darwin-arm64": "1.5.0",
+    "@auspicion/provident-storeroom-js-win32-x64-msvc": "1.5.0"
   },
   "publishConfig": {
     "access": "public"