footprintjs 9.45.0 → 9.46.1

package/dist/esm/lib/memory/runAddress.d.ts

@@ -0,0 +1,20 @@
+/**
+ * runAddress.ts — where a frame with a run id writes: the engine's run namespace (C2, a leaf of its own since C4, L4).
+ *
+ * The record layer never names a namespace: it takes the write ADDRESS as data, a path prefix
+ * (`RecordFrame · address`, `SharedMemory · getValue` / `setValue` / `updateValue`, the transaction
+ * buffer's `address`). The ENGINE decides it, from the one constant here: a frame with run id `c0`
+ * (a fork or selector child takes its own id at the top level) reads and writes at `runs/c0/…`, a
+ * frame without one at the root.
+ *
+ * WHY A LEAF. Two L4 files read the namespace and one imports the other: the frame
+ * (`StageContext`, which builds every address) and the redaction verdict (`redaction.ts` — a
+ * subflow mapper reading the namespace root reads every namespaced key; the mirror's seed scrubs
+ * every namespace). Until C4 the constant sat in `StageContext.ts` and the verdict, then an L2 file,
+ * spelled the namespace itself. This file imports nothing; `test/architecture/write-address.test.ts`
+ * pins it as the one spelling in the record's reach.
+ */
+/** The key run namespaces sit under — the engine's one spelling of it. */
+export declare const RUN_NAMESPACE = "runs";
+/** Where a frame with run id `runId` reads and writes: `['runs', <id>]`, or `[]` (the root) with none. */
+export declare function runAddress(runId: string): readonly string[];

package/dist/esm/lib/memory/runAddress.js

