footprintjs 9.23.2 → 9.24.0

package/dist/esm/lib/reactive/handles.d.ts

@@ -0,0 +1,46 @@
+/**
+ * reactive/handles — which objects are the scope's HANDLES, and the value
+ * behind each.
+ *
+ * Every object the typed scope hands back is a Proxy bound to its stage
+ * (reactive/README.md, "A handle is bound to its stage"): inside the stage
+ * that is what makes a deep write commit and a held read stay live. A handle
+ * can also TRAVEL out of the stage in the library's own hands — an
+ * `addParallelForEach` items selector returns the array handle and its
+ * elements become the generated branch inputs; a subflow `inputMapper` or
+ * `outputMapper` hands one on; `$setValue('copy', scope.customer)` hands one
+ * back. Wherever the engine RECORDS a value it clones it (`structuredClone`,
+ * at commit since 9.23.0), and a Proxy cannot be cloned: `DataCloneError`,
+ * the stage's writes lost. 9.22.0–9.23.2 lost every child of a fan-out over
+ * object items that way (9.23.3).
+ *
+ * LAW: a handle the scope handed out is a value the engine accepts back.
+ * Each proxy factory registers its handle here with the same live reader its
+ * get trap uses, so the value behind a handle is what a read of it would
+ * return NOW — and the engine asks {@link unwrapHandles} at every boundary
+ * where app code hands it a value to record. O(1) for a handle (a WeakMap
+ * lookup, no walk, no JSON round-trip: a `Date` stays a `Date`); a walk only
+ * for a plain container the app built around handles, copy-on-write so a
+ * handle-free value comes back as the SAME reference.
+ *
+ * The value behind a handle is BORROWED — the same reference a read hands
+ * back, cloned by the buffer at commit. Never mutate it (the reads law).
+ */
+/** Register `handle` as a scope handle whose current value `live` returns. Returns the handle. */
+export declare function rememberHandle<T extends object>(handle: T, live: () => unknown): T;
+/** Is `value` a handle the scope handed out? */
+export declare function isHandle(value: unknown): value is object;
+/** The live value behind a handle; `value` itself when it is not one. O(1). */
+export declare function valueBehind(value: unknown): unknown;
+/**
+ * `value` with every handle inside it replaced by the value behind it.
+ *
+ * A handle is replaced in O(1) and NOT entered (the state behind it holds no
+ * handles — they are built on read, never stored). A plain container is
+ * walked and copied ONLY when something inside it changed, so a handle-free
+ * value is returned as the same reference and a hand-built `{ item, index }`
+ * around one handle costs one object. Anything else (a `Date`, a `Map`, a
+ * class instance, a primitive) is a leaf. A cycle among plain containers is
+ * left as it is — `structuredClone` handles cycles; only a Proxy stops it.
+ */
+export declare function unwrapHandles<T>(value: T): T;

package/dist/esm/lib/reactive/handles.js

