@zakkster/lite-signal-decorators 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,140 @@ All notable changes to `@zakkster/lite-signal-decorators` are documented here.
 The format follows Keep a Changelog; this project adheres to Semantic
 Versioning.
 
+## [1.1.0] - 2026-08-30
+
+The pooled-lifetime release: an instance is no longer single-lifetime. The
+surface grows 16 -> 18 with the additive `releaseReactive` / `reinitReactive`
+pair (a MINOR under the 1.0.0 semver promise), and this entry also folds in the
+repo-only COOKBOOK work that rode `[Unreleased]` (PD-34). The hot accessor canon
+(`makeGet` / `makeSet` / `makeDerivedGet`) and `wireInstance` are **byte-identical
+to 1.0.0** -- reinit is a cold-path inverse of dispose, the prebuilt closure set
+is built LAZILY at first `releaseReactive`, so the construct-once/dispose-once
+path takes zero new bytes and no new branches (git-diff proven; S6-A4). Dist-tag
+`latest`. Stage gate archived verbatim below: 257/257 tests on both lanes, torture
+16 scenarios (14 run + 2 forward-compat floor-skips) with 16/16 sabotage controls
+breaking as required, the peer-preview lane SUITE-GREEN per tag, cookbook corpus
+and control sweep green, pack the same 7-file set.
+
+### Added
+
+- `releaseReactive(vm) -> boolean` -- park a LIVE instance to the engine pool:
+  cascade the anchor, dispose each signal box, swap every slot to a per-class
+  PARKED handle (touch throws `ReactiveDisposedError` with a *parked* message),
+  keep the prebuilt wiring closures. A parked instance holds ZERO engine nodes.
+  `true` on first release, `false` on park->park (idempotent, mirrors
+  double-dispose). Fails closed on a disposed, unwired, frozen, or non-reactive
+  value; carries the same self-in-`@derived` re-entrancy guard `disposeReactive`
+  does. The closure set is built lazily on first release (0011).
+- `reinitReactive(vm, initials?) -> vm` -- revive a PARKED instance: rebuild each
+  signal box (`initials[key]` wins, else the plan initial), rebuild anchor +
+  deriveds + effects through the SAME prebuilt closures, restore live slots
+  (values reset). Atomic -- any throw mid-reinit routes through `disposeCore` and
+  lands the instance terminally DISPOSED (a failed revival is final). Fails closed
+  on a live, disposed, frozen, unwired, or non-reactive value; `null` is not zero.
+- The pooled-lifetime lattice: LIVE / PARKED / DISPOSED on one axis, with all nine
+  transitions pinned in `test/16-reinit.test.mjs` (29 cases, both emit lanes) --
+  park->reinit->live (values reset), park->dispose (lands DISPOSED, idempotent
+  false thereafter), park->park (false), the five `reinitReactive` fail-closed
+  states, parked-touch throwing "parked" not "disposed", and `boxOf`/`rootOf`
+  agreement. No new error class (PD-44): the PARKED touch reuses
+  `ReactiveDisposedError` with a pooled-lifetime message.
+- `test/torture/reinit-torture.mjs` (group `semantic`, floor 1.5.0) -- the
+  acquire/release gate: 4096 pooled cycles at the churn shape (P=4, D=2, E=1) hold
+  `maxMajor 0`, `maxPauseMs <= 4.0`, minors CONTROL-RELATIVE (`MINOR_FLOOR + 128`),
+  retained delta-heap at/below the in-process zero-alloc control, and exact pool
+  conservation (F-0: `activeNodes` to baseline, `poolGrowths` delta 0, ledger
+  balanced). Its `TORTURE_BREAK=reinit-torture` control leaks one un-parked
+  instance per cycle and exits non-zero. Torture 15 -> 16 scenarios.
+- `bench/scenarios/churn-reuse.mjs` -- the CHURN-shape acquire/release bench lane
+  (P=4, D=2, E=1): the `lsd`, `lsd-define`, and hand-wired `lite-raw-boxes` tiers
+  pool with retained 0.0KB; `mobx`, `signal-utils`, and `alien-class` return
+  `{ unsupported }` with an honest reason (MobX instances are never disposable --
+  atoms return only via GC, so there is no release/reinit cycle to pool). Bench
+  scenarios 7 -> 8; `bench/results.txt` re-stamped.
+- `spikes/reinit-contract.mjs` -- the S6-T1 spike (four questions answered with
+  numbers on the installed 1.5.0 peer before a line of `reinitReactive` was
+  written): the engine NODE is fully pooled, the JS HANDLE is fresh-per-call but
+  never retains, one prebuilt closure drives N registrations with zero stale
+  fires, and stale external handles fail CLOSED (no aliasing). Verdict EXIT A.
+- `decisions/0010-reinit-contract.md` (the spike contract + the four measured
+  tables + the peer-registry watch) and `decisions/0011-reinit-api.md` (the
+  two-call API shape, the state lattice, the construction-cost finding, and the
+  rejected alternatives).
+- `COOKBOOK.md` -- composition recipes over the surface, delivered GitHub-only
+  (repo-only, not in `files[]`; decisions/0009): the tarball stays the 7-file
+  runtime surface and the shipped README.md and llms.txt point to the cookbook by
+  absolute GitHub URL.
+- `cookbook/` (dev-only, never shipped): a runnable companion corpus of 12
+  recipes (0-11), six GC-gated with `COOKBOOK_BREAK=<id>` sabotage controls and
+  six ungated each carrying a published reason; plus `cookbook/manifest.json`,
+  the `cookbook/citations.json` cross-package symbol allowlist, and
+  `cookbook/run.mjs` -- the `node --expose-gc` per-recipe runner behind
+  `npm run cookbook` (with `--controls` for the sabotage sweep and `--list`).
+- `test/15-cookbook.test.mjs` -- the drift/parity checker: each fenced block in
+  `COOKBOOK.md` is byte-compared against its tagged companion `#region`,
+  bidirectionally, with a surface-freeze check (now exactly 18 exports; PD-48,
+  second-landing session owns the one number), a citation check, a static-cost
+  check, and the shipped-doc-link check.
+- `test/gate.mjs` gains a BLOCKING `cookbook` step (the corpus lane plus the
+  `COOKBOOK_BREAK` control sweep, both must exit 0), between `bench:selftest` and
+  `pack`: the chain is now 8 blocking steps + 1 non-blocking (peer-preview).
+- `test/gate.mjs` pack check upgraded from a bare count to a named-set
+  assertion: the tarball names must equal exactly {SignalDecorators.js,
+  SignalDecorators.d.ts, llms.txt, CHANGELOG.md, README.md, LICENSE,
+  package.json}; `EXPECT_FILES` stays 7 and stays asserted, and a same-count
+  swap now fails.
+- `package.json` `scripts.cookbook` (`node cookbook/run.mjs`) and three pinned
+  devDependencies: `@zakkster/lite-store` 1.2.0, `@zakkster/lite-arena` 1.9.0,
+  `@zakkster/lite-await` 1.1.1.
+
+### Changed
+
+- The export surface grows 16 -> 18 (additive MINOR): `releaseReactive`,
+  `reinitReactive`. The 1.0.0 semver promise holds -- no existing export's
+  signature or behavior changed; the hot accessor canon does not move.
+- Suite 214 -> 257 tests, green on both the plain and `--expose-gc` lanes:
+  `test/15-cookbook.test.mjs` added 14 (214 -> 228), `test/16-reinit.test.mjs`
+  added 29 (228 -> 257). Torture 15 -> 16 scenarios; sabotage controls 15 -> 16.
+- Docs re-stamped to 1.1.0 across the three version sites
+  (`package.json`, `SignalDecorators.js` `VERSION`, `llms.txt`), the README
+  Testing/torture/design sections, and the llms.txt Exports header and scope
+  note. The llms.txt single-lifetime sentence ("disposed once, never revived") is
+  replaced by the pooled-lifetime contract and the three-state lattice, citing
+  decisions/0010 and 0011.
+- Construction cost is unchanged: the prebuilt closure set is built LAZILY at
+  first `releaseReactive` (not at construction), so a construct-once/dispose-once
+  instance carries only one WeakMap `has` beyond 1.0.0; `costOf(Factory).nodes`
+  still equals P+D+E+1 and `capacity-torture` is unperturbed. Measured evidence
+  for why lazy (a stored or transient per-construction bundle tips the
+  `maxMajor 0` churn-soak floor) is in decisions/0011.
+
+### Peer-watch note (PD-46)
+
+Outcome (i): nothing promoted. The `npm view @zakkster/lite-signal dist-tags`
+probe on 2026-08-30 shows stable `latest` still at **1.5.0**; 1.6.x
+(`createScope`) and 1.9.x (engine `Symbol.dispose`) exist only as prerelease tags,
+exactly the ones the peer-preview lane already tracks. No per-feature floor is
+promoted, `torture:peer-preview` keeps reporting per tag, the `scope-adoption`
+and `using-dispose` scenarios keep skipping legitimately below their floors, and
+the peer RANGE floor stays `>=1.5.0 <2.0.0`. Recorded in decisions/0010.
+
+### Gate output (section-10 chain, archived verbatim)
+
+```
+  fixtures              OK       exit 0 -- emit fixtures regenerated
+  test                  OK       exit 0 -- 257 pass / 0 fail
+  test:gc               OK       exit 0 -- 257 pass / 0 fail
+  torture               OK       exit 0 -- 14 passed, 2 skipped, 0 warned, 0 failed in 33.2s
+  torture:controls      OK       exit 0 -- 16 passed, 0 skipped, 0 warned, 0 failed in 2.0s
+  torture:peer-preview  REPORTED NON-BLOCKING -- lane completed (exit 0) [preview   1.9.0-preview.6     SUITE-GREEN     16 passed, 0 skipped, 0 warned, 0 failed; canary    1.9.0-canary.1      SUITE-GREEN     16 passed, 0 skipped, 0 warned, 0 failed]
+  bench:selftest        OK       exit 0 -- ALL PASS -- 22 passed, 0 failed
+  cookbook              OK       exit 0/0 -- corpus 12/12 companions ok in 1.8s; controls 6/6 controls fail correctly in 4.6s
+  pack                  OK       exit 0 -- 7/7 files, exact 7-name set, no demo/ no Publications/
+----------------------------------------------------------------------
+  GATE PASS -- 8 blocking steps + 1 non-blocking (peer-preview)
+```
+
 ## [1.0.0] - 2026-08-29
 
 The 1.0 release: docs freeze, the fleet playground, and the standing pre-publish