@@ -0,0 +1,25 @@
+/**
+ * runAddress.ts — where a frame with a run id writes: the engine's run namespace (C2, a leaf of its own since C4, L4).
+ *
+ * The record layer never names a namespace: it takes the write ADDRESS as data, a path prefix
+ * (`RecordFrame · address`, `SharedMemory · getValue` / `setValue` / `updateValue`, the transaction
+ * buffer's `address`). The ENGINE decides it, from the one constant here: a frame with run id `c0`
+ * (a fork or selector child takes its own id at the top level) reads and writes at `runs/c0/…`, a
+ * frame without one at the root.
+ *
+ * WHY A LEAF. Two L4 files read the namespace and one imports the other: the frame
+ * (`StageContext`, which builds every address) and the redaction verdict (`redaction.ts` — a
+ * subflow mapper reading the namespace root reads every namespaced key; the mirror's seed scrubs
+ * every namespace). Until C4 the constant sat in `StageContext.ts` and the verdict, then an L2 file,
+ * spelled the namespace itself. This file imports nothing; `test/architecture/write-address.test.ts`
+ * pins it as the one spelling in the record's reach.
+ */
+/** The key run namespaces sit under — the engine's one spelling of it. */
+export const RUN_NAMESPACE = 'runs';
+/** The root's address, shared by every frame without a run id (most of them). Never edited. */
+const ROOT_ADDRESS = Object.freeze([]);
+/** Where a frame with run id `runId` reads and writes: `['runs', <id>]`, or `[]` (the root) with none. */
+export function runAddress(runId) {
+    return runId ? [RUN_NAMESPACE, runId] : ROOT_ADDRESS;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/memory/scrub.d.ts

@@ -0,0 +1,51 @@
+/**
+ * scrub.ts — the commit log's scrub: the placeholder at every redacted path of a patch (C4, L2).
+ *
+ * The RECORD's half of a redaction. A redacted path is DATA by the time it reaches here — the
+ * transaction buffer's `redactedPaths`, registered by `RecordFrame · write` from the scrub it was
+ * handed — and this file only writes `LOG_PLACEHOLDER` (`placeholders.ts`) where such a path holds
+ * a value. It never decides WHAT is secret: that is the engine's verdict (`redaction.ts`, L4 —
+ * `RedactionRule` and the write decision), which also owns the OTHER placeholder, the scope channel's
+ * `SCOPE_PLACEHOLDER`. Before C4 both halves lived in `redaction.ts`, so the record imported the
+ * engine's policy module to write a string.
+ *
+ * THE LAW:
+ *   1. A path is scrubbed only where it holds a DEFINED value — scrubbing never invents a field.
+ *   2. Paths are scrubbed in the set's order, against the tree as scrubbed so far: a path under one
+ *      already scrubbed finds a string, not a container, and is left alone.
+ *   3. The input patch is never edited. `scrubPatch` copies only the spine of each scrubbed path
+ *      (and nothing at all when nothing is scrubbed); `redactPatch` hands back a fresh deep copy.
+ */
+import type { MemoryPatch } from './types.js';
+/**
+ * The commit log's scrub: `patch` with {@link LOG_PLACEHOLDER} at every path in `redactedPaths` that
+ * holds a defined value — the copy `recordCommit` records and feeds the redacted mirror.
+ *
+ * CLONE-FREE (9.33.0). The patch is the transaction buffer's commit-time payload, already the record's
+ * own copy (`TransactionBuffer · commit` clones each surviving path once; the buffer is dropped at
+ * commit), so the scrub copies only what it must not edit in place:
+ *   - no path to scrub (no policy, no per-call mark — the common case) → `patch` ITSELF, no copy at all;
+ *   - otherwise → a new root and a shallow copy of each container on a scrubbed path (`pathOps ·
+ *     ownSpine`), every other subtree shared with `patch`. `patch` is never edited.
+ * The engine called the public {@link redactPatch} (a whole `structuredClone`) twice per commit before
+ * 9.33.0. The bytes are the same: a scrubbed path holds the placeholder, every other path the value the
+ * buffer cloned (pinned by the 9.18.1 / 9.19.1 redaction byte tests).
+ *
+ * Paths are scrubbed in the set's order, against the tree as scrubbed so far: a path under one already
+ * scrubbed finds a string, not a container, and is left alone (as before).
+ *
+ * INTERNAL — the result shares structure with `patch`. A caller outside the commit path wants
+ * {@link redactPatch}.
+ *
+ * @param redactedPaths DELIM-joined paths (`TransactionBuffer`'s `redactedPaths`; a bundle's
+ *   `redactedPaths` array works too).
+ */
+export declare function scrubPatch(patch: MemoryPatch, redactedPaths: Iterable<string>): MemoryPatch;
+/**
+ * Redacts sensitive values in a patch for logging/debugging — the PUBLIC scrub (`footprintjs/advanced`),
+ * its contract unchanged since 4.x: a fresh deep copy of `patch` (`structuredClone`) with
+ * {@link LOG_PLACEHOLDER} at every listed path that holds a defined value. Shares nothing with `patch`
+ * and never edits it. (It lived in `memory/utils.ts` until 9.33.0 and in `memory/redaction.ts` until
+ * C4; the engine's own commit path uses the clone-free {@link scrubPatch}.)
+ */
+export declare function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch;

package/dist/esm/lib/memory/scrub.js

@@ -0,0 +1,72 @@
+/**
+ * scrub.ts — the commit log's scrub: the placeholder at every redacted path of a patch (C4, L2).
+ *
+ * The RECORD's half of a redaction. A redacted path is DATA by the time it reaches here — the
+ * transaction buffer's `redactedPaths`, registered by `RecordFrame · write` from the scrub it was
+ * handed — and this file only writes `LOG_PLACEHOLDER` (`placeholders.ts`) where such a path holds
+ * a value. It never decides WHAT is secret: that is the engine's verdict (`redaction.ts`, L4 —
+ * `RedactionRule` and the write decision), which also owns the OTHER placeholder, the scope channel's
+ * `SCOPE_PLACEHOLDER`. Before C4 both halves lived in `redaction.ts`, so the record imported the
+ * engine's policy module to write a string.
+ *
+ * THE LAW:
+ *   1. A path is scrubbed only where it holds a DEFINED value — scrubbing never invents a field.
+ *   2. Paths are scrubbed in the set's order, against the tree as scrubbed so far: a path under one
+ *      already scrubbed finds a string, not a container, and is left alone.
+ *   3. The input patch is never edited. `scrubPatch` copies only the spine of each scrubbed path
+ *      (and nothing at all when nothing is scrubbed); `redactPatch` hands back a fresh deep copy.
+ */
+import { nativeGet, nativeHas, nativeSet, ownedRootOf, ownSpine } from './pathOps.js';
+import { DELIM } from './paths.js';
+import { LOG_PLACEHOLDER } from './placeholders.js';
+/**
+ * The commit log's scrub: `patch` with {@link LOG_PLACEHOLDER} at every path in `redactedPaths` that
+ * holds a defined value — the copy `recordCommit` records and feeds the redacted mirror.
+ *
+ * CLONE-FREE (9.33.0). The patch is the transaction buffer's commit-time payload, already the record's
+ * own copy (`TransactionBuffer · commit` clones each surviving path once; the buffer is dropped at
+ * commit), so the scrub copies only what it must not edit in place:
+ *   - no path to scrub (no policy, no per-call mark — the common case) → `patch` ITSELF, no copy at all;
+ *   - otherwise → a new root and a shallow copy of each container on a scrubbed path (`pathOps ·
+ *     ownSpine`), every other subtree shared with `patch`. `patch` is never edited.
+ * The engine called the public {@link redactPatch} (a whole `structuredClone`) twice per commit before
+ * 9.33.0. The bytes are the same: a scrubbed path holds the placeholder, every other path the value the
+ * buffer cloned (pinned by the 9.18.1 / 9.19.1 redaction byte tests).
+ *
+ * Paths are scrubbed in the set's order, against the tree as scrubbed so far: a path under one already
+ * scrubbed finds a string, not a container, and is left alone (as before).
+ *
+ * INTERNAL — the result shares structure with `patch`. A caller outside the commit path wants
+ * {@link redactPatch}.
+ *
+ * @param redactedPaths DELIM-joined paths (`TransactionBuffer`'s `redactedPaths`; a bundle's
+ *   `redactedPaths` array works too).
+ */
+export function scrubPatch(patch, redactedPaths) {
+    let out;
+    let owned;
+    for (const flat of redactedPaths) {
+        const segs = flat.split(DELIM);
+        const current = out ?? patch;
+        if (!nativeHas(current, segs) || nativeGet(current, segs) === undefined)
+            continue;
+        if (out === undefined) {
+            owned = new WeakSet();
+            out = ownedRootOf(patch, owned);
+        }
+        ownSpine(out, segs, owned);
+        nativeSet(out, segs, LOG_PLACEHOLDER);
+    }
+    return out ?? patch;
+}
+/**
+ * Redacts sensitive values in a patch for logging/debugging — the PUBLIC scrub (`footprintjs/advanced`),
+ * its contract unchanged since 4.x: a fresh deep copy of `patch` (`structuredClone`) with
+ * {@link LOG_PLACEHOLDER} at every listed path that holds a defined value. Shares nothing with `patch`
+ * and never edits it. (It lived in `memory/utils.ts` until 9.33.0 and in `memory/redaction.ts` until
+ * C4; the engine's own commit path uses the clone-free {@link scrubPatch}.)
+ */
+export function redactPatch(patch, redactedSet) {
+    return scrubPatch(structuredClone(patch), redactedSet);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/memory/utils.d.ts

@@ -9,9 +9,9 @@
  * (`paths.ts`), structural equality (`equality.ts`) and the union merge
  * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,
  * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.
- * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.
+ * The log's scrub, `redactPatch`, moved out in 9.33.0; it is the record's own, `scrub.ts` (C4).
  * The writers take an ADDRESS, a path prefix their caller computed, and never
- * name one (C2: the engine decides where a stage writes, `StageContext · address`).
+ * name one (C2: the engine decides where a stage writes, `runAddress.ts · runAddress`).
  * Zero external dependencies.
  */
 export { deepEqual } from './equality.js';
@@ -25,7 +25,7 @@ type NestedObject = {
  * The two places a value at `path` can sit: under `address` (`runPath`, absent
  * for the root address `[]`) and at the root (`globalPath`). `address` is a
  * path prefix the caller computed — for the engine, a frame's run namespace
- * (`StageContext · address`, C2).
+ * (`runAddress.ts · runAddress`, C2), held by its record frame (`RecordFrame · address`, C3).
  */
 export declare function getRunAndGlobalPaths(address?: readonly string[], path?: (string | number)[]): {
     runPath: (string | number)[] | undefined;

package/dist/esm/lib/memory/utils.js

@@ -9,9 +9,9 @@
  * (`paths.ts`), structural equality (`equality.ts`) and the union merge
  * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,
  * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.
- * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.
+ * The log's scrub, `redactPatch`, moved out in 9.33.0; it is the record's own, `scrub.ts` (C4).
  * The writers take an ADDRESS, a path prefix their caller computed, and never
- * name one (C2: the engine decides where a stage writes, `StageContext · address`).
+ * name one (C2: the engine decides where a stage writes, `runAddress.ts · runAddress`).
  * Zero external dependencies.
  */
 import { nativeGet as _get } from './pathOps.js';
@@ -23,7 +23,7 @@ export { applySmartMerge, applySmartMergeInto, dryFold, nextGeneration, supersed
  * The two places a value at `path` can sit: under `address` (`runPath`, absent
  * for the root address `[]`) and at the root (`globalPath`). `address` is a
  * path prefix the caller computed — for the engine, a frame's run namespace
- * (`StageContext · address`, C2).
+ * (`runAddress.ts · runAddress`, C2), held by its record frame (`RecordFrame · address`, C3).
  */
 export function getRunAndGlobalPaths(address = [], path = []) {
     return {
@@ -129,4 +129,4 @@ export function getNestedValue(root, path, field) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — nested-object helpers for the heap, and the memory leaves' one\n * re-export surface.\n *\n * The helpers here (`setNestedValue`, `updateNestedValue`, `updateValue`,\n * `getNestedValue`) walk a nested object by path with\n * prototype-pollution protection. Everything else this file used to hold has an\n * owner of its own and is re-exported, so no importer moved: the path codec\n * (`paths.ts`), structural equality (`equality.ts`) and the union merge\n * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,\n * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.\n * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.\n * The writers take an ADDRESS, a path prefix their caller computed, and never\n * name one (C2: the engine decides where a stage writes, `StageContext · address`).\n * Zero external dependencies.\n */\n\nimport { nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport { DELIM } from './paths.js';\nimport type { MemoryPatch } from './types.js';\n\nexport { deepEqual } from './equality.js';\nexport { deepSmartMerge } from './merge.js';\nexport { DELIM, normalisePath, pathSegments } from './paths.js';\nexport { applySmartMerge, applySmartMergeInto, dryFold, nextGeneration, supersededByNextSet } from './verbs.js';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * The two places a value at `path` can sit: under `address` (`runPath`, absent\n * for the root address `[]`) and at the root (`globalPath`). `address` is a\n * path prefix the caller computed — for the engine, a frame's run namespace\n * (`StageContext · address`, C2).\n */\nexport function getRunAndGlobalPaths(address: readonly string[] = [], path: (string | number)[] = []) {\n  return {\n    runPath: addressOf(address).length > 0 ? pathUnder(address, path) : undefined,\n    globalPath: [...path],\n  };\n}\n\n/** An address is an array. A run id still passed in its place (C2) is refused, never spread into its characters. */\nfunction addressOf(address: readonly string[]): readonly string[] {\n  if (Array.isArray(address)) return address;\n  throw new TypeError(\n    `footprintjs: an address is an array path prefix, got ${address === null ? 'null' : typeof address}`,\n  );\n}\n\n/**\n * `address` then `path`, as one new array. An index loop, because the double\n * spread `[...address, ...path]` costs twice as much and a frame builds one on\n * every read it serves from live state (a fork child reading a root key).\n */\nfunction pathUnder(address: readonly string[], path: readonly (string | number)[]): (string | number)[] {\n  const out = new Array<string | number>(address.length + path.length);\n  for (let i = 0; i < address.length; i++) out[i] = address[i];\n  for (let i = 0; i < path.length; i++) out[address.length + i] = path[i];\n  return out;\n}\n\n/**\n * The container at `address` + `path` inside `obj`, each missing one created\n * on the way: the one AT the address from `defaultValues` when given, every\n * other one empty. The one walk both nested writers share.\n */\nfunction containerAt(\n  obj: NestedObject,\n  address: readonly string[] = [],\n  path: readonly (string | number)[] = [],\n  defaultValues?: unknown,\n): NestedObject {\n  const segments = pathUnder(addressOf(address), path);\n  let current = obj;\n  for (let i = 0; i < segments.length; i++) {\n    const key = segments[i];\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = i === address.length - 1 && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  return current;\n}\n\n/**\n * Sets a value at a nested path under `address`, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  address: readonly string[],\n  path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  containerAt(obj, address, path, defaultValues)[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at a nested path under `address`.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  address: readonly string[],\n  path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  updateValue(containerAt(obj, address, path, defaultValues), field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — nested-object helpers for the heap, and the memory leaves' one\n * re-export surface.\n *\n * The helpers here (`setNestedValue`, `updateNestedValue`, `updateValue`,\n * `getNestedValue`) walk a nested object by path with\n * prototype-pollution protection. Everything else this file used to hold has an\n * owner of its own and is re-exported, so no importer moved: the path codec\n * (`paths.ts`), structural equality (`equality.ts`) and the union merge\n * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,\n * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.\n * The log's scrub, `redactPatch`, moved out in 9.33.0; it is the record's own, `scrub.ts` (C4).\n * The writers take an ADDRESS, a path prefix their caller computed, and never\n * name one (C2: the engine decides where a stage writes, `runAddress.ts · runAddress`).\n * Zero external dependencies.\n */\n\nimport { nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport { DELIM } from './paths.js';\nimport type { MemoryPatch } from './types.js';\n\nexport { deepEqual } from './equality.js';\nexport { deepSmartMerge } from './merge.js';\nexport { DELIM, normalisePath, pathSegments } from './paths.js';\nexport { applySmartMerge, applySmartMergeInto, dryFold, nextGeneration, supersededByNextSet } from './verbs.js';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * The two places a value at `path` can sit: under `address` (`runPath`, absent\n * for the root address `[]`) and at the root (`globalPath`). `address` is a\n * path prefix the caller computed — for the engine, a frame's run namespace\n * (`runAddress.ts · runAddress`, C2), held by its record frame (`RecordFrame · address`, C3).\n */\nexport function getRunAndGlobalPaths(address: readonly string[] = [], path: (string | number)[] = []) {\n  return {\n    runPath: addressOf(address).length > 0 ? pathUnder(address, path) : undefined,\n    globalPath: [...path],\n  };\n}\n\n/** An address is an array. A run id still passed in its place (C2) is refused, never spread into its characters. */\nfunction addressOf(address: readonly string[]): readonly string[] {\n  if (Array.isArray(address)) return address;\n  throw new TypeError(\n    `footprintjs: an address is an array path prefix, got ${address === null ? 'null' : typeof address}`,\n  );\n}\n\n/**\n * `address` then `path`, as one new array. An index loop, because the double\n * spread `[...address, ...path]` costs twice as much and a frame builds one on\n * every read it serves from live state (a fork child reading a root key).\n */\nfunction pathUnder(address: readonly string[], path: readonly (string | number)[]): (string | number)[] {\n  const out = new Array<string | number>(address.length + path.length);\n  for (let i = 0; i < address.length; i++) out[i] = address[i];\n  for (let i = 0; i < path.length; i++) out[address.length + i] = path[i];\n  return out;\n}\n\n/**\n * The container at `address` + `path` inside `obj`, each missing one created\n * on the way: the one AT the address from `defaultValues` when given, every\n * other one empty. The one walk both nested writers share.\n */\nfunction containerAt(\n  obj: NestedObject,\n  address: readonly string[] = [],\n  path: readonly (string | number)[] = [],\n  defaultValues?: unknown,\n): NestedObject {\n  const segments = pathUnder(addressOf(address), path);\n  let current = obj;\n  for (let i = 0; i < segments.length; i++) {\n    const key = segments[i];\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = i === address.length - 1 && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  return current;\n}\n\n/**\n * Sets a value at a nested path under `address`, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  address: readonly string[],\n  path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  containerAt(obj, address, path, defaultValues)[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at a nested path under `address`.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  address: readonly string[],\n  path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  updateValue(containerAt(obj, address, path, defaultValues), field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n"]}

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

@@ -5,7 +5,7 @@
  * path inside the value I read, put this". The value it read is BORROWED —
  * before a stage's first staged write it is a bare reference into committed
  * shared memory, and committed state is immutable-after-swap (see
- * `StageContext.firstTouchState`). Editing it in place would corrupt every
+ * `RecordFrame · firstTouch`). Editing it in place would corrupt every
  * in-flight stage AND leave the commit log with nothing to record.
  *
  * So the write path never mutates. It COPIES the containers along the path

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

@@ -5,7 +5,7 @@
  * path inside the value I read, put this". The value it read is BORROWED —
  * before a stage's first staged write it is a bare reference into committed
  * shared memory, and committed state is immutable-after-swap (see
- * `StageContext.firstTouchState`). Editing it in place would corrupt every
+ * `RecordFrame · firstTouch`). Editing it in place would corrupt every
  * in-flight stage AND leave the commit log with nothing to record.
  *
  * So the write path never mutates. It COPIES the containers along the path
@@ -101,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 * 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"]}
+//# 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 * `RecordFrame · firstTouch`). 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/lib/decide/evaluator.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateFilter = void 0;
 const summarize_js_1 = require("../capture/summarize.js");
 const devMode_js_1 = require("../devMode.js");
-const placeholders_js_1 = require("../memory/placeholders.js");
+const redaction_js_1 = require("../memory/redaction.js");
 const OPERATOR_HANDLERS = {
     eq: (a, t) => a === t,
     ne: (a, t) => a !== t,
@@ -94,7 +94,7 @@ function evaluateFilter(getValueFn, isRedactedFn, filter) {
             continue;
         const actual = getValueFn(key);
         const redacted = isRedactedFn(key);
-        const displayValue = redacted ? placeholders_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(actual, MAX_VALUE_LEN);
+        const displayValue = redacted ? redaction_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(actual, MAX_VALUE_LEN);
         // Evaluate each operator in the FilterOps for this key
         for (const [op, threshold] of Object.entries(ops)) {
             const handler = OPERATOR_HANDLERS[op];
@@ -131,4 +131,4 @@ function evaluateFilter(getValueFn, isRedactedFn, filter) {
     return { matched: allMatched, conditions };
 }
 exports.evaluateFilter = evaluateFilter;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../src/lib/decide/evaluator.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,0DAAyD;AACzD,8CAA0C;AAC1C,+DAA8D;AAO9D,MAAM,iBAAiB,GAA+B;IACpD,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACrB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACrB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,GAAI,CAAY;IAC3C,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,IAAK,CAAY;IAC7C,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,GAAI,CAAY;IAC3C,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,IAAK,CAAY;IAC7C,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACX,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QACpC,IAAI,CAAC,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,0CAA0C,iBAAiB,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IACD,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACd,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC,CAAC,sCAAsC;QAC1E,IAAI,CAAC,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,0CAA0C,iBAAiB,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;CACF,CAAC;AAEF,+EAA+E;AAE/E,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC;IAC1B,WAAW;IACX,aAAa;IACb,WAAW;IACX,UAAU;IACV,SAAS;IACT,gBAAgB;IAChB,eAAe;IACf,sBAAsB;IACtB,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;CACnB,CAAC,CAAC;AAEH,+EAA+E;AAE/E,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAC/B,MAAM,aAAa,GAAG,EAAE,CAAC;AAEzB,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,cAAc,CAC5B,UAAoC,EACpC,YAAsC,EACtC,MAAsB;IAEtB,MAAM,UAAU,GAAsB,EAAE,CAAC;IACzC,IAAI,UAAU,GAAG,IAAI,CAAC;IAEtB,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAChD,uFAAuF;QACvF,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,UAAU,GAAG,KAAK,CAAC;YACnB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS;QAE9C,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QACnC,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,mCAAiB,CAAC,CAAC,CAAC,IAAA,6BAAc,EAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAE1F,uDAAuD;QACvD,KAAK,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAA8B,CAAC,EAAE,CAAC;YAC7E,MAAM,OAAO,GAAG,iBAAiB,CAAC,EAAE,CAAC,CAAC;YACtC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,+EAA+E;gBAC/E,IAAI,IAAA,sBAAS,GAAE,EAAE,CAAC;oBAChB,sCAAsC;oBACtC,OAAO,CAAC,IAAI,CACV,2DAA2D,EAAE,aAAa,GAAG,MAAM;wBACjF,6CAA6C,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAC5F,CAAC;gBACJ,CAAC;gBACD,UAAU,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;gBAC9F,UAAU,GAAG,KAAK,CAAC;gBACnB,SAAS;YACX,CAAC;YAED,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAC1C,UAAU,CAAC,IAAI,CAAC;gBACd,GAAG;gBACH,EAAE;gBACF,SAAS;gBACT,aAAa,EAAE,YAAY;gBAC3B,MAAM;gBACN,QAAQ;aACT,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM;gBAAE,UAAU,GAAG,KAAK,CAAC;QAClC,CAAC;IACH,CAAC;IAED,6EAA6E;IAC7E,wEAAwE;IACxE,yEAAyE;IACzE,gDAAgD;IAChD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAEnE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;AAC7C,CAAC;AA1DD,wCA0DC","sourcesContent":["/**\n * decide/evaluator -- Prisma-style filter evaluator for decision rules.\n *\n * Pure function. Takes a WhereFilter, a value getter, and a redaction checker.\n * Evaluates each condition, records the result, returns matched/conditions.\n *\n * All keys in the filter are ANDed (all must match for the rule to match).\n * Decoupled from ScopeFacade — receives callbacks, not scope.\n */\n\nimport { summarizeValue } from '../capture/summarize.js';\nimport { isDevMode } from '../devMode.js';\nimport { SCOPE_PLACEHOLDER } from '../memory/placeholders.js';\nimport type { FilterCondition, WhereFilter } from './types.js';\n\n// -- Operator dispatch table -------------------------------------------------\n\ntype OperatorFn = (actual: unknown, threshold: unknown) => boolean;\n\nconst OPERATOR_HANDLERS: Record<string, OperatorFn> = {\n  eq: (a, t) => a === t,\n  ne: (a, t) => a !== t,\n  gt: (a, t) => (a as number) > (t as number),\n  gte: (a, t) => (a as number) >= (t as number),\n  lt: (a, t) => (a as number) < (t as number),\n  lte: (a, t) => (a as number) <= (t as number),\n  in: (a, t) => {\n    if (!Array.isArray(t)) return false;\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return t.includes(a);\n  },\n  notIn: (a, t) => {\n    if (!Array.isArray(t)) return true; // not in a non-array = vacuously true\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return !t.includes(a);\n  },\n};\n\n// -- Security: prototype pollution denylist ----------------------------------\n\nconst DENIED_KEYS = new Set([\n  '__proto__',\n  'constructor',\n  'prototype',\n  'toString',\n  'valueOf',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  '__defineGetter__',\n  '__defineSetter__',\n  '__lookupGetter__',\n  '__lookupSetter__',\n]);\n\n// -- Constants ---------------------------------------------------------------\n\nconst MAX_IN_ARRAY_SIZE = 1000;\nconst MAX_VALUE_LEN = 80;\n\n// -- Evaluator ---------------------------------------------------------------\n\n/**\n * Evaluates a Prisma-style filter against scope values.\n *\n * ## Empty filter → NO match (anti-vacuous-truth — inverts Prisma/SQL)\n *\n * A filter with no evaluable conditions (`{}`, or only denied/non-object\n * keys) returns `matched: false`. This deliberately INVERTS the Prisma/SQL\n * intuition where `where: {}` matches everything: in a decision rule, a rule\n * that asserts nothing should never win a branch — \"all zero conditions\n * passed\" is vacuous truth, and silently routing on it would fabricate\n * decision evidence. Want a catch-all? Use the explicit `defaultBranch`\n * argument of `decide()` instead of an empty `when`.\n *\n * ## Unknown operators → condition fails (+ dev-mode warning)\n *\n * An operator outside the supported set (`eq, ne, gt, gte, lt, lte, in,\n * notIn`) records a failed condition — the rule can never spuriously match\n * through a typo (`gte` misspelled `gle`). With dev mode enabled\n * (`enableDevMode()`), a console warning names the unknown operator and key.\n *\n * @param getValueFn - Reads a value from scope by key (raw, for comparison)\n * @param isRedactedFn - Checks if a key is redacted (for evidence display)\n * @param filter - The WhereFilter to evaluate\n * @returns { matched, conditions } — matched = all conditions passed\n */\nexport function evaluateFilter<T extends object>(\n  getValueFn: (key: string) => unknown,\n  isRedactedFn: (key: string) => boolean,\n  filter: WhereFilter<T>,\n): { matched: boolean; conditions: FilterCondition[] } {\n  const conditions: FilterCondition[] = [];\n  let allMatched = true;\n\n  for (const [key, ops] of Object.entries(filter)) {\n    // Security: denied keys cause rule to fail (consistent with unknown operator behavior)\n    if (DENIED_KEYS.has(key)) {\n      allMatched = false;\n      continue;\n    }\n    if (!ops || typeof ops !== 'object') continue;\n\n    const actual = getValueFn(key);\n    const redacted = isRedactedFn(key);\n    const displayValue = redacted ? SCOPE_PLACEHOLDER : summarizeValue(actual, MAX_VALUE_LEN);\n\n    // Evaluate each operator in the FilterOps for this key\n    for (const [op, threshold] of Object.entries(ops as Record<string, unknown>)) {\n      const handler = OPERATOR_HANDLERS[op];\n      if (!handler) {\n        // Unknown operator: treat as failed condition so rule doesn't spuriously match\n        if (isDevMode()) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `[footprint] decide()/select() filter: unknown operator \"${op}\" on key \"${key}\" — ` +\n              `condition never matches (valid operators: ${Object.keys(OPERATOR_HANDLERS).join(', ')})`,\n          );\n        }\n        conditions.push({ key, op, threshold, actualSummary: displayValue, result: false, redacted });\n        allMatched = false;\n        continue;\n      }\n\n      const result = handler(actual, threshold);\n      conditions.push({\n        key,\n        op,\n        threshold,\n        actualSummary: displayValue,\n        result,\n        redacted,\n      });\n\n      if (!result) allMatched = false;\n    }\n  }\n\n  // Empty filter (no evaluable conditions) should NOT match — prevents vacuous\n  // truth. NOTE: this deliberately inverts Prisma/SQL `where: {}` (\"match\n  // everything\") — see the function JSDoc. Catch-alls belong in decide()'s\n  // explicit defaultBranch, not in an empty rule.\n  if (conditions.length === 0) return { matched: false, conditions };\n\n  return { matched: allMatched, conditions };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../src/lib/decide/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/evaluator -- Prisma-style filter evaluator for decision rules.\n *\n * Pure function. Takes a WhereFilter, a value getter, and a redaction checker.\n * Evaluates each condition, records the result, returns matched/conditions.\n *\n * All keys in the filter are ANDed (all must match for the rule to match).\n * Decoupled from ScopeFacade — receives callbacks, not scope.\n */\n\nimport { summarizeValue } from '../capture/summarize.js';\nimport { isDevMode } from '../devMode.js';\nimport { SCOPE_PLACEHOLDER } from '../memory/redaction.js';\nimport type { FilterCondition, WhereFilter } from './types.js';\n\n// -- Operator dispatch table -------------------------------------------------\n\ntype OperatorFn = (actual: unknown, threshold: unknown) => boolean;\n\nconst OPERATOR_HANDLERS: Record<string, OperatorFn> = {\n  eq: (a, t) => a === t,\n  ne: (a, t) => a !== t,\n  gt: (a, t) => (a as number) > (t as number),\n  gte: (a, t) => (a as number) >= (t as number),\n  lt: (a, t) => (a as number) < (t as number),\n  lte: (a, t) => (a as number) <= (t as number),\n  in: (a, t) => {\n    if (!Array.isArray(t)) return false;\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return t.includes(a);\n  },\n  notIn: (a, t) => {\n    if (!Array.isArray(t)) return true; // not in a non-array = vacuously true\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return !t.includes(a);\n  },\n};\n\n// -- Security: prototype pollution denylist ----------------------------------\n\nconst DENIED_KEYS = new Set([\n  '__proto__',\n  'constructor',\n  'prototype',\n  'toString',\n  'valueOf',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  '__defineGetter__',\n  '__defineSetter__',\n  '__lookupGetter__',\n  '__lookupSetter__',\n]);\n\n// -- Constants ---------------------------------------------------------------\n\nconst MAX_IN_ARRAY_SIZE = 1000;\nconst MAX_VALUE_LEN = 80;\n\n// -- Evaluator ---------------------------------------------------------------\n\n/**\n * Evaluates a Prisma-style filter against scope values.\n *\n * ## Empty filter → NO match (anti-vacuous-truth — inverts Prisma/SQL)\n *\n * A filter with no evaluable conditions (`{}`, or only denied/non-object\n * keys) returns `matched: false`. This deliberately INVERTS the Prisma/SQL\n * intuition where `where: {}` matches everything: in a decision rule, a rule\n * that asserts nothing should never win a branch — \"all zero conditions\n * passed\" is vacuous truth, and silently routing on it would fabricate\n * decision evidence. Want a catch-all? Use the explicit `defaultBranch`\n * argument of `decide()` instead of an empty `when`.\n *\n * ## Unknown operators → condition fails (+ dev-mode warning)\n *\n * An operator outside the supported set (`eq, ne, gt, gte, lt, lte, in,\n * notIn`) records a failed condition — the rule can never spuriously match\n * through a typo (`gte` misspelled `gle`). With dev mode enabled\n * (`enableDevMode()`), a console warning names the unknown operator and key.\n *\n * @param getValueFn - Reads a value from scope by key (raw, for comparison)\n * @param isRedactedFn - Checks if a key is redacted (for evidence display)\n * @param filter - The WhereFilter to evaluate\n * @returns { matched, conditions } — matched = all conditions passed\n */\nexport function evaluateFilter<T extends object>(\n  getValueFn: (key: string) => unknown,\n  isRedactedFn: (key: string) => boolean,\n  filter: WhereFilter<T>,\n): { matched: boolean; conditions: FilterCondition[] } {\n  const conditions: FilterCondition[] = [];\n  let allMatched = true;\n\n  for (const [key, ops] of Object.entries(filter)) {\n    // Security: denied keys cause rule to fail (consistent with unknown operator behavior)\n    if (DENIED_KEYS.has(key)) {\n      allMatched = false;\n      continue;\n    }\n    if (!ops || typeof ops !== 'object') continue;\n\n    const actual = getValueFn(key);\n    const redacted = isRedactedFn(key);\n    const displayValue = redacted ? SCOPE_PLACEHOLDER : summarizeValue(actual, MAX_VALUE_LEN);\n\n    // Evaluate each operator in the FilterOps for this key\n    for (const [op, threshold] of Object.entries(ops as Record<string, unknown>)) {\n      const handler = OPERATOR_HANDLERS[op];\n      if (!handler) {\n        // Unknown operator: treat as failed condition so rule doesn't spuriously match\n        if (isDevMode()) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `[footprint] decide()/select() filter: unknown operator \"${op}\" on key \"${key}\" — ` +\n              `condition never matches (valid operators: ${Object.keys(OPERATOR_HANDLERS).join(', ')})`,\n          );\n        }\n        conditions.push({ key, op, threshold, actualSummary: displayValue, result: false, redacted });\n        allMatched = false;\n        continue;\n      }\n\n      const result = handler(actual, threshold);\n      conditions.push({\n        key,\n        op,\n        threshold,\n        actualSummary: displayValue,\n        result,\n        redacted,\n      });\n\n      if (!result) allMatched = false;\n    }\n  }\n\n  // Empty filter (no evaluable conditions) should NOT match — prevents vacuous\n  // truth. NOTE: this deliberately inverts Prisma/SQL `where: {}` (\"match\n  // everything\") — see the function JSDoc. Catch-alls belong in decide()'s\n  // explicit defaultBranch, not in an empty rule.\n  if (conditions.length === 0) return { matched: false, conditions };\n\n  return { matched: allMatched, conditions };\n}\n"]}

package/dist/lib/decide/evidence.js

@@ -10,7 +10,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvidenceCollector = void 0;
 const summarize_js_1 = require("../capture/summarize.js");
-const placeholders_js_1 = require("../memory/placeholders.js");
+const redaction_js_1 = require("../memory/redaction.js");
 const MAX_VALUE_LEN = 80;
 let evidenceCounter = 0;
 /**
@@ -28,7 +28,7 @@ class EvidenceCollector {
             return;
         this.inputs.push({
             key: event.key,
-            valueSummary: event.redacted ? placeholders_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(event.value, MAX_VALUE_LEN),
+            valueSummary: event.redacted ? redaction_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(event.value, MAX_VALUE_LEN),
             redacted: event.redacted === true,
         });
     }
@@ -38,4 +38,4 @@ class EvidenceCollector {
     }
 }
 exports.EvidenceCollector = EvidenceCollector;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZpZGVuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2RlY2lkZS9ldmlkZW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7R0FPRzs7O0FBRUgsMERBQXlEO0FBQ3pELCtEQUE4RDtBQUk5RCxNQUFNLGFBQWEsR0FBRyxFQUFFLENBQUM7QUFFekIsSUFBSSxlQUFlLEdBQUcsQ0FBQyxDQUFDO0FBRXhCOzs7R0FHRztBQUNILE1BQWEsaUJBQWlCO0lBQ25CLEVBQUUsQ0FBUztJQUNaLE1BQU0sR0FBZ0IsRUFBRSxDQUFDO0lBRWpDO1FBQ0UsSUFBSSxDQUFDLEVBQUUsR0FBRyxZQUFZLEVBQUUsZUFBZSxFQUFFLENBQUM7SUFDNUMsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFnQjtRQUNyQixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUc7WUFBRSxPQUFPO1FBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDO1lBQ2YsR0FBRyxFQUFFLEtBQUssQ0FBQyxHQUFHO1lBQ2QsWUFBWSxFQUFFLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLG1DQUFpQixDQUFDLENBQUMsQ0FBQyxJQUFBLDZCQUFjLEVBQUMsS0FBSyxDQUFDLEtBQUssRUFBRSxhQUFhLENBQUM7WUFDN0YsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRLEtBQUssSUFBSTtTQUNsQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQscUNBQXFDO0lBQ3JDLFNBQVM7UUFDUCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDckIsQ0FBQztDQUNGO0FBckJELDhDQXFCQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogZGVjaWRlL2V2aWRlbmNlIC0tIExpZ2h0d2VpZ2h0IHRlbXAgcmVjb3JkZXIgZm9yIGF1dG8tY2FwdHVyaW5nIHJlYWRzXG4gKiBkdXJpbmcgYSB3aGVuKCkgZnVuY3Rpb24gY2FsbC5cbiAqXG4gKiBBdHRhY2hlZCB0byBzY29wZSBiZWZvcmUgY2FsbGluZyB3aGVuKHNjb3BlKSwgZGV0YWNoZWQgYWZ0ZXIuXG4gKiBDYXB0dXJlcyBSZWFkRXZlbnQga2V5ICsgc3VtbWFyaXplZCB2YWx1ZSArIHJlZGFjdGlvbiBmbGFnLlxuICogVXNlcyBzdW1tYXJpemVWYWx1ZSgpIGF0IGNhcHR1cmUgdGltZSAobm8gcmF3IG9iamVjdCByZWZlcmVuY2VzIGhlbGQpLlxuICovXG5cbmltcG9ydCB7IHN1bW1hcml6ZVZhbHVlIH0gZnJvbSAnLi4vY2FwdHVyZS9zdW1tYXJpemUuanMnO1xuaW1wb3J0IHsgU0NPUEVfUExBQ0VIT0xERVIgfSBmcm9tICcuLi9tZW1vcnkvcGxhY2Vob2xkZXJzLmpzJztcbmltcG9ydCB0eXBlIHsgUmVhZEV2ZW50LCBTY29wZVJlY29yZGVyIH0gZnJvbSAnLi4vc2NvcGUvdHlwZXMuanMnO1xuaW1wb3J0IHR5cGUgeyBSZWFkSW5wdXQgfSBmcm9tICcuL3R5cGVzLmpzJztcblxuY29uc3QgTUFYX1ZBTFVFX0xFTiA9IDgwO1xuXG5sZXQgZXZpZGVuY2VDb3VudGVyID0gMDtcblxuLyoqXG4gKiBNaW5pbWFsIFNjb3BlUmVjb3JkZXIgdGhhdCBjYXB0dXJlcyByZWFkcyBmb3IgZGVjaXNpb24gZXZpZGVuY2UuXG4gKiBBdHRhY2ggYmVmb3JlIHdoZW4oKSwgZGV0YWNoIGFmdGVyLiBDb2xsZWN0IHZpYSBnZXRJbnB1dHMoKS5cbiAqL1xuZXhwb3J0IGNsYXNzIEV2aWRlbmNlQ29sbGVjdG9yIGltcGxlbWVudHMgU2NvcGVSZWNvcmRlciB7XG4gIHJlYWRvbmx5IGlkOiBzdHJpbmc7XG4gIHByaXZhdGUgaW5wdXRzOiBSZWFkSW5wdXRbXSA9IFtdO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMuaWQgPSBgZXZpZGVuY2UtJHsrK2V2aWRlbmNlQ291bnRlcn1gO1xuICB9XG5cbiAgb25SZWFkKGV2ZW50OiBSZWFkRXZlbnQpOiB2b2lkIHtcbiAgICBpZiAoIWV2ZW50LmtleSkgcmV0dXJuO1xuICAgIHRoaXMuaW5wdXRzLnB1c2goe1xuICAgICAga2V5OiBldmVudC5rZXksXG4gICAgICB2YWx1ZVN1bW1hcnk6IGV2ZW50LnJlZGFjdGVkID8gU0NPUEVfUExBQ0VIT0xERVIgOiBzdW1tYXJpemVWYWx1ZShldmVudC52YWx1ZSwgTUFYX1ZBTFVFX0xFTiksXG4gICAgICByZWRhY3RlZDogZXZlbnQucmVkYWN0ZWQgPT09IHRydWUsXG4gICAgfSk7XG4gIH1cblxuICAvKiogUmV0dXJucyBjb2xsZWN0ZWQgcmVhZCBpbnB1dHMuICovXG4gIGdldElucHV0cygpOiBSZWFkSW5wdXRbXSB7XG4gICAgcmV0dXJuIHRoaXMuaW5wdXRzO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/engine/handlers/servedPause.js

@@ -14,7 +14,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.servedPause = void 0;
-const placeholders_js_1 = require("../../memory/placeholders.js");
+const redaction_js_1 = require("../../memory/redaction.js");
 function servedPause(context, pauseData) {
     const rule = context.getRedactionRule();
     if (!rule)
@@ -23,8 +23,8 @@ function servedPause(context, pauseData) {
         return rule.retainBoundary(pauseData);
     }
     catch {
-        return placeholders_js_1.SCOPE_PLACEHOLDER;
+        return redaction_js_1.SCOPE_PLACEHOLDER;
     }
 }
 exports.servedPause = servedPause;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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