@zakkster/lite-signal-decorators 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -4,6 +4,102 @@ All notable changes to `@zakkster/lite-signal-decorators` are documented here.
 The format follows Keep a Changelog; this project adheres to Semantic
 Versioning.
 
+## [1.2.0] - 2026-08-30
+
+The flagship of the decisions/0013 strategic-admission track: a story-grade,
+release-after-release ladder (S8 `@localTo` -> S9 `snapshotOf` -> S10
+`costOfInstance` -> S11 fleet helpers), and this is its first rung. `@localTo`
+clears strategic criterion (a) -- impossible to compose correctly on the shipped
+surface: PD-51 measured the effect-based recipe clobbering a user write one tick
+late, so glitch-free reset needs in-package compare-on-read machinery. The one
+release nobody else can copy from a recipe.
+
+### Added
+
+- **`@localTo(source, { equals? })`** -- upstream-keyed resettable local state
+  (19th export; the 18-member surface grows by exactly one). A field FOLLOWS
+  `source(self)` until someone writes it, a write OVERRIDES, and a changed
+  upstream RESETS it -- decided by compare-on-read, so it is glitch-free,
+  synchronous, and PURE (no box write on the read path; legal inside any
+  `@derived`). `source` is a REQUIRED tracked `(self) => value` fn read inline
+  (no extra node). `equals` (default `Object.is`) governs the upstream compare
+  ONLY -- the write path never compares.
+- **The `locals` buildless section** -- `defineReactive(Class, { ..., locals })`
+  with `locals: { key: { source, equals?, initial? } }`, the buildless twin of
+  `@localTo` (fail closed on a missing/non-fn source), full parity with the
+  decorator path on both emit lanes.
+- **The initial-value unification rule** (decisions/0014): a declared
+  initializer means the member STARTS there and resets on the first upstream
+  move (the `@trackedReset` flavor); an OMITTED initializer means the initial is
+  the source evaluated once at wiring and the member follows upstream from the
+  first read (the `@localCopy` flavor). One decorator, both field semantics,
+  selected by the natural syntax.
+- **The ABA contract, stated plainly** (decisions/0014, shipped + asserted): no
+  public revision counter exists (NodeDescriptor is `{id, kind, value}`), so the
+  upstream compare is VALUE-based. Upstream A -> local write X -> upstream B ->
+  upstream back to an equals-A value leaves the read showing the STALE LOCAL X --
+  the reset requires upstream to change relative to the last adoption, not to
+  have moved transitively. tracked-toolbox's `@localCopy` has the same property;
+  it is documented in README/llms.txt, pinned in torture (S8-A6), never softened.
+- **The `localto-torture` lane** (`test/torture/localto-torture.mjs`, scenario
+  13 of 17) with its own `TORTURE_BREAK` sabotage control: the zero-alloc
+  read/write storm, the ABA-stale write/reset interleave asserted AS the
+  contract, pooled park/reinit box+seen reset, and tracking-edge + pure-compute
+  pins.
+- **`test/17-localto.test.mjs`** (34 cases) -- the full lattice on both emit
+  lanes plus buildless `locals`: read/write/reset, both initial flavors, the ABA
+  contract, `equals` override survival, park/reinit reset, `costOf` accounting,
+  source-throw fail-closed, and the option/source rejection matrix.
+- Emit fixtures extended: `fixture.src.ts` gains a `@localTo` member; the two
+  compiled outs + the source hash regenerate (no new fixture row or file).
+
+### Changed
+
+- **The per-instance cost formula is now `P + L + D + E + 1`** (was `P + D + E +
+  1`): one signal box per local plus the anchor; the plain per-instance seen-slot
+  is never a node (+0). `costOf` returns the `L` term; `capacityFor` sizes it.
+  Reflected everywhere the formula appears in README/llms.txt.
+- The shipped `SignalDecorators.d.ts` header de-staged to emitter-named
+  phrasing (PD-49) -- a 1.1.1 zero-grep escapee (the sweep listed the `.js`
+  but not the `.d.ts`), caught by the S8 review.
+- **The export surface: 18 -> 19** -- an additive MINOR under the 1.0.0 semver
+  promise (new exports are minors). The 1.0.0 hot canon
+  (`makeGet`/`makeSet`/`makeDerivedGet`) stays byte-identical: `@localTo` ships
+  its own accessor bodies and pays its own measured cost.
+- Three-place version sync to 1.2.0 (`package.json`, the `VERSION` const,
+  `llms.txt`); the `test/15` surface-freeze recount 18 -> 19.
+
+### Measured (rig: Node v26.3.1, arm64 Apple M4 Pro, lite-signal 1.5.0)
+
+- A `@localTo` read measures **1.69x** a plain decorated read (two tracked reads
+  + a compare, versus one box read) -- documented as-is, not softened.
+- Read AND write storms at N and 8N: **0.000 B/op** (control-relative +2 B), gc
+  major **0**, `maxPauseMs <= 0.08`; a derived over one local holds EXACTLY 2
+  source edges (upstream + box), 0 extra nodes over 1e5 reads.
+- 4096 park/reinit cycles: `tracker.size()` 0, findings 0, warnings 0,
+  `activeNodes` to exact baseline, zero pool growths; release frees exactly
+  `P + L + D + E + 1` nodes.
+
+Records: decisions/0013 (strategic-admission track), decisions/0014 (the localTo
+contract + the ratified spike numbers), `spikes/localto-contract.mjs` (Q1..Q6,
+EXIT A green against peer 1.5.0).
+
+### Gate output (section-10 chain, archived verbatim)
+
+```
+  fixtures              OK       exit 0 -- emit fixtures regenerated
+  test                  OK       exit 0 -- 291 pass / 0 fail
+  test:gc               OK       exit 0 -- 291 pass / 0 fail
+  torture               OK       exit 0 -- 15 passed, 2 skipped, 0 warned, 0 failed in 33.5s
+  torture:controls      OK       exit 0 -- 17 passed, 0 skipped, 0 warned, 0 failed in 2.8s
+  torture:peer-preview  REPORTED NON-BLOCKING -- lane completed (exit 0) [preview 1.9.0-preview.6 SUITE-GREEN 17/0/0/0; canary 1.9.0-canary.1 SUITE-GREEN 17/0/0/0]
+  bench:selftest        OK       exit 0 -- ALL PASS -- 22 passed, 0 failed
+  cookbook              OK       exit 0/0 -- corpus 18/18 companions ok in 2.1s; controls 8/8 controls fail correctly in 5.1s
+  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.1.1] - 2026-08-30
 
 A docs-accuracy patch. No runtime, fixture, or emit-matrix byte changed; the

package/README.md

@@ -15,7 +15,7 @@
 > view-model with a measured per-property cost, one deterministic teardown, and
 > poison-on-dispose safety -- built on @zakkster/lite-signal.
 
-**`@reactive accessor` fields, `@derived` getters, `@reactiveEffect` methods, `@batched` actions, one `@reactiveHost` wiring site -- and `disposeReactive()` tears the whole instance down in one call, every time, with nothing left dangling. A decorated read costs ~1.0x a hand-written instance-field signal read. An instance costs exactly P + D + E + 1 pool nodes and gives all of them back on dispose. A buildless twin, `defineReactive()`, delivers the identical feature set with zero transpiler.**
+**`@reactive accessor` fields, `@derived` getters, `@reactiveEffect` methods, `@batched` actions, one `@reactiveHost` wiring site -- and `disposeReactive()` tears the whole instance down in one call, every time, with nothing left dangling. A decorated read costs ~1.0x a hand-written instance-field signal read. An instance costs exactly P + L + D + E + 1 pool nodes and gives all of them back on dispose. A buildless twin, `defineReactive()`, delivers the identical feature set with zero transpiler.**
 
 ```js
 import { reactive, derived, reactiveHost, disposeReactive } from "@zakkster/lite-signal-decorators";
@@ -100,7 +100,7 @@ class Player {
   }
 }
 
-const p = new Player();  // exactly 2 + 2 + 1 + 1 = 6 pool nodes (P + D + E + 1)
+const p = new Player();  // exactly 2 + 0 + 2 + 1 + 1 = 6 pool nodes (P + L + D + E + 1)
 p.hit(80);               // shield 0, hp 70 -> status still "healthy": effect does NOT re-run
 p.hit(20);               // hp 50 -> "critical": effect runs once
 disposeReactive(p);      // effect stopped, deriveds + boxes disposed, slots poisoned