@@ -358,6 +492,7 @@ Initial release -- the decorator core.
 - Torture skeleton (`@zakkster/lite-leak` + `@zakkster/lite-gc-profiler`):
   retention, conservation, lifecycle, and zero-GC lanes.
 
+[1.1.0]: https://github.com/PeshoVurtoleta/lite-signal-decorators/releases/tag/v1.1.0
 [1.0.0]: https://github.com/PeshoVurtoleta/lite-signal-decorators/releases/tag/v1.0.0
 [0.4.0]: https://github.com/PeshoVurtoleta/lite-signal-decorators/releases/tag/v0.4.0
 [0.3.0]: https://github.com/PeshoVurtoleta/lite-signal-decorators/releases/tag/v0.3.0

package/README.md

@@ -238,6 +238,8 @@ Symbol keys work (`Reflect.ownKeys`). A spec key colliding with an own property
 | Export | Signature | Behavior |
 |---|---|---|
 | `disposeReactive` | `(vm) => boolean` | Cascade + poison teardown. `true` on the first call, `false` after (idempotent). Also wired to `Symbol.dispose`, so `using vm = new Player()` disposes at block exit. Refuses a frozen instance up front (named throw, nothing half-done). |
+| `releaseReactive` | `(vm) => boolean` | Park a LIVE instance to the engine pool: cascade the anchor, dispose each box, swap every slot to a PARKED handle (touch throws `ReactiveDisposedError` with a *parked* message), keep the prebuilt wiring closures. A parked instance holds ZERO engine nodes. `true` on first release, `false` on park->park (idempotent). Fails closed on a disposed, unwired, frozen, or non-reactive value. Pooled-lifetime contract: [decisions/0010](decisions/0010-reinit-contract.md), [0011](decisions/0011-reinit-api.md). |
+| `reinitReactive` | `(vm, initials?) => vm` | Revive a PARKED instance: rebuild each box (`initials[key]` wins, else the plan initial), rebuild anchor + deriveds + effects through the SAME prebuilt closures, restore live slots (values reset). Atomic -- a throw mid-reinit lands the instance DISPOSED (a failed revival is final). Fails closed on a live, disposed, frozen, unwired, or non-reactive value. |
 | `boxOf` | `(vm, key) => SignalBox \| ComputedBox` | The live engine box behind a `@reactive`/`@derived` member -- `.peek()`, `.subscribe()`, raw interop. Unknown key: named throw with a did-you-mean. After dispose: `ReactiveDisposedError`. |
 | `rootOf` | `(vm) => NodeDescriptor` | The instance's anchor descriptor -- feeds `forEachOwned` and lite-devtools. Throws `ReactiveDisposedError` after dispose. |
 
@@ -257,7 +259,7 @@ With labels and audit off, the zero-GC budgets are byte-identical to 0.3.0 -- th
 | Export | Value |
 |---|---|
 | `ReactiveDisposedError` | `extends Error`; `name: "ReactiveDisposedError"`; fields `className`, `key`. Thrown on ANY touch of a disposed instance's surface. |
-| `VERSION` | `"1.0.0"` |
+| `VERSION` | `"1.1.0"` |
 
 ### The rejection matrix
 
@@ -374,14 +376,14 @@ The ~7 ns over raw batch is the guarded thunk + rest-array the decorator allocat
 | `disposeReactive(vm)` | none | allocation-free success path; poison handles are prebuilt per member at decoration time |
 | `boxOf` / `rootOf` / any throw | cold path | introspection and failure paths may allocate; never on the hot path |
 
-The gates that hold it (run on every change, all green at 1.0.0):
+The gates that hold it (run on every change, all green at 1.1.0):
 
-- `npm test` / `npm run test:gc` -- **214/214** on both lanes.
+- `npm test` / `npm run test:gc` -- **257/257** on both lanes.
 - Suite gate (lite-leak + lite-gc-profiler): `leak=size 0/0 findings=0 warnings=0 | gc major=0 minor=0 maxMs=0.00 | ok`.