@@ -0,0 +1,105 @@
+/**
+ * reactive/handles — which objects are the scope's HANDLES, and the value
+ * behind each.
+ *
+ * Every object the typed scope hands back is a Proxy bound to its stage
+ * (reactive/README.md, "A handle is bound to its stage"): inside the stage
+ * that is what makes a deep write commit and a held read stay live. A handle
+ * can also TRAVEL out of the stage in the library's own hands — an
+ * `addParallelForEach` items selector returns the array handle and its
+ * elements become the generated branch inputs; a subflow `inputMapper` or
+ * `outputMapper` hands one on; `$setValue('copy', scope.customer)` hands one
+ * back. Wherever the engine RECORDS a value it clones it (`structuredClone`,
+ * at commit since 9.23.0), and a Proxy cannot be cloned: `DataCloneError`,
+ * the stage's writes lost. 9.22.0–9.23.2 lost every child of a fan-out over
+ * object items that way (9.23.3).
+ *
+ * LAW: a handle the scope handed out is a value the engine accepts back.
+ * Each proxy factory registers its handle here with the same live reader its
+ * get trap uses, so the value behind a handle is what a read of it would
+ * return NOW — and the engine asks {@link unwrapHandles} at every boundary
+ * where app code hands it a value to record. O(1) for a handle (a WeakMap
+ * lookup, no walk, no JSON round-trip: a `Date` stays a `Date`); a walk only
+ * for a plain container the app built around handles, copy-on-write so a
+ * handle-free value comes back as the SAME reference.
+ *
+ * The value behind a handle is BORROWED — the same reference a read hands
+ * back, cloned by the buffer at commit. Never mutate it (the reads law).
+ */
+/** Every handle the four proxy factories built, mapped to its live reader. */
+const LIVE = new WeakMap();
+/** Register `handle` as a scope handle whose current value `live` returns. Returns the handle. */
+export function rememberHandle(handle, live) {
+    LIVE.set(handle, live);
+    return handle;
+}
+/** Is `value` a handle the scope handed out? */
+export function isHandle(value) {
+    return value !== null && typeof value === 'object' && LIVE.has(value);
+}
+/** The live value behind a handle; `value` itself when it is not one. O(1). */
+export function valueBehind(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    const live = LIVE.get(value);
+    return live === undefined ? value : live();
+}
+/** A plain object or array — the only containers the walk enters (a `Date`, `Map` or class instance is a leaf). */
+function isPlainContainer(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return true;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * `value` with every handle inside it replaced by the value behind it.
+ *
+ * A handle is replaced in O(1) and NOT entered (the state behind it holds no
+ * handles — they are built on read, never stored). A plain container is
+ * walked and copied ONLY when something inside it changed, so a handle-free
+ * value is returned as the same reference and a hand-built `{ item, index }`
+ * around one handle costs one object. Anything else (a `Date`, a `Map`, a
+ * class instance, a primitive) is a leaf. A cycle among plain containers is
+ * left as it is — `structuredClone` handles cycles; only a Proxy stops it.
+ */
+export function unwrapHandles(value) {
+    return walk(value, new Set());
+}
+function walk(value, onPath) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    const live = LIVE.get(value);
+    if (live !== undefined)
+        return live();
+    if (!isPlainContainer(value) || onPath.has(value))
+        return value;
+    onPath.add(value);
+    const out = Array.isArray(value) ? walkArray(value, onPath) : walkObject(value, onPath);
+    onPath.delete(value);
+    return out;
+}
+function walkArray(value, onPath) {
+    let copy;
+    for (let i = 0; i < value.length; i++) {
+        const next = walk(value[i], onPath);
+        if (next === value[i])
+            continue;
+        copy ??= [...value];
+        copy[i] = next;
+    }
+    return copy ?? value;
+}
+function walkObject(value, onPath) {
+    let copy;
+    for (const key of Object.keys(value)) {
+        const next = walk(value[key], onPath);
+        if (next === value[key])
+            continue;
+        copy ??= { ...value };
+        copy[key] = next;
+    }
+    return copy ?? value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handles.js","sourceRoot":"","sources":["../../../../src/lib/reactive/handles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/handles — which objects are the scope's HANDLES, and the value\n * behind each.\n *\n * Every object the typed scope hands back is a Proxy bound to its stage\n * (reactive/README.md, \"A handle is bound to its stage\"): inside the stage\n * that is what makes a deep write commit and a held read stay live. A handle\n * can also TRAVEL out of the stage in the library's own hands — an\n * `addParallelForEach` items selector returns the array handle and its\n * elements become the generated branch inputs; a subflow `inputMapper` or\n * `outputMapper` hands one on; `$setValue('copy', scope.customer)` hands one\n * back. Wherever the engine RECORDS a value it clones it (`structuredClone`,\n * at commit since 9.23.0), and a Proxy cannot be cloned: `DataCloneError`,\n * the stage's writes lost. 9.22.0–9.23.2 lost every child of a fan-out over\n * object items that way (9.23.3).\n *\n * LAW: a handle the scope handed out is a value the engine accepts back.\n * Each proxy factory registers its handle here with the same live reader its\n * get trap uses, so the value behind a handle is what a read of it would\n * return NOW — and the engine asks {@link unwrapHandles} at every boundary\n * where app code hands it a value to record. O(1) for a handle (a WeakMap\n * lookup, no walk, no JSON round-trip: a `Date` stays a `Date`); a walk only\n * for a plain container the app built around handles, copy-on-write so a\n * handle-free value comes back as the SAME reference.\n *\n * The value behind a handle is BORROWED — the same reference a read hands\n * back, cloned by the buffer at commit. Never mutate it (the reads law).\n */\n\n/** Every handle the four proxy factories built, mapped to its live reader. */\nconst LIVE = new WeakMap<object, () => unknown>();\n\n/** Register `handle` as a scope handle whose current value `live` returns. Returns the handle. */\nexport function rememberHandle<T extends object>(handle: T, live: () => unknown): T {\n  LIVE.set(handle, live);\n  return handle;\n}\n\n/** Is `value` a handle the scope handed out? */\nexport function isHandle(value: unknown): value is object {\n  return value !== null && typeof value === 'object' && LIVE.has(value);\n}\n\n/** The live value behind a handle; `value` itself when it is not one. O(1). */\nexport function valueBehind(value: unknown): unknown {\n  if (value === null || typeof value !== 'object') return value;\n  const live = LIVE.get(value);\n  return live === undefined ? value : live();\n}\n\n/** A plain object or array — the only containers the walk enters (a `Date`, `Map` or class instance is a leaf). */\nfunction isPlainContainer(value: unknown): value is Record<string, unknown> | unknown[] {\n  if (value === null || typeof value !== 'object') return false;\n  if (Array.isArray(value)) return true;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n/**\n * `value` with every handle inside it replaced by the value behind it.\n *\n * A handle is replaced in O(1) and NOT entered (the state behind it holds no\n * handles — they are built on read, never stored). A plain container is\n * walked and copied ONLY when something inside it changed, so a handle-free\n * value is returned as the same reference and a hand-built `{ item, index }`\n * around one handle costs one object. Anything else (a `Date`, a `Map`, a\n * class instance, a primitive) is a leaf. A cycle among plain containers is\n * left as it is — `structuredClone` handles cycles; only a Proxy stops it.\n */\nexport function unwrapHandles<T>(value: T): T {\n  return walk(value, new Set()) as T;\n}\n\nfunction walk(value: unknown, onPath: Set<object>): unknown {\n  if (value === null || typeof value !== 'object') return value;\n  const live = LIVE.get(value);\n  if (live !== undefined) return live();\n  if (!isPlainContainer(value) || onPath.has(value)) return value;\n  onPath.add(value);\n  const out = Array.isArray(value) ? walkArray(value, onPath) : walkObject(value, onPath);\n  onPath.delete(value);\n  return out;\n}\n\nfunction walkArray(value: unknown[], onPath: Set<object>): unknown[] {\n  let copy: unknown[] | undefined;\n  for (let i = 0; i < value.length; i++) {\n    const next = walk(value[i], onPath);\n    if (next === value[i]) continue;\n    copy ??= [...value];\n    copy[i] = next;\n  }\n  return copy ?? value;\n}\n\nfunction walkObject(value: Record<string, unknown>, onPath: Set<object>): Record<string, unknown> {\n  let copy: Record<string, unknown> | undefined;\n  for (const key of Object.keys(value)) {\n    const next = walk(value[key], onPath);\n    if (next === value[key]) continue;\n    copy ??= { ...value };\n    copy[key] = next;\n  }\n  return copy ?? value;\n}\n"]}

package/dist/esm/lib/reactive/index.d.ts

@@ -11,4 +11,5 @@ export { BREAK_SETTER, EXECUTOR_INTERNAL_METHODS, IS_TYPED_SCOPE, SCOPE_METHOD_N
 export { createTypedScope } from './createTypedScope.js';
 export { shouldWrapWithProxy } from './allowlist.js';
 export { createArrayProxy } from './arrayTraps.js';
+export { isHandle, unwrapHandles, valueBehind } from './handles.js';
 export { buildNestedPatch, joinPath } from './pathBuilder.js';

package/dist/esm/lib/reactive/index.js

@@ -13,5 +13,6 @@ export { createTypedScope } from './createTypedScope.js';
 // Utilities
 export { shouldWrapWithProxy } from './allowlist.js';
 export { createArrayProxy } from './arrayTraps.js';
+export { isHandle, unwrapHandles, valueBehind } from './handles.js';
 export { buildNestedPatch, joinPath } from './pathBuilder.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlYWN0aXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFLSCxvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLFlBQVksRUFBRSx5QkFBeUIsRUFBRSxjQUFjLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFekcsZUFBZTtBQUNmLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELFlBQVk7QUFDWixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsUUFBUSxFQUFFLE1BQU0sa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIHJlYWN0aXZlLyAtLSBEZWVwIFByb3h5IHN5c3RlbSBmb3IgVHlwZWRTY29wZTxUPi5cbiAqXG4gKiBQcm92aWRlcyB0eXBlZCBwcm9wZXJ0eSBhY2Nlc3MgdG8gZm9vdHByaW50anMgc2NvcGUgc3RhdGU6XG4gKiAgIHNjb3BlLmNyZWRpdFRpZXIgPSAnQScgIGluc3RlYWQgb2YgIHNjb3BlLnNldFZhbHVlKCdjcmVkaXRUaWVyJywgJ0EnKVxuICogICBzY29wZS5jdXN0b21lci5hZGRyZXNzLnppcCA9ICc5MDIxMCcgIGluc3RlYWQgb2YgIHNjb3BlLnVwZGF0ZVZhbHVlKC4uLilcbiAqICAgc2NvcGUudGFncy5wdXNoKCd2aXAnKSAgaW5zdGVhZCBvZiAgc2NvcGUuc2V0VmFsdWUoJ3RhZ3MnLCBbLi4udGFncywgJ3ZpcCddKVxuICovXG5cbi8vIFR5cGVzXG5leHBvcnQgdHlwZSB7IFJlYWN0aXZlT3B0aW9ucywgUmVhY3RpdmVUYXJnZXQsIFNjb3BlTWV0aG9kcywgVHlwZWRTY29wZSB9IGZyb20gJy4vdHlwZXMuanMnO1xuXG4vLyBSdW50aW1lIGNvbnN0YW50c1xuZXhwb3J0IHsgQlJFQUtfU0VUVEVSLCBFWEVDVVRPUl9JTlRFUk5BTF9NRVRIT0RTLCBJU19UWVBFRF9TQ09QRSwgU0NPUEVfTUVUSE9EX05BTUVTIH0gZnJvbSAnLi90eXBlcy5qcyc7XG5cbi8vIENvcmUgZmFjdG9yeVxuZXhwb3J0IHsgY3JlYXRlVHlwZWRTY29wZSB9IGZyb20gJy4vY3JlYXRlVHlwZWRTY29wZS5qcyc7XG5cbi8vIFV0aWxpdGllc1xuZXhwb3J0IHsgc2hvdWxkV3JhcFdpdGhQcm94eSB9IGZyb20gJy4vYWxsb3dsaXN0LmpzJztcbmV4cG9ydCB7IGNyZWF0ZUFycmF5UHJveHkgfSBmcm9tICcuL2FycmF5VHJhcHMuanMnO1xuZXhwb3J0IHsgYnVpbGROZXN0ZWRQYXRjaCwgam9pblBhdGggfSBmcm9tICcuL3BhdGhCdWlsZGVyLmpzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlYWN0aXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFLSCxvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLFlBQVksRUFBRSx5QkFBeUIsRUFBRSxjQUFjLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFekcsZUFBZTtBQUNmLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELFlBQVk7QUFDWixPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxXQUFXLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDcEUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLFFBQVEsRUFBRSxNQUFNLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiByZWFjdGl2ZS8gLS0gRGVlcCBQcm94eSBzeXN0ZW0gZm9yIFR5cGVkU2NvcGU8VD4uXG4gKlxuICogUHJvdmlkZXMgdHlwZWQgcHJvcGVydHkgYWNjZXNzIHRvIGZvb3RwcmludGpzIHNjb3BlIHN0YXRlOlxuICogICBzY29wZS5jcmVkaXRUaWVyID0gJ0EnICBpbnN0ZWFkIG9mICBzY29wZS5zZXRWYWx1ZSgnY3JlZGl0VGllcicsICdBJylcbiAqICAgc2NvcGUuY3VzdG9tZXIuYWRkcmVzcy56aXAgPSAnOTAyMTAnICBpbnN0ZWFkIG9mICBzY29wZS51cGRhdGVWYWx1ZSguLi4pXG4gKiAgIHNjb3BlLnRhZ3MucHVzaCgndmlwJykgIGluc3RlYWQgb2YgIHNjb3BlLnNldFZhbHVlKCd0YWdzJywgWy4uLnRhZ3MsICd2aXAnXSlcbiAqL1xuXG4vLyBUeXBlc1xuZXhwb3J0IHR5cGUgeyBSZWFjdGl2ZU9wdGlvbnMsIFJlYWN0aXZlVGFyZ2V0LCBTY29wZU1ldGhvZHMsIFR5cGVkU2NvcGUgfSBmcm9tICcuL3R5cGVzLmpzJztcblxuLy8gUnVudGltZSBjb25zdGFudHNcbmV4cG9ydCB7IEJSRUFLX1NFVFRFUiwgRVhFQ1VUT1JfSU5URVJOQUxfTUVUSE9EUywgSVNfVFlQRURfU0NPUEUsIFNDT1BFX01FVEhPRF9OQU1FUyB9IGZyb20gJy4vdHlwZXMuanMnO1xuXG4vLyBDb3JlIGZhY3RvcnlcbmV4cG9ydCB7IGNyZWF0ZVR5cGVkU2NvcGUgfSBmcm9tICcuL2NyZWF0ZVR5cGVkU2NvcGUuanMnO1xuXG4vLyBVdGlsaXRpZXNcbmV4cG9ydCB7IHNob3VsZFdyYXBXaXRoUHJveHkgfSBmcm9tICcuL2FsbG93bGlzdC5qcyc7XG5leHBvcnQgeyBjcmVhdGVBcnJheVByb3h5IH0gZnJvbSAnLi9hcnJheVRyYXBzLmpzJztcbmV4cG9ydCB7IGlzSGFuZGxlLCB1bndyYXBIYW5kbGVzLCB2YWx1ZUJlaGluZCB9IGZyb20gJy4vaGFuZGxlcy5qcyc7XG5leHBvcnQgeyBidWlsZE5lc3RlZFBhdGNoLCBqb2luUGF0aCB9IGZyb20gJy4vcGF0aEJ1aWxkZXIuanMnO1xuIl19

package/dist/esm/lib/reactive/structuralWrite.d.ts

@@ -14,21 +14,6 @@
  * already makes. The buffer `structuredClone`s what it stages, so the
  * detaching happens once, at the boundary that needs it.
  */
-/**
- * Strip Proxy wrappers from a value about to be stored.
- *
- * `structuredClone` in TransactionBuffer cannot clone a Proxy, and every deep
- * read of state hands back one — so `scope.backup = scope.customer` would
- * otherwise stage an unclonable value.
- *
- * KNOWN COST (landmine 1): this is a JSON round-trip, so a `Date` becomes a
- * string, a `Map` becomes `{}` and an own `undefined` drops. `$setValue`
- * bypasses it, which is why the two write paths can store different bytes.
- * The round-trip is applied to the ASSIGNED VALUE only — never to the
- * surrounding state, which reaches the buffer by reference and is detached by
- * `structuredClone` (Dates and Maps intact).
- */
-export declare function unwrapProxy(value: unknown): unknown;
 /**
  * Return a copy of `root` with `value` at `segments`, mutating nothing.
  *

package/dist/esm/lib/reactive/structuralWrite.js

@@ -14,34 +14,16 @@
  * already makes. The buffer `structuredClone`s what it stages, so the
  * detaching happens once, at the boundary that needs it.
  */
-/**
- * Strip Proxy wrappers from a value about to be stored.
- *
- * `structuredClone` in TransactionBuffer cannot clone a Proxy, and every deep
- * read of state hands back one — so `scope.backup = scope.customer` would
- * otherwise stage an unclonable value.
- *
- * KNOWN COST (landmine 1): this is a JSON round-trip, so a `Date` becomes a
- * string, a `Map` becomes `{}` and an own `undefined` drops. `$setValue`
- * bypasses it, which is why the two write paths can store different bytes.
- * The round-trip is applied to the ASSIGNED VALUE only — never to the
- * surrounding state, which reaches the buffer by reference and is detached by
- * `structuredClone` (Dates and Maps intact).
+/*
+ * Until 9.24.0 this module also owned `unwrapProxy`, a JSON round-trip of
+ * every ASSIGNED value — the only way then to keep the scope's own Proxies
+ * out of the buffer. It cost a `Date` its type and a `Map` its members, and
+ * it made the trap and `$setValue` store different bytes for the same value
+ * (the old landmine 1). The scope's handles are recognised now
+ * (`handles.ts · unwrapHandles`, O(1) each), so the assigned value goes to
+ * the sink AS ASSIGNED and the buffer's `structuredClone` at commit is the
+ * one detaching step — the same law `$setValue` has always had.
  */
-export function unwrapProxy(value) {
-    if (value === null || value === undefined)
-        return value;
-    if (typeof value !== 'object')
-        return value;
-    try {
-        // JSON round-trip strips Proxies. Safe because state values must be JSON-serializable.
-        return JSON.parse(JSON.stringify(value));
-    }
-    catch {
-        // Non-serializable (functions, symbols, etc.) — return as-is
-        return value;
-    }
-}
 /** Shallow copy that preserves array-ness — the one container copy this module makes. */
 function copyContainer(node) {
     if (Array.isArray(node))
@@ -119,4 +101,4 @@ export function deleteInPath(root, segments) {
         copy[segment] = replaced;
     return copy;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"structuralWrite.js","sourceRoot":"","sources":["../../../../src/lib/reactive/structuralWrite.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/structuralWrite -- Build the NEXT value without touching the last one.\n *\n * Every deep write the typed scope intercepts has the same shape: \"at this\n * path inside the value I read, put this\". The value it read is BORROWED —\n * before a stage's first staged write it is a bare reference into committed\n * shared memory, and committed state is immutable-after-swap (see\n * `StageContext.firstTouchState`). Editing it in place would corrupt every\n * in-flight stage AND leave the commit log with nothing to record.\n *\n * So the write path never mutates. It COPIES the containers along the path\n * (and only those) and returns a new root, leaving every untouched sibling\n * shared by reference — the same zero-clone bargain the first-touch view\n * already makes. The buffer `structuredClone`s what it stages, so the\n * detaching happens once, at the boundary that needs it.\n */\n\n/**\n * Strip Proxy wrappers from a value about to be stored.\n *\n * `structuredClone` in TransactionBuffer cannot clone a Proxy, and every deep\n * read of state hands back one — so `scope.backup = scope.customer` would\n * otherwise stage an unclonable value.\n *\n * KNOWN COST (landmine 1): this is a JSON round-trip, so a `Date` becomes a\n * string, a `Map` becomes `{}` and an own `undefined` drops. `$setValue`\n * bypasses it, which is why the two write paths can store different bytes.\n * The round-trip is applied to the ASSIGNED VALUE only — never to the\n * surrounding state, which reaches the buffer by reference and is detached by\n * `structuredClone` (Dates and Maps intact).\n */\nexport function unwrapProxy(value: unknown): unknown {\n  if (value === null || value === undefined) return value;\n  if (typeof value !== 'object') return value;\n  try {\n    // JSON round-trip strips Proxies. Safe because state values must be JSON-serializable.\n    return JSON.parse(JSON.stringify(value));\n  } catch {\n    // Non-serializable (functions, symbols, etc.) — return as-is\n    return value;\n  }\n}\n\n/** Shallow copy that preserves array-ness — the one container copy this module makes. */\nfunction copyContainer(node: unknown): any {\n  if (Array.isArray(node)) return [...node];\n  if (node !== null && typeof node === 'object') return { ...(node as Record<string, unknown>) };\n  // Not a container (primitive, null, undefined): the path continues INTO it,\n  // so it becomes a fresh object — the same coercion `nativeSet` performs.\n  return {};\n}\n\n/** An array index segment, or `undefined` when the segment names a property. */\nfunction indexOf(node: unknown, segment: string): number | undefined {\n  if (!Array.isArray(node)) return undefined;\n  const i = Number(segment);\n  return Number.isInteger(i) && i >= 0 ? i : undefined;\n}\n\n/**\n * Return a copy of `root` with `value` at `segments`, mutating nothing.\n *\n * Containers on the path are shallow-copied (arrays stay arrays); everything\n * off the path is shared by reference. An empty path returns `value` itself.\n */\nexport function setInPath(root: unknown, segments: readonly string[], value: unknown): unknown {\n  if (segments.length === 0) return value;\n  const next = copyContainer(root);\n  const segment = segments[0];\n  const index = indexOf(next, segment);\n  const child = index !== undefined ? next[index] : (next as Record<string, unknown>)[segment];\n  const replaced = setInPath(child, segments.slice(1), value);\n  if (index !== undefined) next[index] = replaced;\n  else (next as Record<string, unknown>)[segment] = replaced;\n  return next;\n}\n\n/**\n * Return a copy of `root` with the key at `segments` REMOVED, mutating nothing.\n *\n * On an array the slot is removed with `splice` (the array shrinks — `delete`\n * on an array index would leave a hole, which cannot survive\n * `structuredClone` round-trips as the same value). A path that does not\n * exist returns the root unchanged, by reference.\n */\nexport function deleteInPath(root: unknown, segments: readonly string[]): unknown {\n  if (segments.length === 0) return undefined;\n  if (root === null || typeof root !== 'object') return root;\n  const segment = segments[0];\n  const index = indexOf(root, segment);\n  if (segments.length === 1) {\n    if (index !== undefined) {\n      if (index >= (root as unknown[]).length) return root;\n      const copy = [...(root as unknown[])];\n      copy.splice(index, 1);\n      return copy;\n    }\n    if (!Object.prototype.hasOwnProperty.call(root, segment)) return root;\n    const copy = { ...(root as Record<string, unknown>) };\n    delete copy[segment];\n    return copy;\n  }\n  const child = index !== undefined ? (root as unknown[])[index] : (root as Record<string, unknown>)[segment];\n  const replaced = deleteInPath(child, segments.slice(1));\n  if (replaced === child) return root;\n  const copy = copyContainer(root);\n  if (index !== undefined) copy[index] = replaced;\n  else copy[segment] = replaced;\n  return copy;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"structuralWrite.js","sourceRoot":"","sources":["../../../../src/lib/reactive/structuralWrite.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/structuralWrite -- Build the NEXT value without touching the last one.\n *\n * Every deep write the typed scope intercepts has the same shape: \"at this\n * path inside the value I read, put this\". The value it read is BORROWED —\n * before a stage's first staged write it is a bare reference into committed\n * shared memory, and committed state is immutable-after-swap (see\n * `StageContext.firstTouchState`). Editing it in place would corrupt every\n * in-flight stage AND leave the commit log with nothing to record.\n *\n * So the write path never mutates. It COPIES the containers along the path\n * (and only those) and returns a new root, leaving every untouched sibling\n * shared by reference — the same zero-clone bargain the first-touch view\n * already makes. The buffer `structuredClone`s what it stages, so the\n * detaching happens once, at the boundary that needs it.\n */\n\n/*\n * Until 9.24.0 this module also owned `unwrapProxy`, a JSON round-trip of\n * every ASSIGNED value — the only way then to keep the scope's own Proxies\n * out of the buffer. It cost a `Date` its type and a `Map` its members, and\n * it made the trap and `$setValue` store different bytes for the same value\n * (the old landmine 1). The scope's handles are recognised now\n * (`handles.ts · unwrapHandles`, O(1) each), so the assigned value goes to\n * the sink AS ASSIGNED and the buffer's `structuredClone` at commit is the\n * one detaching step — the same law `$setValue` has always had.\n */\n\n/** Shallow copy that preserves array-ness — the one container copy this module makes. */\nfunction copyContainer(node: unknown): any {\n  if (Array.isArray(node)) return [...node];\n  if (node !== null && typeof node === 'object') return { ...(node as Record<string, unknown>) };\n  // Not a container (primitive, null, undefined): the path continues INTO it,\n  // so it becomes a fresh object — the same coercion `nativeSet` performs.\n  return {};\n}\n\n/** An array index segment, or `undefined` when the segment names a property. */\nfunction indexOf(node: unknown, segment: string): number | undefined {\n  if (!Array.isArray(node)) return undefined;\n  const i = Number(segment);\n  return Number.isInteger(i) && i >= 0 ? i : undefined;\n}\n\n/**\n * Return a copy of `root` with `value` at `segments`, mutating nothing.\n *\n * Containers on the path are shallow-copied (arrays stay arrays); everything\n * off the path is shared by reference. An empty path returns `value` itself.\n */\nexport function setInPath(root: unknown, segments: readonly string[], value: unknown): unknown {\n  if (segments.length === 0) return value;\n  const next = copyContainer(root);\n  const segment = segments[0];\n  const index = indexOf(next, segment);\n  const child = index !== undefined ? next[index] : (next as Record<string, unknown>)[segment];\n  const replaced = setInPath(child, segments.slice(1), value);\n  if (index !== undefined) next[index] = replaced;\n  else (next as Record<string, unknown>)[segment] = replaced;\n  return next;\n}\n\n/**\n * Return a copy of `root` with the key at `segments` REMOVED, mutating nothing.\n *\n * On an array the slot is removed with `splice` (the array shrinks — `delete`\n * on an array index would leave a hole, which cannot survive\n * `structuredClone` round-trips as the same value). A path that does not\n * exist returns the root unchanged, by reference.\n */\nexport function deleteInPath(root: unknown, segments: readonly string[]): unknown {\n  if (segments.length === 0) return undefined;\n  if (root === null || typeof root !== 'object') return root;\n  const segment = segments[0];\n  const index = indexOf(root, segment);\n  if (segments.length === 1) {\n    if (index !== undefined) {\n      if (index >= (root as unknown[]).length) return root;\n      const copy = [...(root as unknown[])];\n      copy.splice(index, 1);\n      return copy;\n    }\n    if (!Object.prototype.hasOwnProperty.call(root, segment)) return root;\n    const copy = { ...(root as Record<string, unknown>) };\n    delete copy[segment];\n    return copy;\n  }\n  const child = index !== undefined ? (root as unknown[])[index] : (root as Record<string, unknown>)[segment];\n  const replaced = deleteInPath(child, segments.slice(1));\n  if (replaced === child) return root;\n  const copy = copyContainer(root);\n  if (index !== undefined) copy[index] = replaced;\n  else copy[segment] = replaced;\n  return copy;\n}\n"]}

package/dist/esm/lib/reactive/writeTraps.d.ts

@@ -47,9 +47,10 @@ export declare function rootKeySink(target: RootKeyTarget, readSilent: (key: str
  */
 export declare function elementSink(getCurrent: () => unknown[], commit: (next: unknown[]) => void, index: number): WriteSink;
 /**
- * WHY one set trap: the assigned value is unwrapped HERE (landmine 1 — the
- * JSON round-trip applies to what the caller handed in, never to the
- * surrounding state) and handed to the sink at the proxy's path plus the key.
+ * WHY one set trap: the assigned value is taken as a VALUE here (a handle
+ * becomes what it stands for, `handles.ts`; nothing else is copied — the
+ * buffer detaches at commit) and handed to the sink at the proxy's path plus
+ * the key.
  */
 export declare function sinkSetTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['set'];
 /**

package/dist/esm/lib/reactive/writeTraps.js

@@ -13,8 +13,9 @@
  * fixed in one copy of these traps and then found again in the other two).
  */
 import { nativeGet } from '../memory/pathOps.js';
+import { unwrapHandles } from './handles.js';
 import { buildNestedPatch } from './pathBuilder.js';
-import { deleteInPath, setInPath, unwrapProxy } from './structuralWrite.js';
+import { deleteInPath, setInPath } from './structuralWrite.js';
 /**
  * WHY: a write below a top-level key has TWO verbs (reactive/README.md, law
  * 3) — an object leaf is a `merge` of a nested patch, an array leaf or a
@@ -105,15 +106,16 @@ function removeInElement(getCurrent, commit, index, path) {
     commit(next);
 }
 /**
- * WHY one set trap: the assigned value is unwrapped HERE (landmine 1 — the
- * JSON round-trip applies to what the caller handed in, never to the
- * surrounding state) and handed to the sink at the proxy's path plus the key.
+ * WHY one set trap: the assigned value is taken as a VALUE here (a handle
+ * becomes what it stands for, `handles.ts`; nothing else is copied — the
+ * buffer detaches at commit) and handed to the sink at the proxy's path plus
+ * the key.
  */
 export function sinkSetTrap(sink, segments) {
     return (_target, prop, value) => {
         if (typeof prop !== 'string')
             return true;
-        sink.put([...segments, prop], unwrapProxy(value));
+        sink.put([...segments, prop], unwrapHandles(value));
         return true;
     };
 }
@@ -129,4 +131,4 @@ export function sinkDeleteTrap(sink, segments) {
         return true;
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writeTraps.js","sourceRoot":"","sources":["../../../../src/lib/reactive/writeTraps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/writeTraps — where a proxy's writes LAND, and the two traps that\n * send them there.\n *\n * Every object proxy in this folder (nested, terminal, element) intercepts\n * the same three things — a property set, a property delete, and an array\n * mutation somewhere below it — and differs only in where the write goes:\n * a nested/terminal proxy commits under a TOP-LEVEL KEY (an object write as\n * `merge` of a patch, an array write or a delete as `set` of the rebuilt\n * root); an element proxy commits the WHOLE OWNING ARRAY back through the\n * array proxy's own callback. That difference is a {@link WriteSink}; the\n * traps are written once over it (9.23.1 — the 9.22.0 stale-read bug was\n * fixed in one copy of these traps and then found again in the other two).\n */\n\nimport { nativeGet } from '../memory/pathOps.js';\nimport type { MemberCache } from './liveView.js';\nimport { buildNestedPatch } from './pathBuilder.js';\nimport { deleteInPath, setInPath, unwrapProxy } from './structuralWrite.js';\n\n/**\n * The seam between a proxy and state. `path` is measured from the sink's\n * root — the key's value for {@link rootKeySink}, the element for\n * {@link elementSink}; `[]` is the root itself.\n */\nexport interface WriteSink {\n  /** The value at `path`, as it stands NOW (read-your-writes; never a tracked read). */\n  readAt(path: readonly string[]): unknown;\n  /** Put an already-unwrapped `value` at `path`. The sink chooses the verb. */\n  put(path: readonly string[], value: unknown): void;\n  /** Remove the key at `path`. */\n  remove(path: readonly string[]): void;\n}\n\n/** The two ways a value reaches a state key: what the sink writes through. */\nexport interface RootKeyTarget {\n  setValue(key: string, value: unknown): void;\n  updateValue(key: string, value: unknown): void;\n}\n\n/**\n * WHY: a write below a top-level key has TWO verbs (reactive/README.md, law\n * 3) — an object leaf is a `merge` of a nested patch, an array leaf or a\n * delete rebuilds the root immutably and commits a `set` of the key. Only the\n * sink knows that; the traps do not. Every write drops the key's cached child\n * proxy (`cache`), so the next read is built over the new value.\n */\nexport function rootKeySink(\n  target: RootKeyTarget,\n  readSilent: (key: string) => unknown,\n  rootKey: string,\n  cache: Pick<MemberCache, 'delete'>,\n): WriteSink {\n  return new RootKeySink(target, readSilent, rootKey, cache);\n}\n\n/** One allocation per top-level read miss (the methods live on the prototype). */\nclass RootKeySink implements WriteSink {\n  constructor(\n    private readonly target: RootKeyTarget,\n    private readonly readSilent: (key: string) => unknown,\n    private readonly rootKey: string,\n    private readonly cache: Pick<MemberCache, 'delete'>,\n  ) {}\n\n  /** An empty path is the key's own value — `nativeGet(v, [])` would return it unchanged, so the walk is skipped. */\n  readAt(path: readonly string[]): unknown {\n    const root = this.readSilent(this.rootKey);\n    return path.length === 0 ? root : nativeGet(root, path as string[]);\n  }\n\n  put(path: readonly string[], value: unknown): void {\n    if (!Array.isArray(value)) this.target.updateValue(this.rootKey, buildNestedPatch(path as string[], value));\n    else this.target.setValue(this.rootKey, path.length === 0 ? value : setInPath(this.readAt([]), path, value));\n    this.cache.delete(this.rootKey);\n  }\n\n  remove(path: readonly string[]): void {\n    this.target.setValue(this.rootKey, deleteInPath(this.readAt([]), path));\n    this.cache.delete(this.rootKey);\n  }\n}\n\n/**\n * WHY: a write inside an array element is an array write — it rebuilds the\n * owning array immutably and hands the WHOLE new array to the array proxy's\n * commit, the funnel `push` already uses. `path` is measured from the\n * element; `[]` is the element slot itself.\n */\nexport function elementSink(getCurrent: () => unknown[], commit: (next: unknown[]) => void, index: number): WriteSink {\n  return new ElementSink(getCurrent, commit, index);\n}\n\n/** One allocation per element proxy (the methods live on the prototype) — a 10k-element loop builds 10k of these. */\nclass ElementSink implements WriteSink {\n  constructor(\n    private readonly getCurrent: () => unknown[],\n    private readonly commit: (next: unknown[]) => void,\n    private readonly index: number,\n  ) {}\n\n  readAt(path: readonly string[]): unknown {\n    return readInElement(this.getCurrent, this.index, path);\n  }\n\n  put(path: readonly string[], value: unknown): void {\n    replaceInElement(this.getCurrent, this.commit, this.index, path, value);\n  }\n\n  remove(path: readonly string[]): void {\n    removeInElement(this.getCurrent, this.commit, this.index, path);\n  }\n}\n\n/** The value at `path` inside element `index`, as it stands NOW (read-your-writes). */\nfunction readInElement(getCurrent: () => unknown[], index: number, path: readonly string[]): unknown {\n  const element = getCurrent()[index];\n  return path.length === 0 ? element : nativeGet(element, path as string[]);\n}\n\n/** A copy of the array with `value` at `path` inside element `index`; a gone element has nothing to write into. */\nfunction replaceInElement(\n  getCurrent: () => unknown[],\n  commit: (next: unknown[]) => void,\n  index: number,\n  path: readonly string[],\n  value: unknown,\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return;\n  next[index] = path.length === 0 ? value : setInPath(next[index], path, value);\n  commit(next);\n}\n\n/** A copy of the array with the key at `path` inside element `index` removed. */\nfunction removeInElement(\n  getCurrent: () => unknown[],\n  commit: (next: unknown[]) => void,\n  index: number,\n  path: readonly string[],\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return;\n  next[index] = deleteInPath(next[index], path);\n  commit(next);\n}\n\n/**\n * WHY one set trap: the assigned value is unwrapped HERE (landmine 1 — the\n * JSON round-trip applies to what the caller handed in, never to the\n * surrounding state) and handed to the sink at the proxy's path plus the key.\n */\nexport function sinkSetTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['set'] {\n  return (_target, prop, value) => {\n    if (typeof prop !== 'string') return true;\n    sink.put([...segments, prop], unwrapProxy(value));\n    return true;\n  };\n}\n\n/**\n * WHY one delete trap: `merge` cannot express a removal (a patch of\n * `undefined` reads as absent), so a delete always rebuilds through the sink.\n */\nexport function sinkDeleteTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['deleteProperty'] {\n  return (_target, prop) => {\n    if (typeof prop !== 'string') return true;\n    sink.remove([...segments, prop]);\n    return true;\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writeTraps.js","sourceRoot":"","sources":["../../../../src/lib/reactive/writeTraps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/writeTraps — where a proxy's writes LAND, and the two traps that\n * send them there.\n *\n * Every object proxy in this folder (nested, terminal, element) intercepts\n * the same three things — a property set, a property delete, and an array\n * mutation somewhere below it — and differs only in where the write goes:\n * a nested/terminal proxy commits under a TOP-LEVEL KEY (an object write as\n * `merge` of a patch, an array write or a delete as `set` of the rebuilt\n * root); an element proxy commits the WHOLE OWNING ARRAY back through the\n * array proxy's own callback. That difference is a {@link WriteSink}; the\n * traps are written once over it (9.23.1 — the 9.22.0 stale-read bug was\n * fixed in one copy of these traps and then found again in the other two).\n */\n\nimport { nativeGet } from '../memory/pathOps.js';\nimport { unwrapHandles } from './handles.js';\nimport type { MemberCache } from './liveView.js';\nimport { buildNestedPatch } from './pathBuilder.js';\nimport { deleteInPath, setInPath } from './structuralWrite.js';\n\n/**\n * The seam between a proxy and state. `path` is measured from the sink's\n * root — the key's value for {@link rootKeySink}, the element for\n * {@link elementSink}; `[]` is the root itself.\n */\nexport interface WriteSink {\n  /** The value at `path`, as it stands NOW (read-your-writes; never a tracked read). */\n  readAt(path: readonly string[]): unknown;\n  /** Put an already-unwrapped `value` at `path`. The sink chooses the verb. */\n  put(path: readonly string[], value: unknown): void;\n  /** Remove the key at `path`. */\n  remove(path: readonly string[]): void;\n}\n\n/** The two ways a value reaches a state key: what the sink writes through. */\nexport interface RootKeyTarget {\n  setValue(key: string, value: unknown): void;\n  updateValue(key: string, value: unknown): void;\n}\n\n/**\n * WHY: a write below a top-level key has TWO verbs (reactive/README.md, law\n * 3) — an object leaf is a `merge` of a nested patch, an array leaf or a\n * delete rebuilds the root immutably and commits a `set` of the key. Only the\n * sink knows that; the traps do not. Every write drops the key's cached child\n * proxy (`cache`), so the next read is built over the new value.\n */\nexport function rootKeySink(\n  target: RootKeyTarget,\n  readSilent: (key: string) => unknown,\n  rootKey: string,\n  cache: Pick<MemberCache, 'delete'>,\n): WriteSink {\n  return new RootKeySink(target, readSilent, rootKey, cache);\n}\n\n/** One allocation per top-level read miss (the methods live on the prototype). */\nclass RootKeySink implements WriteSink {\n  constructor(\n    private readonly target: RootKeyTarget,\n    private readonly readSilent: (key: string) => unknown,\n    private readonly rootKey: string,\n    private readonly cache: Pick<MemberCache, 'delete'>,\n  ) {}\n\n  /** An empty path is the key's own value — `nativeGet(v, [])` would return it unchanged, so the walk is skipped. */\n  readAt(path: readonly string[]): unknown {\n    const root = this.readSilent(this.rootKey);\n    return path.length === 0 ? root : nativeGet(root, path as string[]);\n  }\n\n  put(path: readonly string[], value: unknown): void {\n    if (!Array.isArray(value)) this.target.updateValue(this.rootKey, buildNestedPatch(path as string[], value));\n    else this.target.setValue(this.rootKey, path.length === 0 ? value : setInPath(this.readAt([]), path, value));\n    this.cache.delete(this.rootKey);\n  }\n\n  remove(path: readonly string[]): void {\n    this.target.setValue(this.rootKey, deleteInPath(this.readAt([]), path));\n    this.cache.delete(this.rootKey);\n  }\n}\n\n/**\n * WHY: a write inside an array element is an array write — it rebuilds the\n * owning array immutably and hands the WHOLE new array to the array proxy's\n * commit, the funnel `push` already uses. `path` is measured from the\n * element; `[]` is the element slot itself.\n */\nexport function elementSink(getCurrent: () => unknown[], commit: (next: unknown[]) => void, index: number): WriteSink {\n  return new ElementSink(getCurrent, commit, index);\n}\n\n/** One allocation per element proxy (the methods live on the prototype) — a 10k-element loop builds 10k of these. */\nclass ElementSink implements WriteSink {\n  constructor(\n    private readonly getCurrent: () => unknown[],\n    private readonly commit: (next: unknown[]) => void,\n    private readonly index: number,\n  ) {}\n\n  readAt(path: readonly string[]): unknown {\n    return readInElement(this.getCurrent, this.index, path);\n  }\n\n  put(path: readonly string[], value: unknown): void {\n    replaceInElement(this.getCurrent, this.commit, this.index, path, value);\n  }\n\n  remove(path: readonly string[]): void {\n    removeInElement(this.getCurrent, this.commit, this.index, path);\n  }\n}\n\n/** The value at `path` inside element `index`, as it stands NOW (read-your-writes). */\nfunction readInElement(getCurrent: () => unknown[], index: number, path: readonly string[]): unknown {\n  const element = getCurrent()[index];\n  return path.length === 0 ? element : nativeGet(element, path as string[]);\n}\n\n/** A copy of the array with `value` at `path` inside element `index`; a gone element has nothing to write into. */\nfunction replaceInElement(\n  getCurrent: () => unknown[],\n  commit: (next: unknown[]) => void,\n  index: number,\n  path: readonly string[],\n  value: unknown,\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return;\n  next[index] = path.length === 0 ? value : setInPath(next[index], path, value);\n  commit(next);\n}\n\n/** A copy of the array with the key at `path` inside element `index` removed. */\nfunction removeInElement(\n  getCurrent: () => unknown[],\n  commit: (next: unknown[]) => void,\n  index: number,\n  path: readonly string[],\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return;\n  next[index] = deleteInPath(next[index], path);\n  commit(next);\n}\n\n/**\n * WHY one set trap: the assigned value is taken as a VALUE here (a handle\n * becomes what it stands for, `handles.ts`; nothing else is copied — the\n * buffer detaches at commit) and handed to the sink at the proxy's path plus\n * the key.\n */\nexport function sinkSetTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['set'] {\n  return (_target, prop, value) => {\n    if (typeof prop !== 'string') return true;\n    sink.put([...segments, prop], unwrapHandles(value));\n    return true;\n  };\n}\n\n/**\n * WHY one delete trap: `merge` cannot express a removal (a patch of\n * `undefined` reads as absent), so a delete always rebuilds through the sink.\n */\nexport function sinkDeleteTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['deleteProperty'] {\n  return (_target, prop) => {\n    if (typeof prop !== 'string') return true;\n    sink.remove([...segments, prop]);\n    return true;\n  };\n}\n"]}

package/dist/index.js

@@ -125,4 +125,4 @@ Object.defineProperty(exports, "isDevMode", { enumerable: true, get: function ()
 // `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in
 // `footprintjs/zod` entry — keeping zod out of the core load path (it is an
 // optional peer). Import them from 'footprintjs/zod'.
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AASH,4BAA4B;AAC5B,mDAAwF;AAA/E,qGAAA,SAAS,OAAA;AAAE,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AA4BvD,4BAA4B;AAC5B,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAoBlB,mCAAmC;AACnC,kDAAuD;AAA9C,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAYvB,oBAAoB;AACpB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAE1B,oBAAoB;AACpB,kDAAmD;AAA1C,sGAAA,UAAU,OAAA;AAqBnB,+BAA+B;AAC/B,iDAAsD;AAA7C,0GAAA,cAAc,OAAA;AAEvB,+BAA+B;AAC/B,iDAAqD;AAA5C,yGAAA,aAAa,OAAA;AAEtB,oCAAoC;AACpC,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAmC1B,qEAAqE;AACrE,oDAKiC;AAJ/B,kHAAA,sBAAsB,OAAA;AACtB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,uGAAA,WAAW,OAAA;AAkDb,+BAA+B;AAC/B,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAK9B,+BAA+B;AAC/B,mDAA6D;AAApD,iHAAA,oBAAoB,OAAA;AAE7B,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAuE;AAA9D,2HAAA,8BAA8B,OAAA;AAEvC,+BAA+B;AAC/B,mDAAyE;AAAhE,6HAAA,gCAAgC,OAAA;AAEzC,+BAA+B;AAC/B,mDAAiE;AAAxD,qHAAA,wBAAwB,OAAA;AAEjC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAoE;AAA3D,wHAAA,2BAA2B,OAAA;AAEpC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAyBtC,uCAAuC;AACvC,mDAA6E;AAApE,+GAAA,kBAAkB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAE7C,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,qDAA4D;AAAnD,8GAAA,iBAAiB,OAAA;AAoB1B,6BAA6B;AAC7B,kDAAiD;AAAxC,sGAAA,SAAS,OAAA;AAiElB,sCAAsC;AACtC,mDAA2E;AAAlE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,kGAAA,KAAK,OAAA;AAE3C,sCAAsC;AACtC,mDAAqG;AAA5F,iHAAA,oBAAoB,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AASrE,gCAAgC;AAChC,mDAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAE1C,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,mEAAyF;AAAhF,mHAAA,cAAc,OAAA;AAAE,kHAAA,aAAa,OAAA;AAAE,8GAAA,SAAS,OAAA;AAEjD,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'summary'` default / `'clone'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `footprintjs/trace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\nexport type { CommitValuesMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AASH,4BAA4B;AAC5B,mDAAwF;AAA/E,qGAAA,SAAS,OAAA;AAAE,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AA6BvD,4BAA4B;AAC5B,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAoBlB,mCAAmC;AACnC,kDAAuD;AAA9C,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAYvB,oBAAoB;AACpB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAE1B,oBAAoB;AACpB,kDAAmD;AAA1C,sGAAA,UAAU,OAAA;AAqBnB,+BAA+B;AAC/B,iDAAsD;AAA7C,0GAAA,cAAc,OAAA;AAEvB,+BAA+B;AAC/B,iDAAqD;AAA5C,yGAAA,aAAa,OAAA;AAEtB,oCAAoC;AACpC,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAmC1B,qEAAqE;AACrE,oDAKiC;AAJ/B,kHAAA,sBAAsB,OAAA;AACtB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,uGAAA,WAAW,OAAA;AAkDb,+BAA+B;AAC/B,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAK9B,+BAA+B;AAC/B,mDAA6D;AAApD,iHAAA,oBAAoB,OAAA;AAE7B,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAuE;AAA9D,2HAAA,8BAA8B,OAAA;AAEvC,+BAA+B;AAC/B,mDAAyE;AAAhE,6HAAA,gCAAgC,OAAA;AAEzC,+BAA+B;AAC/B,mDAAiE;AAAxD,qHAAA,wBAAwB,OAAA;AAEjC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAoE;AAA3D,wHAAA,2BAA2B,OAAA;AAEpC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAyBtC,uCAAuC;AACvC,mDAA6E;AAApE,+GAAA,kBAAkB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAE7C,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,qDAA4D;AAAnD,8GAAA,iBAAiB,OAAA;AAoB1B,6BAA6B;AAC7B,kDAAiD;AAAxC,sGAAA,SAAS,OAAA;AAiElB,sCAAsC;AACtC,mDAA2E;AAAlE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,kGAAA,KAAK,OAAA;AAE3C,sCAAsC;AACtC,mDAAqG;AAA5F,iHAAA,oBAAoB,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AASrE,gCAAgC;AAChC,mDAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAE1C,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,mEAAyF;AAAhF,mHAAA,cAAc,OAAA;AAAE,kHAAA,aAAa,OAAA;AAAE,8GAAA,SAAS,OAAA;AAEjD,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'summary'` default / `'clone'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `footprintjs/trace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\nexport type { CommitValuesMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n"]}