@@ -138,6 +138,7 @@ const ReactivePlayer = defineReactive(Player, {
 
 - **`@reactive accessor x = v`** -- a per-instance signal box in a unique symbol slot. The read body is one slot load + one monomorphic box call: zero branches, zero allocation.
 - **`@derived get y()`** -- a lazy computed owned by the instance's anchor, with optional custom `equals` for change-cutoff.
+- **`@localTo(source) accessor x = v`** -- upstream-keyed resettable local state: reads follow `source(self)` until you write, a write overrides, and a changed upstream resets it -- glitch-free by compare-on-read, no effect, no extra tick. With an initializer the field starts there and resets on the first upstream move; without one it follows upstream from wiring. One signal box + one plain seen-slot per member; the read is pure, so it is legal inside any `@derived`.
 - **`@reactiveEffect m()`** -- a method that auto-runs as an effect after wiring. Manual calls are leak-guarded (a call inside a foreign tracking scope is untracked, so it records zero stray dependencies) and identity-guarded (a foreign receiver throws by name instead of running against garbage).
 - **`@batched m()`** -- the method body inside one engine batch: N writes, one flush. Action-grade by design, with a measured per-call cost -- not a per-frame path.
 - **`@reactiveHost`** -- the single wiring site. Its most-derived constructor builds the anchor, every derived, and every effect exactly once, after all fields of all classes in the chain initialize. `@reactiveHost({ registry })` binds the whole chain to an isolated lite-signal registry.
@@ -205,7 +206,7 @@ The failure mode this package is built against is not "reactivity doesn't work"
 
 ### Member decorators
 
-All four take a bare form and a factory form (`@reactive` and `@reactive({...})` both work).
+The first four take a bare form and a factory form (`@reactive` and `@reactive({...})` both work); `@localTo` is the exception -- it always takes a required `source` argument (detailed below the table).
 
 | Decorator | Placement | Options | Behavior |
 |---|---|---|---|
@@ -213,6 +214,24 @@ All four take a bare form and a factory form (`@reactive` and `@reactive({...})`
 | `@derived` | `get y()` | `equals(a, b)` | Lazy computed owned by the anchor. Recomputes on dependency change; `equals` cuts propagation when the result is unchanged. |
 | `@reactiveEffect` | `m()` | `scheduler(run)` | Auto-runs as an effect at wiring, re-runs on tracked changes. `scheduler` defers re-runs (frame coalescing etc.). Manual calls: leak-guarded + identity-guarded. |
 | `@batched` | `m()` | -- | Runs the body inside one engine batch: all writes flush once, at close. Nesting flushes at the outermost close. Action-grade -- see [the numbers](#the-numbers). |
+| `@localTo` | `accessor x = v` | `equals(a, b)` | Upstream-keyed resettable local state. Read follows `source(self)` until written, a write overrides, a changed upstream resets. Compare-on-read (pure); `equals` governs the upstream compare only. Takes a REQUIRED `source` argument -- see below. |
+
+### `localTo(source, { equals? }?)`
+
+`@localTo(source)` declares a field that **follows an upstream value until someone writes it, then resets when upstream changes** -- the "local copy you can edit, that re-syncs on a real update" pattern, done glitch-free with no effect and no extra tick. `source` is a REQUIRED tracked `(self) => value` function, read inline on every get (no extra node). The get is **pure** -- it compares `source(self)` to a per-instance last-seen slot and returns the local box when upstream is unchanged, else the upstream value; it never writes a box, so a `@localTo` read is legal inside any `@derived`. A write always overrides (the write path never compares). `{ equals }` (default `Object.is`) governs the **upstream** compare only.
+
+Two field flavors, selected by the natural syntax (the [initial-value unification rule](decisions/0014-localto-contract.md)):
+
+```js
+@reactiveHost
+class Field {
+  @reactive accessor upstream = "server";
+  @localTo((self) => self.upstream) accessor draft;        // no initial: FOLLOWS upstream from wiring
+  @localTo((self) => self.upstream) accessor pinned = "";  // initial: STARTS "", resets on first upstream move
+}
+```
+
+**The ABA contract (honest, shipped, never softened).** The upstream compare is VALUE-based -- lite-signal exposes no public revision counter, and reaching for a private one would be impure. So the reset triggers when upstream *changes relative to the last adoption*, not when it has moved transitively: upstream `A` -> local write `X` -> upstream `B` -> upstream back to an equals-`A` value leaves the read showing the **stale local `X`**. tracked-toolbox's `@localCopy` has the same property. A coarse custom `equals` widens override survival on purpose. See the [compare-on-read design bullet](#design-decisions-worth-knowing).
 
 ### Class decorator
 
@@ -229,6 +248,7 @@ The buildless twin. Installs the members on `Class.prototype`, wraps the class t
 |---|---|---|
 | `signals` | `["a", "b"]` or `{ key: value \| { initial \| init \| equals } }` | A plain non-function value is the initial. `initial` is taken verbatim; `init(self)` computes per instance; a bare function is a named throw (ambiguous -- wrap it). |
 | `deriveds` | `{ key: (self) => value \| { get, equals } }` | |
+| `locals` | `{ key: { source, equals?, initial? } }` | Map only. The buildless twin of `@localTo`. `source` REQUIRED and a `(self) => value` fn (missing/non-fn is a named throw); `equals` governs the upstream compare; `initial` (verbatim) selects the reset-from flavor, its absence the follow-from-wiring flavor. |
 | `effects` | `{ key: (self) => void \| { run, scheduler } }` | Map only. |
 | `host` | `{ registry }` or omitted | Same validation as `@reactiveHost`. |
 
@@ -248,7 +268,7 @@ Symbol keys work (`Reflect.ownKeys`). A spec key colliding with an own property
 
 | Export | Signature | Behavior |
 |---|---|---|
-| `costOf` | `(Factory) => { nodes, links, signals, deriveds, effects }` | The measured, settled per-instance cost, probed on the class's bound registry (frozen result, cached per class). Double-probed: an inconclusive or polluted probe THROWS -- never a guess. `nodes` is exactly P + D + E + 1; `links` is the first-full-read link count. |
+| `costOf` | `(Factory) => { nodes, links, signals, deriveds, effects }` | The measured, settled per-instance cost, probed on the class's bound registry (frozen result, cached per class). Double-probed: an inconclusive or polluted probe THROWS -- never a guess. `nodes` is exactly P + L + D + E + 1; `links` is the first-full-read link count. |
 | `capacityFor` | `(inventory, { headroom }?) => RegistryConfig` | Sizes a `createRegistry` config from `[Factory, count]` pairs: nodes exact, links x `headroom` (floored at the engine minimum of 1), `prealloc: "eager"`, `onCapacityExceeded: "throw"`. Fail-closed inventory and options validation. Link policy + caveats: [decisions/0007](decisions/0007-capacity-policy.md). |
 | `enableLabels` / `labelOf` | `(on)` / `(idOrHandle, registry?) => string \| undefined` | Opt-in devtools identity (default OFF): while on, wiring registers per-registry `nodeId -> "Class.prop"` / `"Class#method"` / `"Class@anchor"`; dispose unregisters. `labelOf` misses return `undefined`, never throw. |
 | `auditReactive` | `(on)` | Opt-in leak auditor (default OFF): a lazily-created `FinalizationRegistry` reports any instance collected WITHOUT `disposeReactive`, naming class and shape. Holds no instance references itself; zero cost and zero registrations while off. |
@@ -260,7 +280,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.1.1"` |
+| `VERSION` | `"1.2.0"` |
 
 ### The rejection matrix
 
@@ -349,6 +369,8 @@ The fair baseline for a decorated property is a hand-written instance field (`th
 
 A decorated reactive property costs **~1.0x a hand-written instance-field signal read**; both are ~2x a module-level signal because that is the cost of per-instance storage, paid either way -- an engine indirection, not a decorator tax. Writes are ~2.5-3x a module-const read across all instance layouts (box `.set` propagation dominates; inherent to any reactive write). The rejected dictionary layout is the one that *degrades at fleet scale* (cross-instance IC megamorphism) -- the hazard only a class-shaped benchmark exposes, and the reason this package doesn't use one.
 
+A `@localTo` read measures **1.69x** a plain decorated read -- two tracked reads (upstream `source` + the local box) plus a value compare, versus the one box read of `@reactive` -- and it pays that cost with **0.000 B/op** under the read/write storms (`gc.major 0`, observed `maxPauseMs` 0.07-0.08 against the 4.0 gate); the compare-on-read is honest arithmetic, not free.
+
 ### `@batched` per call (`spikes/batched-cost.mjs`)
 
 | Path | ns/op |
@@ -361,7 +383,7 @@ The ~7 ns over raw batch is the guarded thunk + rest-array the decorator allocat
 
 ### Per instance
 
-`P + D + E + 1` pool nodes -- one per signal, per derived, per effect, plus the anchor. All of them return to the pool on dispose: conservation is node-exact (`activeNodes` to baseline, zero pool growths, allocations minus disposals reconciled) over 4096-cycle churn and a wall-clock soak.
+`P + L + D + E + 1` pool nodes -- one per signal, per local, per derived, per effect, plus the anchor. All of them return to the pool on dispose: conservation is node-exact (`activeNodes` to baseline, zero pool growths, allocations minus disposals reconciled) over 4096-cycle churn and a wall-clock soak.
 
 <details>
 <summary><strong>Zero-GC design notes: the allocation table + the gates</strong></summary>
@@ -373,15 +395,15 @@ The ~7 ns over raw batch is the guarded thunk + rest-array the decorator allocat
 | `@derived get` read | none | lazy computed read |
 | Effect re-run | none retained | gated: zero major GC across the read/write torture lanes |
 | `@batched m()` call | 1 thunk + 1 rest array | the documented, measured exception (+7 ns vs raw batch); action-grade only |
-| `new Host()` | P + D + E + 1 pool nodes | plus the instance itself; nodes recycle on dispose (F-0 conservation) |
+| `new Host()` | P + L + D + E + 1 pool nodes | plus the instance itself; nodes recycle on dispose (F-0 conservation) |
 | `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.1.1):
+The gates that hold it (run on every change, all green at 1.2.0):
 
-- `npm test` / `npm run test:gc` -- **257/257** on both lanes.
+- `npm test` / `npm run test:gc` -- **291/291** 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: **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.
+- Torture: **17 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; the `localto-torture` zero-alloc read/write storm + ABA-stale interleave lattice + pooled park/reinit) -- **15 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 -- **17/17 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 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.
@@ -406,18 +428,19 @@ Full rationale lives in [`decisions/`](decisions/) -- each is a numbered, dated
 - **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)).
+- **`@localTo` resets by compare-on-read, and its ABA limit is stated, not hidden (1.2.0).** The reset is decided *on the read* -- `source(self)` compared to a per-instance last-seen slot -- so it is glitch-free, synchronous, and pure (no box write on read, legal inside a `@derived`). The rejected alternative was an effect that watches upstream and clears the local: PD-51 measured that recipe clobbering a user's write one tick late, which is the whole reason the feature lives in-package instead of a cookbook recipe. Because the compare is value-based (lite-signal exposes no public revision counter and a private one would be impure), the honest limit is ABA: upstream `A` -> local write -> upstream `B` -> upstream back to an equals-`A` value shows the stale local -- the same property tracked-toolbox's `@localCopy` ships, documented rather than papered over ([decisions/0013](decisions/0013-strategic-admission-track.md), [0014](decisions/0014-localto-contract.md)).
 
 ---
 
 ## Testing (for clients & QA)
 
 ```bash
-npm test            # node --test, 257 tests
-npm run test:gc     # the same 257 with --expose-gc (enables the allocation assertions)
+npm test            # node --test, 291 tests
+npm run test:gc     # the same 291 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
 ```
 
-**257 tests** across sixteen files, all green at 1.1.1. The decorator protocol is tested three times over: against a mock standard-decorators emitter *and* against committed real TypeScript 5 and Babel `2023-11` emits, so both toolchains' codegen is pinned, not assumed.
+**291 tests** across seventeen files, all green at 1.2.0. The decorator protocol is tested three times over: against a mock standard-decorators emitter *and* against committed real TypeScript 5 and Babel `2023-11` emits, so both toolchains' codegen is pinned, not assumed.
 
 | File | Tests | Covers |
 |---|---:|---|
@@ -435,8 +458,9 @@ 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 |
+| `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 19 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 |
+| `17-localto` | 34 | `@localTo` on both emit lanes + buildless `locals`: the read/write/upstream-reset lattice, both initial flavors (follow-from-wiring vs reset-from-initial), the ABA stale-local contract, `equals` override survival, park/reinit box+seen reset, `costOf` = P+L+D+E+1, source-throw fail-closed, and the fail-closed option/source matrix |
 
 ### Emit-support matrix
 
@@ -447,14 +471,14 @@ Generated by `node test/fixtures/emit-matrix.mjs` from `test/fixtures/hashes.jso
 
 | Source | Emitter | Emit lane | Compiled output | sha256 | At decoration time |
 |---|---|---|---|---|---|
-| `fixture.src.ts` | TypeScript 5 | standard 2023-11 | `ts-out/fixture.src.js` | `1a3fc0f943bf` | accepted -- full decorator surface wired + pinned green |
-| `fixture.src.ts` | Babel | standard 2023-11 | `babel-out/fixture.src.js` | `eb9dfb5939b1` | accepted -- full decorator surface wired + pinned green |
+| `fixture.src.ts` | TypeScript 5 | standard 2023-11 | `ts-out/fixture.src.js` | `5d6837710b34` | accepted -- full decorator surface wired + pinned green |
+| `fixture.src.ts` | Babel | standard 2023-11 | `babel-out/fixture.src.js` | `f7d8b3e5ed19` | accepted -- full decorator surface wired + pinned green |
 | `static.src.ts` | TypeScript 5 | standard 2023-11 | `ts-out/static.src.js` | `d2a03e3d5f70` | rejected -- static member is a named throw at decoration time |
 | `static.src.ts` | Babel | standard 2023-11 | `babel-out/static.src.js` | `dc936c5aa235` | rejected -- static member is a named throw at decoration time |
 | `legacy.src.ts` | TypeScript 5 | legacy (experimental) | `ts-legacy-out/legacy.src.js` | `c1059b1d37b1` | rejected -- legacy emit -> named rejection at decoration time |
 | `legacy.src.ts` | Babel | legacy (experimental) | `babel-legacy-out/legacy.src.js` | `1d35a02c57ce` | rejected -- legacy emit -> named rejection at decoration time |
 
-Source hashes: `fixture.src.ts` `fb492a396340`, `static.src.ts` `81fb649965e6`, `legacy.src.ts` `30ac3dabaf7c`.
+Source hashes: `fixture.src.ts` `339c40148a70`, `static.src.ts` `81fb649965e6`, `legacy.src.ts` `30ac3dabaf7c`.
 <!-- EMIT-MATRIX:END -->
 
 ### The torture suite (dev-side, never shipped)
@@ -462,13 +486,13 @@ 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 16 scenarios (14 run + 2 floor-gated skips)
+npm run torture             # all 17 scenarios (15 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
 ```
 
-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`.
+Seventeen 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 `localto-torture` gate (zero-alloc `@localTo` read/write storm at `maxMajor 0`, the ABA-stale write/reset interleave asserted AS the shipped contract, pooled park/reinit box+seen reset, tracking-edge and pure-compute-read pins), 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: 15 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)
 