-- Torture: **15 scenarios** (zero-GC read/write lanes at `maxMajor 0, maxPauseMs 4`; 4096-cycle leak gate at 0 live / 0 findings / 0 warnings; capacity atomicity at every overflow point; a 300-seed x 20k-op oracle with zero divergences) -- **13 run + 2 that skip correctly below their peer floors** (`scope-adoption` needs 1.6.0, `using-dispose` needs 1.9.0; the installed peer is 1.5.0). A skip *below* a floor is the forward-compat design working; a skip *at or above* it is a FAIL (run.mjs enforces floor-escalation). Every scenario carries a `TORTURE_BREAK` sabotage control that must exit non-zero -- **15/15 controls** prove each gate can actually fail.
+- Torture: **16 scenarios** (zero-GC read/write lanes at `maxMajor 0, maxPauseMs 4`; 4096-cycle leak gate at 0 live / 0 findings / 0 warnings; capacity atomicity at every overflow point; a 300-seed x 20k-op oracle with zero divergences; the `reinit-torture` acquire/release gate) -- **14 run + 2 that skip correctly below their peer floors** (`scope-adoption` needs 1.6.0, `using-dispose` needs 1.9.0; the installed peer is 1.5.0). A skip *below* a floor is the forward-compat design working; a skip *at or above* it is a FAIL (run.mjs enforces floor-escalation). Every scenario carries a `TORTURE_BREAK` sabotage control that must exit non-zero -- **16/16 controls** prove each gate can actually fail.
 - `churn-soak` + `fleet-soak`: sustained construct/use/dispose and a 10s 2k-VM fleet tick; pools at floor and retained heap flat at every sample.
 
-The cross-framework matrix lives in `bench/` (private, never shipped): six engines -- both our tiers, the hand-written `lite-raw-boxes` baseline, MobX 7, signal-utils/signal-polyfill, and a hand-rolled alien-signals class -- across seven class-shaped scenarios, checksum-verified for identical work, stamped into `bench/results.txt`. The formal verdicts are in [`decisions/0006-kill-criteria.md`](decisions/0006-kill-criteria.md): the decorated path measured **0.94x** the hand-written baseline on vm-write and **1.10x** on a 10k-instance fleet read (the 2.0x kill line cleared with margin), and **0 major + 0 minor GC over 4096 construct/use/dispose cycles** with pools at floor -- while emitting ~12.6x less transient garbage per churn run than the hand-rolled class it replaces.
+The cross-framework matrix lives in `bench/` (private, never shipped): six engines -- both our tiers, the hand-written `lite-raw-boxes` baseline, MobX 7, signal-utils/signal-polyfill, and a hand-rolled alien-signals class -- across eight class-shaped scenarios (including the `churn-reuse` acquire/release lane, where the lite tiers pool with zero retained growth and MobX/signal-utils/alien-class are structurally `unsupported` -- no disposable instance lifecycle to pool), checksum-verified for identical work, stamped into `bench/results.txt`. The formal verdicts are in [`decisions/0006-kill-criteria.md`](decisions/0006-kill-criteria.md): the decorated path measured **0.94x** the hand-written baseline on vm-write and **1.10x** on a 10k-instance fleet read (the 2.0x kill line cleared with margin), and **0 major + 0 minor GC over 4096 construct/use/dispose cycles** with pools at floor -- while emitting ~12.6x less transient garbage per churn run than the hand-rolled class it replaces.
 
 </details>
 
@@ -398,18 +400,19 @@ Full rationale lives in [`decisions/`](decisions/) -- each is a numbered, dated
 - **Frozen instances refuse disposal up front.** `Object.freeze(vm)` makes the poison swap impossible, so `disposeReactive` throws by name *before* touching anything -- no half-dispose. `seal`/`preventExtensions` are fine.
 - **Symbol-slot storage.** Chosen over the emitter's private backing (emitter-dependent codegen) and a dict (fleet megamorphism, measured) -- and it is the same mechanism poison uses, so storage, dispose, and poison are one design.
 - **Statics and `#` privates are rejected, not half-supported.** A module-level signal belongs to raw lite-signal; a private member can't be reached by the wiring protocol -- both are named decoration-time throws.
+- **Pooled reinit is an identity-stable arena tool, not a speed shortcut (1.1.0).** `releaseReactive(vm)` parks a live instance to the engine pool and `reinitReactive(vm, initials?)` revives it -- a three-state lattice (live / parked / disposed) over the same instance, so consumers keep the object reference across turnover. It holds its gate: over 4096 acquire/release cycles at the churn shape (P=4, D=2, E=1) it measures **0 major GC**, retained delta-heap **at or below the in-process zero-alloc control**, and exact pool conservation (`activeNodes` back to baseline, zero pool growths, a parked instance holding 0 engine nodes). The honest throughput number, same shape, 2026-08-30 stamp (module 1.1.0): plain construct/dispose CHURN is *faster* -- **1323K ops/s** vs reuse's **1159K** -- because construction is already allocation-light and pool-conserving, so reinit is not a per-op win. Reach for it when you need identity-stable pooled instances under sustained turnover with zero retained growth (an arena/fleet primitive), not when you want raw op speed. MobX has no equivalent lifecycle at all: its instances are never disposable, so there is no release/reinit cycle to pool ([decisions/0010](decisions/0010-reinit-contract.md), [0011](decisions/0011-reinit-api.md)).
 
 ---
 
 ## Testing (for clients & QA)
 
 ```bash
-npm test            # node --test, 214 tests
-npm run test:gc     # the same 214 with --expose-gc (enables the allocation assertions)
-npm run gate        # the full pre-publish chain (section 10): fixtures -> test -> test:gc -> torture -> controls -> peer-preview (non-blocking) -> bench selftest -> pack
+npm test            # node --test, 257 tests
+npm run test:gc     # the same 257 with --expose-gc (enables the allocation assertions)
+npm run gate        # the full pre-publish chain (section 10): fixtures -> test -> test:gc -> torture -> controls -> peer-preview (non-blocking) -> bench selftest -> cookbook -> pack
 ```
 
-**214 tests** across fourteen files, all green at 1.0.0. The decorator protocol is tested three times over: against a mock Stage-3 emitter *and* against committed real TypeScript 5 and Babel `2023-11` emits, so both toolchains' codegen is pinned, not assumed.
+**257 tests** across sixteen files, all green at 1.1.0. The decorator protocol is tested three times over: against a mock Stage-3 emitter *and* against committed real TypeScript 5 and Babel `2023-11` emits, so both toolchains' codegen is pinned, not assumed.
 
 | File | Tests | Covers |
 |---|---:|---|
@@ -427,6 +430,8 @@ npm run gate        # the full pre-publish chain (section 10): fixtures -> test
 | `12-accounting` | 11 | `costOf` node/link/shape grid (double-probe, frozen + cached, fail-closed) + `capacityFor` budget sizing |
 | `13-labels-audit` | 10 | `enableLabels`/`labelOf` per-registry identity + `auditReactive` leak reporting, both opt-in and default-OFF |
 | `14-qa-s4-boundary` | 21 | S4 adversarial edges: stats-less facade closure, signals-only capacity floor, label/audit boundary matrix |
+| `15-cookbook` | 14 | [`COOKBOOK.md`](https://github.com/PeshoVurtoleta/lite-signal-decorators/blob/main/COOKBOOK.md) drift/parity: each fenced block byte-compared against its tagged companion `#region` (both directions + both-way coverage), surface freeze (exactly 18 exports), citation allowlist, link law, static-cost probe |
+| `16-reinit` | 29 | Pooled-reinit lattice on both emit lanes: park/reinit/dispose transitions, the five `reinitReactive` fail-closed states, parked-touch throws by name, `initials` boundary matrix (0..N+1 keys, null/undefined, NaN/-0 verbatim), `Symbol.dispose` on a parked instance, accessor descriptors byte-identical across reinit, self-release re-entrancy, ledger conservation |
 
 ### Emit-support matrix
 
@@ -452,13 +457,25 @@ Source hashes: `fixture.src.ts` `fb492a396340`, `static.src.ts` `81fb649965e6`,
 Process-isolated stress scenarios built on `@zakkster/lite-leak` + `@zakkster/lite-gc-profiler`:
 
 ```bash
-npm run torture             # all 15 scenarios (13 run + 2 floor-gated skips)
+npm run torture             # all 16 scenarios (14 run + 2 floor-gated skips)
 npm run torture:semantic    # the correctness lane (CI)
 npm run torture:soak        # the wall-clock churn + fleet soaks
 npm run torture:controls    # sabotage self-test: every scenario must FAIL when broken
 ```
 
-Fifteen scenarios: emit-matrix, ordering, lifecycle, pool-conservation, zero-GC lanes, capacity atomicity (every overflow point x both construction paths), the full disposed-poison surface + resurrection storms, a 4096-cycle lite-leak gate, a **300-seed x 20k-op oracle fuzzer** (decorated vs hand-wired raw twin in lockstep: every derived value, every effect fire count, every graph opcode tally), raw/decorated interop + cross-registry + `registry.destroy()` contracts, batch/untrack semantics, the wall-clock churn soak, and a 10s 2k-VM fleet soak -- plus two forward-compat scenarios (`scope-adoption`, `using-dispose`) that **skip correctly** while the installed peer sits below their per-feature floors (1.6.0 `createScope`, 1.9.0 `Symbol.dispose`). A skip below a floor is the design working; a skip at or above it is a FAIL. On the installed 1.5.0 peer: 13 pass, 2 skip. Every scenario carries a `TORTURE_BREAK` sabotage control that must exit non-zero -- a gate that cannot fail is not a gate. Seeded lanes replay exactly via `TORTURE_SEED`.
+Sixteen scenarios: emit-matrix, ordering, lifecycle, pool-conservation, zero-GC lanes, capacity atomicity (every overflow point x both construction paths), the full disposed-poison surface + resurrection storms, a 4096-cycle lite-leak gate, a **300-seed x 20k-op oracle fuzzer** (decorated vs hand-wired raw twin in lockstep: every derived value, every effect fire count, every graph opcode tally), raw/decorated interop + cross-registry + `registry.destroy()` contracts, batch/untrack semantics, the `reinit-torture` acquire/release gate (4096 pooled cycles: `maxMajor 0`, retained delta-heap at/below the in-process zero-alloc control, exact pool conservation), the wall-clock churn soak, and a 10s 2k-VM fleet soak -- plus two forward-compat scenarios (`scope-adoption`, `using-dispose`) that **skip correctly** while the installed peer sits below their per-feature floors (1.6.0 `createScope`, 1.9.0 `Symbol.dispose`). A skip below a floor is the design working; a skip at or above it is a FAIL. On the installed 1.5.0 peer: 14 pass, 2 skip. Every scenario carries a `TORTURE_BREAK` sabotage control that must exit non-zero -- a gate that cannot fail is not a gate. Seeded lanes replay exactly via `TORTURE_SEED`.
+
+### The cookbook lane (dev-side, never shipped)
+
+Every code block in [`COOKBOOK.md`](https://github.com/PeshoVurtoleta/lite-signal-decorators/blob/main/COOKBOOK.md) is byte-identical to a runnable companion in `cookbook/` (dev-only, never in `files[]`):
+
+```bash
+npm run cookbook            # run all 12 companions under node --expose-gc
+npm run cookbook -- --controls  # sabotage sweep: every gated recipe must FAIL when broken
+npm run cookbook -- --list      # the manifest: id, title, tier, gc verdict
+```
+
+Twelve recipe companions, six of them GC-gated (r1, r2, r4, r5, r9, r10) at the S1 budget (`gc.major === 0`, `maxPauseMs <= 4.0`, `<= 0.589` B/op with control-relative minors) and each carrying a `COOKBOOK_BREAK=<id>` sabotage control; the other six publish a non-empty reason in the manifest. Latest lane tails: `cookbook lane: 12/12 companions ok in 1.8s` and, under `--controls`, `cookbook lane: 6/6 controls fail correctly in 4.6s`. `test/15-cookbook.test.mjs` drift-checks the document against the companions in both directions (a one-byte edit either side fails, naming the recipe), and the gate runs the lane as a blocking step -- the chain is now 8 blocking steps + 1 non-blocking.
 
 ### The fleet demo (dev-side, never shipped)
 
@@ -542,6 +559,10 @@ The cross-framework numbers behind this table are stamped in [`decisions/0006-ki
 | [`@zakkster/lite-watch-ex`](https://www.npmjs.com/package/@zakkster/lite-watch-ex) | One-shot / predicate-gated / pausable watchers over the same engine; thunk sources, default-registry effects -- see the [registry note](#composability) before pointing one at a decorated member. |
 | `@zakkster/lite-leak` + `@zakkster/lite-gc-profiler` | The dev-side harness that proves every retention and allocation claim in this README. Never shipped to consumers. |
 
+### The cookbook
+
+[`COOKBOOK.md`](https://github.com/PeshoVurtoleta/lite-signal-decorators/blob/main/COOKBOOK.md) collects twelve composition recipes over the frozen 16-export surface -- how to build the things this package deliberately does not ship a decorator for, by composing the ones it does. Its headline is the **MobX-parity-by-composition matrix**, mapping each remaining MobX construct (`observable.array`, `observable.map`, `observable.deep`, `toJS`, `when`, `runInAction`, `observe`/`intercept`) to a decorator, a suite member, or a recipe -- extending the migration tables above to the rest of MobX with the honest note per row. It walks the **two-plane fleet** (a sim plane of arena columns written raw per frame beside a reactive plane of a handful of committed members), the reactive-collection-without-a-node-per-element pattern, and the **lite-store boundary** where document state meets class state -- stated plainly as the one path that is *not* zero-GC, and why. Every code block is byte-verified against a runnable, GC-gated companion in `cookbook/` (`npm run cookbook`), so a quoted recipe cannot drift from working code. It is delivered GitHub-only -- the installed tarball stays the lean 7-file runtime surface (decisions/0009).
+
 ---
 
 ## FAQ

package/SignalDecorators.d.ts

@@ -239,6 +239,33 @@ export function defineReactive<C extends new (...args: any[]) => any>(
  */
 export function disposeReactive(vm: object): boolean;
 
+/**
+ * Release a live reactive instance to the engine pool (PARKED state): cascade its
+ * anchor, dispose each signal box, and swap every slot to a parked handle that
+ * throws a parked-specific {@link ReactiveDisposedError} on touch. The instance
+ * keeps its prebuilt wiring closures so {@link reinitReactive} revives it with
+ * zero new closure allocation. Idempotent on an already-parked instance (returns
+ * `false`, mirroring {@link disposeReactive}); returns `true` on the first
+ * successful release.
+ *
+ * @throws if `vm` is not a reactive instance, is unwired, is frozen, or was
+ *   terminally disposed (a disposed instance cannot be pooled).
+ */
+export function releaseReactive(vm: object): boolean;
+
+/**
+ * Revive a PARKED reactive instance (see {@link releaseReactive}): rebuild its
+ * signal boxes -- using `initials`' values where given, else each member's
+ * declared initial -- then rebuild the anchor, deriveds, and effects through the
+ * instance's prebuilt closures. Atomicity matches construction: any throw
+ * mid-reinit leaves the instance terminally disposed. Returns the same `vm`.
+ *
+ * @param initials optional map of `@reactive` keys to reset values (a non-signal
+ *   or unknown key throws with a did-you-mean hint).
+ * @throws if `vm` is live, disposed, frozen, unwired, or not a reactive instance.
+ */
+export function reinitReactive<T extends object>(vm: T, initials?: Record<PropertyKey, unknown>): T;
+
 /**
  * Return the live {@link SignalBox} / {@link ComputedBox} backing a reactive
  * member -- for interop with raw lite-signal code and devtools.

package/SignalDecorators.js

@@ -1,5 +1,5 @@
 /**
- * @zakkster/lite-signal-decorators v1.0.0
+ * @zakkster/lite-signal-decorators v1.1.0
  * --------------------
  * Stage-3 decorator layer over @zakkster/lite-signal. Turns a plain class into
  * a reactive view-model with measured per-instance cost and deterministic
@@ -67,13 +67,35 @@ const HOST_MARK = Symbol("lite-signal-decorators.host");
 // The instance's anchor NodeDescriptor lives here; DISPOSED after teardown.
 const ANCHOR = Symbol("lite-signal-decorators.anchor");
 
-// Marks the poison/prewired handles so boxOf/rootOf recognize them without
-// calling get() (PD-4): value is "disposed" or "prewired".
+// Marks the poison/prewired/parked handles so boxOf/rootOf recognize them
+// without calling get() (PD-4): value is "disposed", "prewired", or "parked".
 const NONLIVE = Symbol("lite-signal-decorators.nonlive");
 
 // Frozen sentinel written to ANCHOR on dispose (idempotency signal, PD-7).
 const DISPOSED = Object.freeze({ [NONLIVE]: "disposed" });
 
+// PD-44: frozen sentinel written to ANCHOR on releaseReactive(), the PARKED
+// state. Distinct from DISPOSED so the lattice tells a pooled instance (revivable
+// by reinitReactive) from a terminally-disposed one; both carry NONLIVE so
+// disposeCore/boxOf/rootOf classify them without touching a live node.
+const PARKED = Object.freeze({ [NONLIVE]: "parked" });
+
+// PD-42: the per-instance prebuilt closure set (S6-T2). Built at first wiring
+// (transient) and rebuilt+RETAINED at first releaseReactive, then reused by every
+// acquire (buildGraph) so a reinit allocates ZERO new closures (0010 Q3). Holds
+// the createRoot thunk, the anchor effect body, the runWithOwner thunk, and the
+// per-derived and per-effect bodies. Kept in one module-private slot on the
+// instance; a construct-once/dispose-once instance never stores it (S6-A6: the
+// prebuild adds no retained construction cost, so churn-soak's maxMajor 0 holds).
+const CLOSURES = Symbol("lite-signal-decorators.closures");
+
+// PD-44: decorator-signal initials for reinit value reset. A decorator signal's
+// initial is its field-initializer value, captured (per member, first-seen) in
+// makeInit -- NOT retained per instance, so construct-once churn pays nothing.
+// Buildless signals reset via their plan initFn instead; a caller override always
+// wins. Keyed by the frozen signal rec (bounded by the class member count).
+const SIG_INITIAL = new WeakMap();
+
 // Scratch-frame stack (D-2h): decorator signal boxes are created in accessor
 // `init` during super()'s field initialization -- BEFORE wireInstance's
 // try/catch exists. Each init pushes its box here; the wrapper constructor
@@ -162,13 +184,18 @@ const REG_METHODS = [
 // --- ReactiveDisposedError ----------------------------------------------------
 
 /**
- * Thrown when a disposed reactive member (or root) is read or written. Carries
- * the originating class name and the member key for actionable diagnostics.
+ * Thrown when a disposed OR parked reactive member (or root) is read or written.
+ * Carries the originating class name and the member key for actionable
+ * diagnostics. The optional `parked` flag selects a pooled-lifetime message so a
+ * touch on a released-to-pool instance reads differently from a zombie (PD-44) --
+ * one error class, two states, no surface growth.
  */
 export class ReactiveDisposedError extends Error {
-    constructor(className, key) {
+    constructor(className, key, parked) {
         super(
-            `${ERR}${className}.${String(key)} was used after disposeReactive() -- the reactive graph is gone`,
+            parked
+                ? `${ERR}${className}.${String(key)} was released to the pool (parked) -- call reinitReactive() to revive it before use`
+                : `${ERR}${className}.${String(key)} was used after disposeReactive() -- the reactive graph is gone`,
         );
         this.name = "ReactiveDisposedError";
         this.className = className;
@@ -325,9 +352,13 @@ function throwNotWired(what) {
     );
 }
 
-function throwSelfDisposeInDerived(ctorName, key) {
+function throwSelfDisposeInDerived(ctorName, key, op) {
+    // `op` defaults to disposeReactive so the 1.0.0 call site's message stays
+    // byte-identical; releaseReactive passes its own name (same fail-open hazard).
+    const fn = op === undefined ? "disposeReactive" : op;
+    const verb = op === undefined ? "Dispose" : "Release";
     throw new Error(
-        `${ERR}disposeReactive(${ctorName}) was called from inside its own @derived ${keyLabel(key)} computation -- derived getters must be pure. Dispose from an effect, a subscription, or plain code instead.`,
+        `${ERR}${fn}(${ctorName}) was called from inside its own @derived ${keyLabel(key)} computation -- derived getters must be pure. ${verb} from an effect, a subscription, or plain code instead.`,
     );
 }
 
@@ -353,6 +384,51 @@ function throwPrewiredMember(ctorName, key) {
     );
 }
 
+function throwReleaseDisposed(ctorName) {
+    throw new Error(
+        `${ERR}releaseReactive(${ctorName}) -- the instance was disposed (terminal) and cannot be released to the pool. disposeReactive is final; releaseReactive parks a LIVE instance for reinitReactive to revive.`,
+    );
+}
+
+function throwReleaseFrozen(ctorName) {
+    throw new TypeError(
+        `${ERR}releaseReactive(${ctorName}) -- the instance is frozen, so the parked-handle swap cannot be installed. Do not freeze a live reactive instance.`,
+    );
+}
+
+function throwReinitLive(ctorName) {
+    throw new Error(
+        `${ERR}reinitReactive(${ctorName}) -- the instance is live; call releaseReactive() to park it before reinitReactive() revives it.`,
+    );
+}
+
+function throwReinitDisposed(ctorName) {
+    throw new Error(
+        `${ERR}reinitReactive(${ctorName}) -- the instance was disposed (terminal); a disposed instance cannot be revived. Construct a fresh one.`,
+    );
+}
+
+function throwReinitFrozen(ctorName) {
+    throw new TypeError(
+        `${ERR}reinitReactive(${ctorName}) -- the instance is frozen, so live handles cannot be restored into its slots. Do not freeze a parked instance.`,
+    );
+}
+
+function throwReinitInitials(ctorName) {
+    throw new TypeError(
+        `${ERR}reinitReactive(${ctorName}, initials) -- initials must be an object mapping @reactive keys to their reset values.`,
+    );
+}
+
+function throwReinitInitialsKey(ctorName, key, plan) {
+    const avail = [];
+    for (let i = 0; i < plan.signals.length; i++) avail.push(keyLabel(plan.signals[i].key));
+    const near = nearestKey(keyLabel(key), avail);
+    throw new Error(
+        `${ERR}reinitReactive(${ctorName}) initials carries key \`${keyLabel(key)}\` that is not a @reactive signal${near ? ` -- did you mean \`${near}\`?` : ""} Signals: ${avail.join(", ")}.`,
+    );
+}
+
 function throwNoBox(ctorName, key, kind) {
     const what = kind === "effect" ? "@reactiveEffect" : "@batched";
     throw new Error(
@@ -480,6 +556,9 @@ function makeInit(rec) {
         const box = rec.plan.reg.signalBox(v, rec.opts);
         this[rec.slot] = box;
         SCRATCH.push(box);                     // D-2h: track for init-phase rollback
+        // PD-44: record the first-seen field-initializer value as this decorator
+        // signal's reinit reset value (per member, once; no per-instance retention).
+        if (!SIG_INITIAL.has(rec)) SIG_INITIAL.set(rec, v);
         return v;                              // emitter backing store, unused
     };
 }
@@ -569,6 +648,7 @@ function applyReactive(target, ctx, opts) {
         plan: null,
         poison: null,
         prewired: null,
+        parked: null,
         initFn: null,                          // decorator boxes are born at init
     };
     PENDING.push(rec);
@@ -609,6 +689,7 @@ function applyDerived(value, ctx, opts) {
         plan: null,
         poison: null,
         prewired: null,
+        parked: null,
         initFn: null,
     };
     PENDING.push(rec);
@@ -761,6 +842,15 @@ function buildHandles(rec, ctorName) {
         get() { throw new TypeError(msg); },
         set(v) { throw new TypeError(msg); },
     });
+    // PD-44: parked handle -- swapped into every slot at releaseReactive(). A
+    // touch on a pooled instance throws a parked-specific ReactiveDisposedError
+    // (naming Class.prop) so a use-after-release reads differently from a
+    // use-after-dispose. Frozen, NONLIVE-tagged so disposeCore skips it.
+    rec.parked = Object.freeze({
+        [NONLIVE]: "parked",
+        get() { throw new ReactiveDisposedError(ctorName, key, true); },
+        set(v) { throw new ReactiveDisposedError(ctorName, key, true); },
+    });
 }
 
 function nearestAncestorPlan(C) {
@@ -871,6 +961,69 @@ function claimPlan(C, ctorName, registry) {
 function makeDerivedBody(inst, fn) { return function () { return fn.call(inst, inst); }; }
 function makeEffectBody(inst, fn) { return function () { return fn.call(inst, inst); }; }
 
+// PD-42: build the per-instance closure set -- the createRoot thunk, the anchor
+// effect body (writes the owner straight into inst[ANCHOR]), the runWithOwner
+// thunk (rebuilds deriveds + effects), one body per derived, one per effect. The
+// engine retains nothing of a disposed registration (0010 Q3), so these exact
+// closure objects re-register on every acquire (buildGraph) with zero new
+// allocation. Built LAZILY at first releaseReactive and retained on the instance,
+// so a reused instance amortizes the closure cost to zero across acquire/release
+// cycles -- while a construct-once/dispose-once instance never allocates it (0011:
+// building it at first wiring measured 140 / 1 major GC in churn-soak, both over
+// the maxMajor-0 floor; the construct path stays byte-identical to 1.0.0). Cold.
+function prebuildClosures(inst, plan) {
+    const reg = plan.reg;
+    const ders = plan.deriveds;
+    const effs = plan.effects;
+    const derivedBodies = new Array(ders.length);
+    for (let i = 0; i < ders.length; i++) derivedBodies[i] = makeDerivedBody(inst, ders[i].fn);
+    const effectBodies = new Array(effs.length);
+    for (let i = 0; i < effs.length; i++) effectBodies[i] = makeEffectBody(inst, effs[i].fn);
+    const anchorBody = function () { inst[ANCHOR] = reg.getOwner(); };
+    const bundle = {
+        createRootThunk: function () { reg.effect(anchorBody); },
+        runOwnerThunk: null,
+        derivedBodies,
+        effectBodies,
+    };
+    // The runWithOwner thunk carries the SAME OFF/ON introspection branch the
+    // 1.0.0 wireInstance carried; the flags are read at CALL time, so a prebuilt
+    // closure honors a later enableLabels()/auditReactive() exactly as before.
+    // Effects wire AFTER every derived (D-4a): the first synchronous run sees
+    // every field and every derived. Dispose handles are DISCARDED -- teardown is
+    // the anchor cascade.
+    bundle.runOwnerThunk = function () {
+        for (let i = 0; i < ders.length; i++) {
+            inst[ders[i].slot] = reg.computedBox(derivedBodies[i], ders[i].opts);
+        }
+        if (INTROSPECT_ON) {
+            const effHandles = LABELS_ON ? [] : null;
+            for (let i = 0; i < effs.length; i++) {
+                const h = reg.effect(effectBodies[i], effs[i].opts);
+                if (effHandles !== null) effHandles.push(h);
+            }
+            introspectWire(inst, plan, reg, effHandles);
+        } else {
+            for (let i = 0; i < effs.length; i++) {
+                reg.effect(effectBodies[i], effs[i].opts);
+            }
+        }
+    };
+    return bundle;
+}
+
+// The node-building body invoked by reinit (S6-T2): build the R-A anchor, then the
+// deriveds + effects under it, all through a PREBUILT closure set. Signal boxes
+// are NOT built here -- reinit creates them first (all boxes, with reset values) --
+// because the value source differs between construction and reinit while the
+// anchor/derived/effect build is identical. wireInstance keeps its own inline node
+// build (below) so the construct-once path allocates exactly as 1.0.0 did (0011).
+function buildGraph(inst, plan, closures) {
+    const reg = plan.reg;
+    reg.createRoot(closures.createRootThunk);          // R-A anchor -> inst[ANCHOR]
+    reg.runWithOwner(inst[ANCHOR], closures.runOwnerThunk);
+}
+
 function wireInstance(inst, plan) {
     const reg = plan.reg;
     // The WHOLE wiring phase is atomic (D-2h): the buildless box loop and the
@@ -926,7 +1079,10 @@ function wireInstance(inst, plan) {
 function disposeCore(inst, plan) {             // assumes not already disposed
     const reg = plan.reg;
     const a = inst[ANCHOR];
-    if (a !== undefined && a !== DISPOSED) reg.dispose(a); // cascades deriveds + effects
+    // PARKED holds no live anchor node (releaseReactive already cascaded it), so a
+    // dispose-on-parked must NOT re-dispose the sentinel -- it only swaps the
+    // parked handles to poison below and lands the instance DISPOSED.
+    if (a !== undefined && a !== DISPOSED && a !== PARKED) reg.dispose(a); // cascades deriveds + effects
     const sigs = plan.signals;
     for (let i = 0; i < sigs.length; i++) {
         const r = sigs[i];
@@ -1045,6 +1201,7 @@ function makeSignalRecFromValue(key, initFn, opts) {
         plan: null,
         poison: null,
         prewired: null,
+        parked: null,
         initFn,
     };
 }
@@ -1117,6 +1274,7 @@ function makeDerivedRec(key, fn, opts) {
         plan: null,
         poison: null,
         prewired: null,
+        parked: null,
         initFn: null,
     };
 }
@@ -1312,6 +1470,129 @@ export function disposeReactive(vm) {
     return true;
 }
 
+// --- Pooled lifecycle: release + reinit (S6-T3, PD-42(b)/PD-44) ---------------
+
+// The cold inverse of buildGraph: tear the graph down to the engine pool exactly
+// as disposeCore does (anchor cascade + per-box dispose) but swap every slot to
+// its per-class PARKED handle (not poison), keep the prebuilt CLOSURES slot, and
+// set ANCHOR to the PARKED sentinel. A parked instance holds ZERO engine nodes.
+function releaseCore(inst, plan) {             // assumes a LIVE instance
+    const reg = plan.reg;
+    const a = inst[ANCHOR];
+    if (a !== undefined && a !== DISPOSED && a !== PARKED) reg.dispose(a); // cascades deriveds + effects
+    const sigs = plan.signals;
+    for (let i = 0; i < sigs.length; i++) {
+        const r = sigs[i];
+        const box = inst[r.slot];
+        if (box !== undefined && box[NONLIVE] === undefined) reg.dispose(box);
+        inst[r.slot] = r.parked;
+    }
+    const ders = plan.deriveds;
+    for (let i = 0; i < ders.length; i++) {
+        inst[ders[i].slot] = ders[i].parked;   // cboxes already cascaded
+    }
+    inst[ANCHOR] = PARKED;
+}
+
+/**
+ * Release a live reactive instance to the engine pool: cascade its anchor,
+ * dispose each signal box, and swap every slot to a PARKED handle that throws a
+ * parked-specific `ReactiveDisposedError` on touch. The instance keeps its
+ * prebuilt wiring closures so `reinitReactive(vm)` can revive it with zero new
+ * closure allocation. Idempotent on an already-parked instance (returns `false`,
+ * mirroring `disposeReactive`'s double-dispose contract); returns `true` on the
+ * first successful release. Fails closed (named throw) on a non-reactive value, an
+ * unwired instance, a frozen instance, or a terminally-disposed one -- a disposed
+ * instance is gone and cannot be pooled (0011).
+ */
+export function releaseReactive(vm) {
+    const plan = planOf(vm);
+    if (plan === undefined) throwNoPlan("releaseReactive");
+    const a = vm[ANCHOR];
+    if (a === PARKED) return false;            // idempotent park->park (0011)
+    if (a === DISPOSED) throwReleaseDisposed(plan.ctorName);
+    if (a === undefined) throwNotWired("releaseReactive");
+    if (Object.isFrozen(vm)) throwReleaseFrozen(plan.ctorName);
+    const reg = plan.reg;
+    // Same re-entrancy guard disposeReactive carries (D-2f): releasing from inside
+    // one of this instance's OWN @derived computations would cascade the very node
+    // being computed (fail-open). The isTracking() gate keeps the plain-code path
+    // zero-alloc; only under tracking do we pay one getOwner() descriptor.
+    if (reg.isTracking()) {
+        const cur = reg.getOwner();
+        if (cur !== undefined) {
+            const ders = plan.deriveds;
+            for (let i = 0; i < ders.length; i++) {
+                const h = vm[ders[i].slot];
+                if (h !== undefined && h[NONLIVE] === undefined && reg.nodeId(h) === cur.id) {
+                    throwSelfDisposeInDerived(plan.ctorName, ders[i].key, "releaseReactive");
+                }
+            }
+        }
+    }
+    if (INTROSPECT_ON) introspectDispose(vm, reg);
+    // Retain the prebuilt closure set on first release (reuse intent now known):
+    // every later reinit re-registers these exact closures with zero new
+    // allocation (0010 Q3), amortizing the cost to zero across acquire/release.
+    if (vm[CLOSURES] === undefined) vm[CLOSURES] = prebuildClosures(vm, plan);
+    releaseCore(vm, plan);
+    return true;
+}
+
+/**
+ * Revive a PARKED reactive instance: rebuild its signal boxes (with `initials`'
+ * values where given, else the plan's initials), rebuild the anchor, deriveds,
+ * and effects through the PREBUILT closures, and restore every slot to a live
+ * handle. Atomicity is identical to construction -- any throw mid-reinit routes
+ * through disposeCore, leaving conservation exact and the instance terminally
+ * DISPOSED (a failed revival is final; fail closed). Returns the same `vm`.
+ * Requires PARKED: fails closed (named throw) on a live, disposed, frozen,
+ * unwired, or non-reactive value -- null is not zero.
+ */
+export function reinitReactive(vm, initials) {
+    const plan = planOf(vm);
+    if (plan === undefined) throwNoPlan("reinitReactive");
+    const a = vm[ANCHOR];
+    if (a === DISPOSED) throwReinitDisposed(plan.ctorName);
+    if (a === undefined) throwNotWired("reinitReactive");
+    if (a !== PARKED) throwReinitLive(plan.ctorName);      // a live anchor node
+    if (Object.isFrozen(vm)) throwReinitFrozen(plan.ctorName);
+    if (initials !== undefined) {
+        if (initials === null || typeof initials !== "object") throwReinitInitials(plan.ctorName);
+        const ikeys = Reflect.ownKeys(initials);
+        for (let i = 0; i < ikeys.length; i++) {
+            const rec = plan.byKey.get(ikeys[i]);
+            if (rec === undefined || rec.kind !== "signal") throwReinitInitialsKey(plan.ctorName, ikeys[i], plan);
+        }
+    }
+    const reg = plan.reg;
+    const closures = vm[CLOSURES];
+    try {
+        // Rebuild every signal box with its reset value: caller override first,
+        // then the buildless plan initFn, then the decorator field-initial captured
+        // per member in makeInit. Boxes rebuild BEFORE buildGraph so deriveds and
+        // effects see them on the first synchronous run (D-4a), same as construction.
+        const sigs = plan.signals;
+        for (let i = 0; i < sigs.length; i++) {
+            const r = sigs[i];
+            let v;
+            if (initials !== undefined && Object.prototype.hasOwnProperty.call(initials, r.key)) {
+                v = initials[r.key];
+            } else if (r.initFn !== null) {
+                v = r.initFn(vm);
+            } else {
+                v = SIG_INITIAL.get(r);
+            }
+            vm[r.slot] = reg.signalBox(v, r.opts);
+        }
+        buildGraph(vm, plan, closures);
+    } catch (e) {
+        disposeCore(vm, plan);                 // failed revival is terminal -> DISPOSED
+        throw e;
+    }
+    return vm;
+}
+
 /**
  * Return the live SignalBox/ComputedBox backing a reactive member. Throws
  * `ReactiveDisposedError` if the instance was disposed, and a named error for an
@@ -1327,6 +1608,7 @@ export function boxOf(vm, key) {
     if (h === undefined || h === null) throwNotWired("boxOf");
     const nl = h[NONLIVE];
     if (nl === "disposed") throw new ReactiveDisposedError(plan.ctorName, key);
+    if (nl === "parked") throw new ReactiveDisposedError(plan.ctorName, key, true);
     if (nl === "prewired") throwPrewiredMember(plan.ctorName, key);
     return h;
 }
@@ -1342,6 +1624,7 @@ export function rootOf(vm) {
     const a = vm[ANCHOR];
     if (a === undefined) throwNotWired("rootOf");
     if (a === DISPOSED) throw new ReactiveDisposedError(plan.ctorName, "<root>");
+    if (a === PARKED) throw new ReactiveDisposedError(plan.ctorName, "<root>", true);
     return a;
 }
 
@@ -1661,4 +1944,4 @@ export function auditReactive(on) {
 // --- Version ------------------------------------------------------------------
 
 /** Package version. Kept in lockstep with package.json and llms.txt. */
-export const VERSION = "1.0.0";
+export const VERSION = "1.1.0";

package/llms.txt

@@ -1,6 +1,6 @@
 # @zakkster/lite-signal-decorators
 
-VERSION 1.0.0
+VERSION 1.1.0
 
 > Stage-3 decorator layer over @zakkster/lite-signal. Turns a plain class into a
 > reactive view-model where each instance has a measured per-property cost, a
@@ -20,7 +20,7 @@ zero decorator syntax, sharing the SAME core by function identity.
 slot for a poison handle, so any later read/write throws a named
 `ReactiveDisposedError`.
 
-## Exports (16)
+## Exports (18)
 
 - `reactive` -- `@reactive accessor x = v` (bare) or `@reactive({ equals })`
   (factory). Declares a per-instance signal.
@@ -48,6 +48,18 @@ slot for a poison handle, so any later read/write throws a named
   buildless contract.
 - `disposeReactive(vm) -> boolean` -- cascade + poison teardown. Idempotent: a
   second call returns `false` and changes nothing.
+- `releaseReactive(vm) -> boolean` -- park a LIVE instance to the engine pool:
+  cascade the anchor, dispose each signal box, swap every slot to a per-class
+  PARKED handle, keep the prebuilt wiring closures. A parked instance holds ZERO
+  engine nodes. `true` on the first release, `false` on park->park (idempotent,
+  mirrors double-dispose). Fails closed on a disposed, unwired, frozen, or
+  non-reactive value. See the pooled-lifetime contract (decisions/0010, 0011).
+- `reinitReactive(vm, initials?) -> vm` -- revive a PARKED instance: rebuild each
+  signal box (`initials[key]` wins, else the plan initial), rebuild the anchor +
+  deriveds + effects through the SAME prebuilt closures, restore live slots.
+  Atomic: any throw mid-reinit routes through disposeCore and lands the instance
+  DISPOSED (a failed revival is final). Fails closed on a live, disposed, frozen,
+  unwired, or non-reactive value. Two-call lifecycle by design (decisions/0011).
 - `boxOf(vm, key) -> SignalBox | ComputedBox` -- the live box behind a member;
   throws with a did-you-mean on an unknown key, `ReactiveDisposedError` after
   dispose.
@@ -68,7 +80,7 @@ slot for a poison handle, so any later read/write throws a named
   `FinalizationRegistry` reports any instance GC'd without `disposeReactive`.
 - `ReactiveDisposedError` -- `extends Error`, `name` `"ReactiveDisposedError"`,
   fields `className` and `key`.
-- `VERSION` -- `"1.0.0"`.
+- `VERSION` -- `"1.1.0"`.
 
 ## Registry law (one registry per host chain)
 
@@ -195,16 +207,42 @@ runtime requirement -- the shipped surface runs on 1.5.0.
 
 ## Scope note
 
-1.0.0 FREEZES the export surface -- 16 exports: the 11 runtime exports plus
-`costOf`, `capacityFor`, `enableLabels`, `labelOf`, and `auditReactive` (all
-cold / opt-in; the hot accessor canon is byte-identical to 0.3.0). The semver
-promise from here: any change to an existing export's signature or behavior is a
-MAJOR, recorded in a decision file; new exports are minors; the hot accessor
-canon (`makeGet`/`makeSet`) does not move without a major. Also present since
+1.0.0 FROZE the export surface at 16; 1.1.0 adds `releaseReactive` +
+`reinitReactive` (an additive MINOR under that promise) -> 18 exports: the 13
+runtime exports plus `costOf`, `capacityFor`, `enableLabels`, `labelOf`, and
+`auditReactive` (all cold / opt-in; the hot accessor canon is byte-identical to
+0.3.0). The semver promise from here: any change to an existing export's
+signature or behavior is a MAJOR, recorded in a decision file; new exports are
+minors; the hot accessor canon (`makeGet`/`makeSet`) does not move without a
+major. Also present since
 0.3.0: the dev-side class-reactivity benchmark (`bench/`, private, never
 shipped) and the fleet-soak torture scenario; the formal kill-criteria verdicts
-live in decisions/0006-kill-criteria.md. Still OUT of the 1.0 surface (each a
+live in decisions/0006-kill-criteria.md. Composition recipes over this frozen
+surface (the MobX-parity-by-composition matrix, the two-plane fleet, the
+lite-store boundary) live in COOKBOOK.md, delivered GitHub-only and NOT in the
+tarball -- read it at
+https://github.com/PeshoVurtoleta/lite-signal-decorators/blob/main/COOKBOOK.md
+(every code block byte-verified against a GC-gated companion; decisions/0009). Still OUT of the 1.1 surface (each a
 deliberate, documented exclusion, not an oversight): private (`#`) members,
-static members, module/global signals (raw lite-signal territory), and any
-instance reinitialization / pooling API -- an instance is single-lifetime,
-disposed once, never revived.
+static members, and module/global signals (raw lite-signal territory).
+
+## Pooled lifetime (1.1.0)
+
+An instance is no longer single-lifetime. It moves on a three-state lattice --
+LIVE / PARKED / DISPOSED -- driven by a two-call API. `releaseReactive(vm)` parks
+a LIVE instance (cascades the anchor, disposes each box, holds ZERO engine nodes,
+keeps its prebuilt wiring closures); `reinitReactive(vm, initials?)` revives a
+PARKED one (rebuilds boxes + anchor + deriveds + effects through the SAME
+closures, values reset). Two calls, not one: park and revive are separated in
+time by the pool, and `disposeReactive`'s frozen `(vm) -> boolean` signature
+cannot double as park (decisions/0011). Fail closed: every member touch on a
+PARKED instance throws `ReactiveDisposedError` with a *parked* message (not
+"disposed"), and `boxOf`/`rootOf` agree; a throw mid-reinit routes through
+disposeCore and lands the instance DISPOSED (a failed revival is final); DISPOSED
+is TERMINAL -- only a PARKED instance revives, a disposed one is gone and cannot
+be pooled. park->park is idempotent (`false`); dispose-on-parked lands DISPOSED
+and stays idempotent. The prebuilt closure set is built LAZILY at first
+`releaseReactive`, so the construct-once/dispose-once path is byte-untouched
+(0011); the amortization holds -- one closure build per reused instance,
+re-registered across all N acquire/release cycles with zero new allocation. See
+decisions/0010 (the spike contract, measured) and 0011 (the API shape).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zakkster/lite-signal-decorators",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Stage-3 decorator layer over @zakkster/lite-signal. The reactive class layer where an instance has a measured cost, deterministic teardown, and a churn benchmark.",
   "author": "Zahary Shinikchiev <shinikchiev@yahoo.com>",
   "license": "MIT",
@@ -68,6 +68,7 @@
     "torture:controls": "node test/torture/run.mjs --controls",
     "torture:peer-preview": "node test/torture/peer-preview.mjs",
     "gate": "node test/gate.mjs",
+    "cookbook": "node cookbook/run.mjs",
     "spikes": "for f in spikes/*.mjs; do echo \"== $f ==\"; node --expose-gc \"$f\" || exit 1; done",
     "spike:emit": "node --expose-gc spikes/emit/probe.mjs",
     "spike:ownership": "node --expose-gc spikes/ownership.mjs",
@@ -88,10 +89,13 @@
     "@babel/core": "^7.25.0",
     "@babel/plugin-proposal-decorators": "^7.25.0",
     "@babel/preset-typescript": "^7.29.7",
+    "@zakkster/lite-arena": "1.9.0",
+    "@zakkster/lite-await": "1.1.1",
     "@zakkster/lite-devtools": "^1.4.0",
     "@zakkster/lite-gc-profiler": "^1.16.0",
     "@zakkster/lite-leak": "^1.10.0",
     "@zakkster/lite-signal": "1.5.0",
+    "@zakkster/lite-store": "1.2.0",
     "@zakkster/lite-watch-ex": "^1.1.0",
     "esbuild": "0.28.2",
     "typescript": "^5.6.0"