@@ -546,7 +570,7 @@ The cross-framework numbers behind this table are stamped in [`decisions/0006-ki
 - **Not a deep/proxy observation layer.** No `observable.deep`, no wrapped Arrays/Maps/Sets, no proxy magic -- the reactive unit is a declared member, not a traversed object graph. Collections are `@zakkster/lite-project` territory.
 - **Not a per-frame action system.** `@batched` costs a measured thunk per call -- fine for "one call per user intent", wrong inside a render loop. Per-frame hot lanes stay on plain accessor writes (and frame *scheduling* belongs to `lite-raf`).
 - **Not a framework, renderer, or component model.** It ends at the reactive view-model; DOM binding is `lite-signal-dom`'s job.
-- **Not a general meta-programming kit.** Five decorators, one wiring law -- not an open decorator toolbox. It does one thing: turn a class into a reactive view-model with a provable lifetime.
+- **Not a general meta-programming kit.** Six decorators, one wiring law -- not an open decorator toolbox. It does one thing: turn a class into a reactive view-model with a provable lifetime.
 - **Not a MobX API shim.** No `makeObservable`, no administration objects -- and no GC-based cleanup: disposal is explicit, deterministic, and verified, because "the collector will get it eventually" is not a lifecycle.
 - **Not a legacy-decorators consumer.** TypeScript `experimentalDecorators` emit is detected by call shape at decoration time and rejected with a named error -- never "works differently under legacy".
 - **Not usable as `@` syntax without a toolchain** -- that is exactly what `defineReactive` exists for.
@@ -566,7 +590,7 @@ The cross-framework numbers behind this table are stamped in [`decisions/0006-ki
 
 ### The cookbook
 
-[`COOKBOOK.md`](https://github.com/PeshoVurtoleta/lite-signal-decorators/blob/main/COOKBOOK.md) collects eighteen composition recipes over the frozen 18-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).
+[`COOKBOOK.md`](https://github.com/PeshoVurtoleta/lite-signal-decorators/blob/main/COOKBOOK.md) collects eighteen composition recipes over the frozen 19-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).
 
 ---
 

package/SignalDecorators.d.ts

@@ -1,5 +1,5 @@
 /**
- * @zakkster/lite-signal-decorators -- Stage-3 decorator layer over
+ * @zakkster/lite-signal-decorators -- Standard-decorators layer over
  * @zakkster/lite-signal.
  *
  * Public type surface for the JavaScript implementation in
@@ -30,6 +30,16 @@ export interface DerivedOptions<V> {
     equals?: (a: V, b: V) => boolean;
 }
 
+/** Options for a `@localTo` member. `equals` governs the UPSTREAM compare only. */
+export interface LocalToOptions<V> {
+    /**
+     * Custom equality predicate for the UPSTREAM compare (source vs the last-seen
+     * value). A coarse predicate widens how long a local override survives an
+     * upstream move. Default: `Object.is`. The write path never compares.
+     */
+    equals?: (a: V, b: V) => boolean;
+}
+
 /** Options for a `@reactiveEffect` method. */
 export interface ReactiveEffectOptions {
     /** Optional scheduler forwarded straight to the underlying `effect(fn, { scheduler })`. */
@@ -101,6 +111,37 @@ export function derived<V>(
     ctx: ClassGetterDecoratorContext<This, V>,
 ) => (this: This) => V;
 
+// --- localTo ------------------------------------------------------------------
+
+/**
+ * `@localTo(source) accessor x = v` -- upstream-keyed resettable local state.
+ * Each read compares the tracked `source(self)` against a per-instance last-seen
+ * slot: an unchanged upstream yields the local override, a changed upstream
+ * resets to the upstream value (no write on read -- pure). A write always
+ * overrides. With an initializer the member STARTS there and resets on the first
+ * upstream move (the `@trackedReset` flavor); without one it FOLLOWS upstream
+ * from wiring (the `@localCopy` flavor). `source` is REQUIRED. `equals` governs
+ * the upstream compare only.
+ *
+ * The ABA contract (shipped, documented): the reset requires the upstream to
+ * change relative to the last adoption, not to have merely moved -- upstream
+ * A -> local write X -> upstream B -> upstream back to an equals-A value shows
+ * the STALE local X.
+ *
+ * @example
+ * class Editor {
+ *   `@reactive` accessor saved = "";
+ *   `@localTo`((self) => self.saved) accessor draft = "";
+ * }
+ */
+export function localTo<This, V>(
+    source: (this: This, self: This) => V,
+    options?: LocalToOptions<V>,
+): <T>(
+    target: ClassAccessorDecoratorTarget<T, V>,
+    ctx: ClassAccessorDecoratorContext<T, V>,
+) => ClassAccessorDecoratorResult<T, V>;
+
 // --- reactiveHost -------------------------------------------------------------
 
 /**
@@ -177,6 +218,20 @@ export interface SignalSpec<This = unknown, V = unknown> {
     equals?: (a: V, b: V) => boolean;
 }
 
+/** Local descriptor for a `defineReactive` `locals` map entry (`@localTo` twin). */
+export interface LocalSpec<This = unknown, V = unknown> {
+    /** The tracked upstream read `(self) => value`. REQUIRED. */
+    source: (this: This, self: This) => V;
+    /** Custom equality predicate for the upstream compare. Default: `Object.is`. */
+    equals?: (a: V, b: V) => boolean;
+    /**
+     * The initial value. Present -> the member starts here and resets to upstream
+     * on the first upstream move (`@trackedReset`). Absent -> the member follows
+     * upstream from wiring (`@localCopy`).
+     */
+    initial?: V;
+}
+
 /** Derived descriptor for a `defineReactive` `deriveds` map entry. */
 export interface DerivedSpec<This = unknown, V = unknown> {
     /** The compute body `(self) => value`. */
@@ -204,6 +259,8 @@ export interface DefineReactiveSpec<This = any> {
      * throw (ambiguous -- use `{ initial: fn }` or `{ init: (self) => value }`).
      */
     signals?: PropertyKey[] | Record<PropertyKey, unknown | SignalSpec<This>>;
+    /** Upstream-keyed locals (`@localTo` twin): a map of `key -> LocalSpec`. */
+    locals?: Record<PropertyKey, LocalSpec<This>>;
     /** Lazy deriveds: a map of `key -> (self) => value | DerivedSpec`. */
     deriveds?: Record<PropertyKey, ((this: This, self: This) => unknown) | DerivedSpec<This>>;
     /** Auto-effects: a map of `key -> (self) => void | EffectSpec`. */
@@ -289,12 +346,14 @@ export function rootOf(vm: object): NodeDescriptor;
 
 /** The measured per-instance cost of a reactive class, returned by {@link costOf}. */
 export interface ReactiveCost {
-    /** Total nodes = `signals + deriveds + effects + 1` (the anchor). */
+    /** Total nodes = `signals + locals + deriveds + effects + 1` (the anchor). */
     nodes: number;
     /** Dependency links held after every `@derived` has been read once (0007). */
     links: number;
     /** Count of `@reactive` members. */
     signals: number;
+    /** Count of `@localTo` members (each one box node; its seen slot is a plain field). */
+    locals: number;
     /** Count of `@derived` members. */
     deriveds: number;
     /** Count of `@reactiveEffect` members. */

package/SignalDecorators.js

@@ -1,5 +1,5 @@
 /**
- * @zakkster/lite-signal-decorators v1.1.1
+ * @zakkster/lite-signal-decorators v1.2.0
  * --------------------
  * Standard-decorators layer over @zakkster/lite-signal. Turns a plain class into
  * a reactive view-model with measured per-instance cost and deterministic
@@ -96,6 +96,13 @@ const CLOSURES = Symbol("lite-signal-decorators.closures");
 // wins. Keyed by the frozen signal rec (bounded by the class member count).
 const SIG_INITIAL = new WeakMap();
 
+// S8/PD-58: decorator-local field-initial for reinit reset. A @localTo member's
+// field-initializer value is captured (per member, first-seen) in makeLocalInit --
+// undefined means "no initializer" (the @localCopy flavor: reinit reseeds the box
+// from the current upstream). Buildless locals carry hasInitial + initFn on the
+// rec instead. Keyed by the frozen local rec (bounded by the class member count).
+const LOCAL_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
@@ -139,6 +146,7 @@ let AUDIT_FR = null;
 
 // Known option keys per decorator (unknown-key did-you-mean sets, PD-8/PD-11).
 const KNOWN_OPTION_KEYS = ["equals"];
+const LOCAL_OPTION_KEYS = ["equals"];
 const EFFECT_OPTION_KEYS = ["scheduler"];
 const HOST_OPTION_KEYS = ["registry"];
 const CAP_OPTION_KEYS = ["headroom"];
@@ -285,6 +293,12 @@ function throwBadScheduler(what) {
     );
 }
 
+function throwLocalSource() {
+    throw new TypeError(
+        `${ERR}localTo requires a source function: write \`@localTo((self) => self.upstream) accessor x = ...\`. \`source\` is a tracked (self) -> value read, not an option.`,
+    );
+}
+
 function throwUnknownOption(what, key, known) {
     const near = nearestKey(String(key), known);
     throw new TypeError(
@@ -423,9 +437,10 @@ function throwReinitInitials(ctorName) {
 function throwReinitInitialsKey(ctorName, key, plan) {
     const avail = [];
     for (let i = 0; i < plan.signals.length; i++) avail.push(keyLabel(plan.signals[i].key));
+    for (let i = 0; i < plan.locals.length; i++) avail.push(keyLabel(plan.locals[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(", ")}.`,
+        `${ERR}reinitReactive(${ctorName}) initials carries key \`${keyLabel(key)}\` that is not a @reactive signal or @localTo member${near ? ` -- did you mean \`${near}\`?` : ""} Resettable keys: ${avail.join(", ")}.`,
     );
 }
 
@@ -451,9 +466,9 @@ function throwDefineSpec() {
 }
 
 function throwUnknownSection(key) {
-    const near = nearestKey(keyLabel(key), ["signals", "deriveds", "effects", "host"]);
+    const near = nearestKey(keyLabel(key), ["signals", "locals", "deriveds", "effects", "host"]);
     throw new TypeError(
-        `${ERR}defineReactive spec got unknown section \`${keyLabel(key)}\`${near ? ` -- did you mean \`${near}\`?` : ""} Known sections: signals, deriveds, effects, host.`,
+        `${ERR}defineReactive spec got unknown section \`${keyLabel(key)}\`${near ? ` -- did you mean \`${near}\`?` : ""} Known sections: signals, locals, deriveds, effects, host.`,
     );
 }
 
@@ -538,6 +553,25 @@ function throwBadEffect(key) {
     );
 }
 
+function throwSpecLocals() {
+    throw new TypeError(
+        `${ERR}defineReactive spec.locals must be a map of key -> { source, equals?, initial? }.`,
+    );
+}
+
+function throwUnknownLocalDescKey(key, dk) {
+    const near = nearestKey(keyLabel(dk), ["source", "equals", "initial"]);
+    throw new TypeError(
+        `${ERR}defineReactive local ${keyLabel(key)} got unknown descriptor key \`${keyLabel(dk)}\`${near ? ` -- did you mean \`${near}\`?` : ""} Known keys: source, equals, initial.`,
+    );
+}
+
+function throwLocalSourceNotFn(key) {
+    throw new TypeError(
+        `${ERR}defineReactive local ${keyLabel(key)} \`source\` must be a function (self) -> value.`,
+    );
+}
+
 function throwSpecCollision(className, key) {
     throw new TypeError(
         `${ERR}defineReactive spec declares ${keyLabel(key)}, but ${className}.prototype already owns that member -- a spec-declared member cannot collide with a hand-written one.`,
@@ -550,6 +584,49 @@ function makeGet(slot) { return function () { return this[slot].get(); }; }
 function makeSet(slot) { return function (v) { this[slot].set(v); }; }
 function makeDerivedGet(slot) { return function () { return this[slot].get(); }; }
 
+// S8 hot bodies (0014): the @localTo accessor pair. NEW bodies -- the 1.0.0 canon
+// above stays byte-identical (S8-A5); @localTo pays its own measured cost. Both
+// are prebuilt ONCE per member and close over the member's slots + source + equals,
+// so a read/write allocates nothing (the same prebuilt-closure discipline as
+// makeGet/makeSet). Two per-instance stores back a local: the box slot (a signal
+// node, the local value) and the seen slot (a PLAIN field, the last-adopted
+// upstream value). makeLocalGet is PURE (0014 read law): it calls the tracked
+// source, equals-compares it against the seen slot, and returns the local box on
+// an UNCHANGED upstream, else the upstream value -- never writing any box on the
+// read path, so a localTo read is legal inside any @derived compute.
+function makeLocalGet(rec) {
+    const source = rec.source;
+    const eq = rec.eq;
+    const boxSlot = rec.slot;
+    const seenSlot = rec.seenSlot;
+    return function () {
+        const up = source.call(this, this);
+        if (eq(up, this[seenSlot])) return this[boxSlot].get();
+        return up;
+    };
+}
+// makeLocalSet: box.set (a write always overrides -- PD-56 never compares) + seen
+// slot = upstream-at-write. The seen capture must NOT subscribe: a write inside an
+// effect body runs under that effect's tracking scope, so a tracked source read
+// there would silently link the effect to the upstream (a fail-open dep leak,
+// measured: reg.isTracking() -> a bare source read re-fires the effect on an
+// upstream move). The isTracking() gate untracks ONLY under an active scope --
+// the same idiom makeEffectPublic uses (D-4b) -- so the plain-code write path
+// (the hot path) stays a zero-alloc source.call, and only the rare in-effect write
+// pays the untrack thunk. reg comes from the frozen rec.plan (set at claimPlan).
+function makeLocalSet(rec) {
+    const source = rec.source;
+    const boxSlot = rec.slot;
+    const seenSlot = rec.seenSlot;
+    return function (v) {
+        this[boxSlot].set(v);
+        const reg = rec.plan.reg;
+        this[seenSlot] = reg.isTracking()
+            ? reg.untrack(() => source.call(this, this))
+            : source.call(this, this);
+    };
+}
+
 function makeInit(rec) {
     return function (v) {
         if (rec.plan === null) throwMissingHost(rec);
@@ -563,6 +640,69 @@ function makeInit(rec) {
     };
 }
 
+// S8 (cold): seed one @localTo member's two stores on an instance. seen = the
+// source read at wiring, UNTRACKED (wiring/reinit must register no dependency);
+// the box starts at the declared initial when present, else at that same upstream
+// value (the initial-value unification rule, 0014: an initializer -> @trackedReset
+// flavor; no initializer -> @localCopy flavor). Returns the box for SCRATCH
+// rollback. Shared by the decorator init, the buildless wire loop, and reinit.
+function seedLocal(inst, rec, reg, hasInitial, initialValue) {
+    const source = rec.source;
+    const seen = reg.isTracking()
+        ? reg.untrack(() => source.call(inst, inst))
+        : source.call(inst, inst);
+    // The box is created WITHOUT the equals opts: {equals} governs the UPSTREAM
+    // compare only (PD-56); the box uses default equals so a local write always
+    // propagates (a write overrides, never suppresses).
+    const box = reg.signalBox(hasInitial ? initialValue : seen);
+    inst[rec.slot] = box;
+    inst[rec.seenSlot] = seen;
+    return box;
+}
+
+// S8 (cold): the frozen local rec, shared by the decorator (@localTo) and buildless
+// (spec.locals) paths. eq defaults to Object.is (0014 read law). initFn is null for
+// the decorator path (the box is born at field-init time, like a decorator signal)
+// and a per-instance factory for the buildless path (born in wireInstance).
+function makeLocalRec(key, slot, seenSlot, source, opts, initFn, hasInitial) {
+    const eq = opts !== undefined && opts.equals !== undefined ? opts.equals : Object.is;
+    const rec = {
+        kind: "local",
+        key,
+        slot,
+        seenSlot,
+        source,
+        eq,
+        opts,
+        get: null,
+        set: null,
+        fn: null,
+        plan: null,
+        poison: null,
+        prewired: null,
+        parked: null,
+        initFn,
+        hasInitial,
+    };
+    rec.get = makeLocalGet(rec);
+    rec.set = makeLocalSet(rec);
+    return rec;
+}
+
+// S8 (cold): the decorator @localTo init -- mirrors makeInit. The box + seen are
+// born during super()'s field initialization; the box joins the SCRATCH frame for
+// init-phase rollback. The field-initial value is captured per member (undefined
+// means "no initializer" -> the @localCopy reset flavor) for reinit.
+function makeLocalInit(rec) {
+    return function (v) {
+        if (rec.plan === null) throwMissingHost(rec);
+        const box = seedLocal(this, rec, rec.plan.reg, v !== undefined, v);
+        SCRATCH.push(box);                     // D-2h: track for init-phase rollback
+        if (!LOCAL_INITIAL.has(rec)) LOCAL_INITIAL.set(rec, v);
+        return v;                              // emitter backing store, unused
+    };
+}
+
 // --- Option validation (cold) -------------------------------------------------
 
 function isStandardContext(c) {
@@ -583,6 +723,21 @@ function validateOptions(what, opts) {
     return Object.freeze({ equals: opts.equals });
 }
 
+function validateLocalOptions(opts) {
+    // localTo's OWN key set (equals only) -- NOT the shared reactive/derived
+    // validator: admitting `source` there would silently accept @derived({source})
+    // (fail-open, PLAN-S8 spelling call). Returns a frozen { equals } or undefined.
+    if (opts === undefined || opts === null) return undefined;
+    if (typeof opts !== "object") throwUsage("localTo");
+    const keys = Object.keys(opts);
+    for (let i = 0; i < keys.length; i++) {
+        if (keys[i] !== "equals") throwUnknownOption("localTo", keys[i], LOCAL_OPTION_KEYS);
+    }
+    if ("equals" in opts && opts.equals !== undefined && typeof opts.equals !== "function") throwBadEquals("localTo");
+    if (opts.equals === undefined) return undefined;
+    return Object.freeze({ equals: opts.equals });
+}
+
 function validateEffectOptions(opts) {
     // Returns a frozen { scheduler } copy, or undefined for the bare form.
     if (opts === undefined || opts === null) return undefined;
@@ -668,6 +823,36 @@ export function reactive(target, ctx) {
     return function (t, c) { return applyReactive(t, c, opts); };
 }
 
+// --- localTo (S8, 0014) -------------------------------------------------------
+
+function applyLocalTo(target, ctx, source, opts) {
+    if (!isStandardContext(ctx)) throwLegacyEmit("localTo");
+    if (ctx.kind !== "accessor") {
+        throwWrongKind("localTo", "accessor", ctx.kind, "write `@localTo(source) accessor x = ...`.");
+    }
+    if (ctx.static === true) throwStatic("localTo", ctx.name);
+    if (ctx.private === true) throwPrivate("localTo", ctx.name);
+    const nm = typeof ctx.name === "symbol" ? "local" : "local:" + String(ctx.name);
+    const rec = makeLocalRec(ctx.name, Symbol(nm), Symbol(nm + ":seen"), source, opts, null, false);
+    PENDING.push(rec);
+    return { get: rec.get, set: rec.set, init: makeLocalInit(rec) };
+}
+
+/**
+ * `@localTo(source) accessor x = v` -- upstream-keyed resettable local state
+ * (0014). Reads compare the tracked `source(self)` against a per-instance
+ * last-seen slot: an unchanged upstream yields the local override, a changed
+ * upstream resets to it. A write always overrides. With an initializer the member
+ * STARTS there and resets on the first upstream move; without one it FOLLOWS
+ * upstream from wiring. `@localTo(source)` or `@localTo(source, { equals })` --
+ * `equals` governs the upstream compare ONLY. `source` is REQUIRED.
+ */
+export function localTo(source, options) {
+    if (typeof source !== "function") throwLocalSource();
+    const opts = validateLocalOptions(options);
+    return function (t, c) { return applyLocalTo(t, c, source, opts); };
+}
+
 // --- derived ------------------------------------------------------------------
 
 function applyDerived(value, ctx, opts) {
@@ -834,7 +1019,7 @@ function buildHandles(rec, ctorName) {
         get() { throw new ReactiveDisposedError(ctorName, key); },
         set(v) { throw new ReactiveDisposedError(ctorName, key); },
     });
-    const msg = rec.kind === "signal"
+    const msg = rec.kind === "signal" || rec.kind === "local"
         ? `${ERR}${ctorName}.${keyLabel(key)} read/write before its initializer ran (declaration order).`
         : `${ERR}${ctorName}.${keyLabel(key)} read before construction completed (deriveds are available after wiring).`;
     rec.prewired = Object.freeze({
@@ -882,6 +1067,7 @@ function claimPlan(C, ctorName, registry) {
     }
 
     const signals = [];
+    const locals = [];
     const deriveds = [];
     const effects = [];
     const byKey = new Map();
@@ -891,6 +1077,12 @@ function claimPlan(C, ctorName, registry) {
             signals.push(r);
             byKey.set(r.key, r);
         }
+        // PD-55: locals live in their OWN array; L is a first-class accounting term.
+        for (let i = 0; i < ancestor.locals.length; i++) {
+            const r = ancestor.locals[i];
+            locals.push(r);
+            byKey.set(r.key, r);
+        }
         for (let i = 0; i < ancestor.deriveds.length; i++) {
             const r = ancestor.deriveds[i];
             deriveds.push(r);
@@ -920,7 +1112,7 @@ function claimPlan(C, ctorName, registry) {
         const rec = own[i];
         const desc = Object.getOwnPropertyDescriptor(proto, rec.key);
         let installed;
-        if (rec.kind === "signal" || rec.kind === "derived") {
+        if (rec.kind === "signal" || rec.kind === "derived" || rec.kind === "local") {
             installed = desc !== undefined && desc.get === rec.get;
         } else {
             installed = desc !== undefined && desc.value === rec.pub;
@@ -931,8 +1123,9 @@ function claimPlan(C, ctorName, registry) {
 
     for (let i = 0; i < own.length; i++) {
         const rec = own[i];
-        if (rec.kind === "signal" || rec.kind === "derived") buildHandles(rec, ctorName);
+        if (rec.kind === "signal" || rec.kind === "derived" || rec.kind === "local") buildHandles(rec, ctorName);
         if (rec.kind === "signal") signals.push(rec);
+        else if (rec.kind === "local") locals.push(rec);
         else if (rec.kind === "derived") deriveds.push(rec);
         else if (rec.kind === "effect") effects.push(rec);
         // batched recs join byKey only (no node) for reg resolution + diagnostics.
@@ -943,6 +1136,7 @@ function claimPlan(C, ctorName, registry) {
         ctorName,
         reg,
         signals: Object.freeze(signals),
+        locals: Object.freeze(locals),
         deriveds: Object.freeze(deriveds),
         effects: Object.freeze(effects),
         byKey,
@@ -1041,6 +1235,13 @@ function wireInstance(inst, plan) {
             const r = sigs[i];
             if (r.initFn !== null) inst[r.slot] = reg.signalBox(r.initFn(inst), r.opts);
         }
+        // Buildless locals: seed box + seen in spec order BEFORE the anchor.
+        // Decorator locals already exist from field-init time (initFn === null).
+        const locs = plan.locals;
+        for (let i = 0; i < locs.length; i++) {
+            const r = locs[i];
+            if (r.initFn !== null) seedLocal(inst, r, reg, r.hasInitial, r.initFn(inst));
+        }
         let a;
         reg.createRoot(() => { reg.effect(() => { a = reg.getOwner(); }); });   // R-A anchor
         inst[ANCHOR] = a;
@@ -1090,6 +1291,16 @@ function disposeCore(inst, plan) {             // assumes not already disposed
         if (box !== undefined && box[NONLIVE] === undefined) reg.dispose(box);
         inst[r.slot] = r.poison;
     }
+    // S8: locals dispose exactly like signals -- dispose the box, poison the box
+    // slot (a touch throws the named ReactiveDisposedError, 0014 dispose lattice).
+    // The seen slot is a plain field; it is left as-is (the poisoned box guards it).
+    const locs = plan.locals;
+    for (let i = 0; i < locs.length; i++) {
+        const r = locs[i];
+        const box = inst[r.slot];
+        if (box !== undefined && box[NONLIVE] === undefined) reg.dispose(box);
+        inst[r.slot] = r.poison;
+    }
     const ders = plan.deriveds;
     for (let i = 0; i < ders.length; i++) {
         const r = ders[i];
@@ -1120,6 +1331,17 @@ function applyReactiveHost(C, ctx, registry) {
             enumerable: false,
         });
     }
+    // S8: a local's box slot gets the same prewired guard (the seen slot is a
+    // plain field, undefined until init -- no proto guard needed).
+    for (let i = 0; i < plan.locals.length; i++) {
+        const r = plan.locals[i];
+        Object.defineProperty(C.prototype, r.slot, {
+            value: r.prewired,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
     for (let i = 0; i < plan.deriveds.length; i++) {
         const r = plan.deriveds[i];
         Object.defineProperty(C.prototype, r.slot, {
@@ -1261,6 +1483,38 @@ function normalizeSignals(spec, recs) {
     }
 }
 
+// S8/PD-57: the buildless `locals` section -- { key: { source, equals?, initial? } }.
+// Fail closed on a missing/non-fn source (a local without a source is meaningless).
+// An `initial` present selects the @trackedReset flavor; absent, the @localCopy
+// flavor (initFn returns undefined, hasInitial false -> seedLocal reads upstream).
+function normalizeLocalEntry(key, entry) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throwLocalSourceNotFn(key);
+    const dkeys = Reflect.ownKeys(entry);
+    for (let i = 0; i < dkeys.length; i++) {
+        const dk = dkeys[i];
+        if (dk !== "source" && dk !== "equals" && dk !== "initial") throwUnknownLocalDescKey(key, dk);
+    }
+    const source = entry.source;
+    if (typeof source !== "function") throwLocalSourceNotFn(key);
+    const opts = normalizeEquals(entry, `defineReactive local ${keyLabel(key)}`);
+    const hasInitial = Object.prototype.hasOwnProperty.call(entry, "initial");
+    const initial = hasInitial ? entry.initial : undefined;
+    const initFn = function () { return initial; };
+    const slot = Symbol(typeof key === "symbol" ? "local" : "local:" + String(key));
+    const seenSlot = Symbol(typeof key === "symbol" ? "local:seen" : "local:" + String(key) + ":seen");
+    return makeLocalRec(key, slot, seenSlot, source, opts, initFn, hasInitial);
+}
+
+function normalizeLocals(spec, recs) {
+    const l = spec.locals;
+    if (l === undefined) return;
+    if (l === null || typeof l !== "object" || Array.isArray(l)) throwSpecLocals();
+    const keys = Reflect.ownKeys(l);
+    for (let i = 0; i < keys.length; i++) {
+        recs.push(normalizeLocalEntry(keys[i], l[keys[i]]));
+    }
+}
+
 function makeDerivedRec(key, fn, opts) {
     const slot = Symbol(typeof key === "symbol" ? "derived" : "derived:" + String(key));
     return {
@@ -1354,6 +1608,13 @@ function installRec(rec, proto) {
             enumerable: true,
             configurable: true,
         });
+    } else if (rec.kind === "local") {
+        Object.defineProperty(proto, rec.key, {
+            get: rec.get,
+            set: rec.set,
+            enumerable: true,
+            configurable: true,
+        });
     } else if (rec.kind === "derived") {
         Object.defineProperty(proto, rec.key, {
             get: rec.get,
@@ -1382,13 +1643,14 @@ export function defineReactive(Class, spec) {
     const sections = Reflect.ownKeys(spec);
     for (let i = 0; i < sections.length; i++) {
         const k = sections[i];
-        if (k !== "signals" && k !== "deriveds" && k !== "effects" && k !== "host") {
+        if (k !== "signals" && k !== "locals" && k !== "deriveds" && k !== "effects" && k !== "host") {
             throwUnknownSection(k);
         }
     }
 
     const recs = [];
     normalizeSignals(spec, recs);              // signals first (spec/wire order)
+    normalizeLocals(spec, recs);               // locals second (PD-57)
     normalizeDeriveds(spec, recs);
     normalizeEffects(spec, recs);
     const registry = validateHostOptions(spec.host);   // shared PD-11 validation
@@ -1487,6 +1749,16 @@ function releaseCore(inst, plan) {             // assumes a LIVE instance
         if (box !== undefined && box[NONLIVE] === undefined) reg.dispose(box);
         inst[r.slot] = r.parked;
     }
+    // S8: a parked local releases its box node (swap the box slot to the parked
+    // handle) but RETAINS the seen slot as a plain record field (0014 park lattice);
+    // reinit re-creates the box and resets both (PD-58).
+    const locs = plan.locals;
+    for (let i = 0; i < locs.length; i++) {
+        const r = locs[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
@@ -1562,7 +1834,10 @@ export function reinitReactive(vm, initials) {
         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);
+            // PD-58: initials[] accepts @reactive signal keys AND @localTo keys.
+            if (rec === undefined || (rec.kind !== "signal" && rec.kind !== "local")) {
+                throwReinitInitialsKey(plan.ctorName, ikeys[i], plan);
+            }
         }
     }
     const reg = plan.reg;
@@ -1585,6 +1860,30 @@ export function reinitReactive(vm, initials) {
             }
             vm[r.slot] = reg.signalBox(v, r.opts);
         }
+        // PD-58: each local resets its box -> initial AND its seen slot -> the
+        // CURRENT upstream (seedLocal reads source untracked). Precedence mirrors
+        // the signal loop: caller override, then the buildless plan initFn (with its
+        // hasInitial flag), then the decorator field-initial captured in
+        // makeLocalInit (undefined -> the @localCopy flavor: reseed the box from
+        // the current upstream). Locals rebuild BEFORE buildGraph so deriveds/effects
+        // see them on the first synchronous run (D-4a), same as construction.
+        const locs = plan.locals;
+        for (let i = 0; i < locs.length; i++) {
+            const r = locs[i];
+            let hasInitial;
+            let v;
+            if (initials !== undefined && Object.prototype.hasOwnProperty.call(initials, r.key)) {
+                hasInitial = true;
+                v = initials[r.key];
+            } else if (r.initFn !== null) {
+                hasInitial = r.hasInitial;
+                v = r.initFn(vm);
+            } else {
+                v = LOCAL_INITIAL.get(r);
+                hasInitial = v !== undefined;
+            }
+            seedLocal(vm, r, reg, hasInitial, v);
+        }
         buildGraph(vm, plan, closures);
     } catch (e) {
         disposeCore(vm, plan);                 // failed revival is terminal -> DISPOSED
@@ -1656,7 +1955,7 @@ function throwCostInconclusive(name, a, b) {
 
 function throwCostNodeMismatch(name, got, want) {
     throw new Error(
-        `${ERR}costOf(${name}) -- probed node count ${got} != P+D+E+1 (${want}); the bound registry was not quiet during the probe.`,
+        `${ERR}costOf(${name}) -- probed node count ${got} != P+L+D+E+1 (${want}); the bound registry was not quiet during the probe.`,
     );
 }
 
@@ -1688,9 +1987,9 @@ function probeCost(Factory, plan, reg) {
  * Measure the settled per-instance cost of a reactive class on its bound
  * registry: construct, read every `@derived` once (forcing the lazy links),
  * snapshot, dispose, verify the floor -- twice, requiring identical deltas.
- * Returns a frozen `{ nodes, links, signals, deriveds, effects }`; `nodes`
- * equals P+D+E+1. Cached per class. Throws (never guesses) on an inconclusive
- * or polluted probe. Constructs the probe instance with no arguments.
+ * Returns a frozen `{ nodes, links, signals, locals, deriveds, effects }`;
+ * `nodes` equals P+L+D+E+1. Cached per class. Throws (never guesses) on an
+ * inconclusive or polluted probe. Constructs the probe instance with no arguments.
  */
 export function costOf(Factory) {
     if (typeof Factory !== "function") throwCostFactory();
@@ -1709,14 +2008,18 @@ export function costOf(Factory) {
         throwCostInconclusive(plan.ctorName, first, second);
     }
     const sig = plan.signals.length;
+    const loc = plan.locals.length;
     const der = plan.deriveds.length;
     const eff = plan.effects.length;
-    const expected = sig + der + eff + 1;
+    // S8: each @localTo member is exactly 1 box node (its seen slot is a plain
+    // field, 0 nodes), so the node formula is P + L + D + E + 1 (0014 cost law).
+    const expected = sig + loc + der + eff + 1;
     if (first.nodes !== expected) throwCostNodeMismatch(plan.ctorName, first.nodes, expected);
     const result = Object.freeze({
         nodes: first.nodes,
         links: first.links,
         signals: sig,
+        locals: loc,
         deriveds: der,
         effects: eff,
     });
@@ -1820,11 +2123,13 @@ function labelStringsFor(plan) {
     const name = plan.ctorName;
     const sig = [];
     for (let i = 0; i < plan.signals.length; i++) sig.push(`${name}.${keyLabel(plan.signals[i].key)}`);
+    const loc = [];
+    for (let i = 0; i < plan.locals.length; i++) loc.push(`${name}.${keyLabel(plan.locals[i].key)}`);
     const der = [];
     for (let i = 0; i < plan.deriveds.length; i++) der.push(`${name}.${keyLabel(plan.deriveds[i].key)}`);
     const eff = [];
     for (let i = 0; i < plan.effects.length; i++) eff.push(`${name}#${keyLabel(plan.effects[i].key)}`);
-    s = { anchor: `${name}@anchor`, signals: sig, deriveds: der, effects: eff };
+    s = { anchor: `${name}@anchor`, signals: sig, locals: loc, deriveds: der, effects: eff };
     LABEL_STRINGS.set(plan, s);
     return s;
 }
@@ -1844,6 +2149,11 @@ function registerLabels(inst, plan, reg, effHandles) {
         const id = reg.nodeId(inst[sigs[i].slot]);
         if (id !== undefined) { map.set(id, strings.signals[i]); ids.push(id); }
     }
+    const locs = plan.locals;
+    for (let i = 0; i < locs.length; i++) {
+        const id = reg.nodeId(inst[locs[i].slot]);
+        if (id !== undefined) { map.set(id, strings.locals[i]); ids.push(id); }
+    }
     const ders = plan.deriveds;
     for (let i = 0; i < ders.length; i++) {
         const id = reg.nodeId(inst[ders[i].slot]);
@@ -1944,4 +2254,4 @@ export function auditReactive(on) {
 // --- Version ------------------------------------------------------------------
 
 /** Package version. Kept in lockstep with package.json and llms.txt. */
-export const VERSION = "1.1.1";
+export const VERSION = "1.2.0";

package/llms.txt

@@ -1,6 +1,6 @@
 # @zakkster/lite-signal-decorators
 
-VERSION 1.1.1
+VERSION 1.2.0
 
 > Standard-decorators layer over @zakkster/lite-signal, built on the TC39
 > decorators proposal (Stage 2.7 since 2026-05; TS 5.x / Babel 2023-11 emit
@@ -22,12 +22,34 @@ 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 (18)
+## Exports (19)
 
 - `reactive` -- `@reactive accessor x = v` (bare) or `@reactive({ equals })`
   (factory). Declares a per-instance signal.
 - `derived` -- `@derived get y()` (bare) or `@derived({ equals })` (factory).
   Declares a lazy computed derived from other reactive members.
+- `localTo` -- `@localTo(source) accessor x = v` or
+  `@localTo(source, { equals? })`. Upstream-keyed resettable local state
+  (decisions/0014). `source` is a REQUIRED tracked `(self) => value` fn, called
+  inline in the read body (no extra node, PD-54). The read is PURE (never writes
+  a box): it calls `source`, compares the value to a per-instance last-seen slot
+  via `equals` (default `Object.is`), and returns the local box `.get()` when
+  upstream is unchanged, else the upstream value (a changed upstream resets to
+  it). A write always overrides -- the write path never compares (PD-56).
+  Initial-value unification (0014): with an initializer the member STARTS at that
+  value and resets on the first upstream move (@trackedReset flavor); with NO
+  initializer the initial is the source evaluated once at wiring and the member
+  FOLLOWS upstream from the first read (@localCopy flavor) -- one decorator, both
+  semantics, selected by the natural syntax. `equals` governs the UPSTREAM
+  compare ONLY. A throwing source propagates from the read, mutating nothing
+  (fail closed). ABA contract (shipped, honest, never softened): no public epoch
+  exists (NodeDescriptor is {id, kind, value}), so the compare is VALUE-based --
+  upstream A -> local write X -> upstream B -> upstream back to an equals-A value
+  -> the read shows the STALE LOCAL X (the reset needs upstream to change
+  relative to the last adoption, not to have moved transitively). tracked-toolbox
+  @localCopy has the same property. Storage per member: ONE signal box + ONE
+  plain per-instance seen-slot (never reactive); cost delta +1 node, +0 for the
+  slot -- the per-instance formula becomes P+L+D+E+1.
 - `reactiveEffect` -- `@reactiveEffect m()` (bare) or
   `@reactiveEffect({ scheduler })` (factory). A method that auto-runs as an
   effect once the instance is wired. The auto-effect tracks; the public method is
@@ -45,7 +67,7 @@ slot for a poison handle, so any later read/write throws a named
   (factory). The single wiring site; wraps the class. A `registry` isolates the
   whole host chain (see the registry law).
 - `defineReactive(Class, spec) -> Class'` -- the buildless twin. `spec` is
-  `{ signals, deriveds, effects, host }`; it installs the members on
+  `{ signals, deriveds, locals, effects, host }`; it installs the members on
   `Class.prototype` and wraps the class through the same host step. See the
   buildless contract.
 - `disposeReactive(vm) -> boolean` -- cascade + poison teardown. Idempotent: a
@@ -70,7 +92,7 @@ slot for a poison handle, so any later read/write throws a named
 - `costOf(Factory) -> { nodes, links, signals, deriveds, effects }` -- the
   measured settled per-instance cost on the class's bound registry (frozen,
   cached). Double-probed: an inconclusive or polluted probe throws, never
-  guesses. `nodes` = P+D+E+1; `links` = the first-full-read link count. See
+  guesses. `nodes` = P+L+D+E+1; `links` = the first-full-read link count. See
   "Introspection & audit".
 - `capacityFor(inventory, { headroom }?) -> RegistryConfig` -- size a
   `createRegistry` config from `[Factory, count]` pairs. Nodes exact, links x
@@ -82,7 +104,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.1.1"`.
+- `VERSION` -- `"1.2.0"`.
 
 ## Registry law (one registry per host chain)
 
@@ -136,6 +158,12 @@ spec normalizes (fail closed; `Reflect.ownKeys`, so symbol keys work):
   throw (ambiguous -- wrap it in `{ initial: fn }` or `{ init }`).
 - `deriveds`: a map `{ key: (self) => value | { get, equals } }`.
 - `effects`: a MAP ONLY `{ key: (self) => void | { run, scheduler } }`.
+- `locals`: a MAP ONLY `{ key: { source, equals?, initial? } }` -- the buildless
+  twin of `@localTo` (PD-57). `source` is REQUIRED and must be a `(self) => value`
+  function (a missing or non-function source is a named throw, fail closed);
+  `equals` governs the upstream compare only; `initial` (verbatim, when present)
+  selects the @trackedReset flavor, its absence the @localCopy flavor. Same
+  read/write laws and ABA contract as the decorator.
 - `host`: `{ registry }` or omitted -- the same validation as `@reactiveHost`.
 
 Spec-declared members that collide with an own property of `Class.prototype` are
@@ -153,7 +181,7 @@ probe on its bound registry: construct, read every `@derived` once (forcing the
 lazy links), snapshot, dispose, verify the floor -- run TWICE, requiring
 identical deltas. An inconclusive probe (a data-dependent derived read, or a
 registry mutated mid-probe) or a floor-verify failure THROWS a named error;
-costOf never returns a guess. `nodes` equals P+D+E+1 (the R-A law); `links` is
+costOf never returns a guess. `nodes` equals P+L+D+E+1 (the R-A law); `links` is
 the first-full-read count. The result is frozen and cached per class. costOf
 constructs the probe instance with NO constructor arguments.
 
@@ -214,7 +242,10 @@ runtime requirement -- the shipped surface runs on 1.5.0.
 `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
+0.3.0). 1.2.0 adds `localTo` (decisions/0013 strategic track, 0014 contract) as
+an additive MINOR -> 19 exports; the 1.0.0 canon (`makeGet`/`makeSet`/
+`makeDerivedGet`) stays byte-identical -- @localTo ships its own accessor bodies
+and pays its own measured cost. 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zakkster/lite-signal-decorators",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Standard-decorators layer over @zakkster/lite-signal (TC39 decorators proposal, Stage 2.7 since 2026-05; TS 5.x / Babel 2023-11 emit unchanged). 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",