footprintjs 9.48.2 → 10.0.0

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

@@ -1,93 +0,0 @@
-/**
- * honesty.ts — the ONE vocabulary for what a reader cannot see.
- *
- * WHY THIS FILE EXISTS. A recording cannot always answer what it is asked, and the library says
- * so in several places, each in its own words: a slice carries `HonestyNote`s and, when it has no
- * answer, a `missing` reason; a fed edge and an element birth carry a `basis`; a fold carries a
- * `basis` and its `redacted` paths; a stored log reports `LogGap`s; a causal node carries
- * `incompleteSources` and `truncated`. A reader that wants to EXPLAIN any of them to a person (a
- * why-panel, an agent tool) kept its own table of code → sentence, and tables kept apart drift.
- * This file is that table, once.
- *
- * WHAT IT HOLDS.
- *   - `HONESTY_CODES` — a frozen, closed registry: code → the ONE sentence that says what the code
- *     means. The shape of rustc's `--explain` and LSP's `Diagnostic.code`: the code is the stable
- *     key a consumer BRANCHES on; the sentence is for whoever reads the screen. It is not the
- *     per-instance `detail` a note carries (that names the key, the budget, the rows).
- *   - `HonestyCode` / `RegisteredCode` — what makes the registry the owner and not a suggestion:
- *     each public union of these codes (`HonestyNoteCode`, `MissingSliceReason`,
- *     `MissingProvenanceReason`, `FedBasis`, `AttributionBasis`, `FoldBasis`, and since 9.33.0 `ValueBasis` /
- *     `WriterBasis` — the basis twins of `commitValueAt` / `findLastWriter`) declares its members
- *     through `RegisteredCode`, so a member the registry does not hold fails to COMPILE. And
- *     `test/architecture/honesty-vocabulary.test.ts` asks the type checker for every exported type
- *     alias of `footprintjs/trace` that is a union of string literals: each one is inside the
- *     registry or is named, with its reason, as not an honesty vocabulary.
- *
- * NO OBJECT GAINS A FIELD from being registered. Three signals carry no code of their own — a
- * `LogGap` (`'log-gap'`), `CausalNode.incompleteSources` (`'incomplete-sources'`) and
- * `FoldedState.redacted` / `redactedPaths` (`'redacted'`) — and a `truncated: { byDepth, byNodes }`
- * field means `'truncated'`; they are registered so a reader explains them from the same place.
- *
- * NOT HERE: the two strings a redaction leaves where a value was. The engine writes those on every
- * redacted run; the log's lives in its own leaf, `memory/placeholders.ts` (the scope channel's with
- * the verdict, `memory/redaction.ts`), so that an app which only runs charts does not carry these
- * sentences in its bundle (`HONESTY_CODES` is a pure expression, so a bundler drops it wherever
- * nothing reads it).
- *
- * WHY L0. This file imports NOTHING, and `slice/` and `time-travel/` (L3) type their codes through
- * it, so it sits below them — the layer table is `scripts/layering.config.cjs`.
- *
- * @example
- * ```typescript
- * import { HONESTY_CODES } from 'footprintjs/trace';
- *
- * for (const { code } of forwardSlice.notes) console.log(code, '→', HONESTY_CODES[code]);
- * // reads-not-recorded → This log carries no recorded read at all (the readTracking: 'off' signature), …
- * HONESTY_CODES[foldedState.basis]; // 'log-only' → No initialState travelled with this log (…), …
- * ```
- */
-/**
- * Every honesty code the trace readers (`footprintjs/trace`) speak, with the one sentence that says
- * what it means.
- *
- * Frozen and closed: the keys are exactly the codes below, and {@link HonestyCode} is derived from
- * them. A new code is one new line here: a union declared through {@link RegisteredCode} cannot hold
- * a code that is not on it, and `test/architecture/honesty-vocabulary.test.ts` fails on an exported
- * type alias of `footprintjs/trace` that is a union of string literals neither inside the registry
- * nor named there as not an honesty vocabulary. The values are typed `string`, not literal types,
- * on purpose: the sentences are for a screen and may be reworded; a consumer branches on the KEY.
- */
-export declare const HONESTY_CODES: Readonly<{
-    'conservative-fed-edges': string;
-    'nested-rows': string;
-    'pre-run-origin': string;
-    'reads-not-recorded': string;
-    'unknown-key': string;
-    truncated: string;
-    'empty-log': string;
-    'never-written': string;
-    'not-an-array': string;
-    'per-write': string;
-    stage: string;
-    'append-verb': string;
-    'prefix-inference': string;
-    'whole-value': string;
-    'initial+log': string;
-    'log-only': string;
-    'log-gap': string;
-    'incomplete-sources': string;
-    redacted: string;
-    deleted: string;
-    'from-initial-state': string;
-}>;
-/** Any code in {@link HONESTY_CODES} — the key a reader looks an explanation up by. */
-export type HonestyCode = keyof typeof HONESTY_CODES;
-/**
- * A union of honesty codes a type DECLARES: `T` must be a subset of {@link HonestyCode}, or the
- * declaration fails to compile (TS2344).
- *
- * `RegisteredCode<T>` is `T` — an identity at the type level — so the union keeps exactly the
- * members it was written with and does NOT widen to every code:
- * `type FoldBasis = RegisteredCode<'initial+log' | 'log-only'>`.
- */
-export type RegisteredCode<T extends HonestyCode> = T;

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

@@ -1,92 +0,0 @@
-/**
- * honesty.ts — the ONE vocabulary for what a reader cannot see.
- *
- * WHY THIS FILE EXISTS. A recording cannot always answer what it is asked, and the library says
- * so in several places, each in its own words: a slice carries `HonestyNote`s and, when it has no
- * answer, a `missing` reason; a fed edge and an element birth carry a `basis`; a fold carries a
- * `basis` and its `redacted` paths; a stored log reports `LogGap`s; a causal node carries
- * `incompleteSources` and `truncated`. A reader that wants to EXPLAIN any of them to a person (a
- * why-panel, an agent tool) kept its own table of code → sentence, and tables kept apart drift.
- * This file is that table, once.
- *
- * WHAT IT HOLDS.
- *   - `HONESTY_CODES` — a frozen, closed registry: code → the ONE sentence that says what the code
- *     means. The shape of rustc's `--explain` and LSP's `Diagnostic.code`: the code is the stable
- *     key a consumer BRANCHES on; the sentence is for whoever reads the screen. It is not the
- *     per-instance `detail` a note carries (that names the key, the budget, the rows).
- *   - `HonestyCode` / `RegisteredCode` — what makes the registry the owner and not a suggestion:
- *     each public union of these codes (`HonestyNoteCode`, `MissingSliceReason`,
- *     `MissingProvenanceReason`, `FedBasis`, `AttributionBasis`, `FoldBasis`, and since 9.33.0 `ValueBasis` /
- *     `WriterBasis` — the basis twins of `commitValueAt` / `findLastWriter`) declares its members
- *     through `RegisteredCode`, so a member the registry does not hold fails to COMPILE. And
- *     `test/architecture/honesty-vocabulary.test.ts` asks the type checker for every exported type
- *     alias of `footprintjs/trace` that is a union of string literals: each one is inside the
- *     registry or is named, with its reason, as not an honesty vocabulary.
- *
- * NO OBJECT GAINS A FIELD from being registered. Three signals carry no code of their own — a
- * `LogGap` (`'log-gap'`), `CausalNode.incompleteSources` (`'incomplete-sources'`) and
- * `FoldedState.redacted` / `redactedPaths` (`'redacted'`) — and a `truncated: { byDepth, byNodes }`
- * field means `'truncated'`; they are registered so a reader explains them from the same place.
- *
- * NOT HERE: the two strings a redaction leaves where a value was. The engine writes those on every
- * redacted run; the log's lives in its own leaf, `memory/placeholders.ts` (the scope channel's with
- * the verdict, `memory/redaction.ts`), so that an app which only runs charts does not carry these
- * sentences in its bundle (`HONESTY_CODES` is a pure expression, so a bundler drops it wherever
- * nothing reads it).
- *
- * WHY L0. This file imports NOTHING, and `slice/` and `time-travel/` (L3) type their codes through
- * it, so it sits below them — the layer table is `scripts/layering.config.cjs`.
- *
- * @example
- * ```typescript
- * import { HONESTY_CODES } from 'footprintjs/trace';
- *
- * for (const { code } of forwardSlice.notes) console.log(code, '→', HONESTY_CODES[code]);
- * // reads-not-recorded → This log carries no recorded read at all (the readTracking: 'off' signature), …
- * HONESTY_CODES[foldedState.basis]; // 'log-only' → No initialState travelled with this log (…), …
- * ```
- */
-/**
- * Every honesty code the trace readers (`footprintjs/trace`) speak, with the one sentence that says
- * what it means.
- *
- * Frozen and closed: the keys are exactly the codes below, and {@link HonestyCode} is derived from
- * them. A new code is one new line here: a union declared through {@link RegisteredCode} cannot hold
- * a code that is not on it, and `test/architecture/honesty-vocabulary.test.ts` fails on an exported
- * type alias of `footprintjs/trace` that is a union of string literals neither inside the registry
- * nor named there as not an honesty vocabulary. The values are typed `string`, not literal types,
- * on purpose: the sentences are for a screen and may be reworded; a consumer branches on the KEY.
- */
-export const HONESTY_CODES = /* @__PURE__ */ Object.freeze({
-    // ── a slice's notes — `HonestyNote.code` (slice/) ─────────────────────────
-    'conservative-fed-edges': "At least one 'fed' edge is stage-level (conservative): its write carries no per-write read provenance, so the edge may not be real — turn on writeProvenance: 'reads-prefix' for exact edges.",
-    'nested-rows': "A write this answer rests on reached the key only through paths inside it (a subflow's input seed, an outputMapper merge-back, a fork child's namespace), so it changed part of the key's value, not the whole: earlier writes may account for the rest, and a reader of the key may not have read the part that write changed.",
-    'pre-run-origin': 'The value being followed was absent or already there before the first write this log can see (initial state, frozen run input or a closure), so who put it there is outside the commit log.',
-    'reads-not-recorded': "This log carries no recorded read at all (the readTracking: 'off' signature), so 'nothing read this value' is unknowable here, not true.",
-    'unknown-key': "This log has no write and no recorded read of the key, which is most likely a typo or the wrong run's log rather than a variable with no history.",
-    truncated: 'A budget (maxDepth or maxNodes) cut the walk, so more of the answer exists beyond the horizon it stopped at.',
-    // ── why a slice has no answer — `missing` (slice/: MissingSliceReason, MissingProvenanceReason) ─
-    'empty-log': 'The commit log holds no commit at all (nothing has executed, or the log handed in is empty), so there is no history to answer from.',
-    'never-written': 'No commit in the range asked about wrote the key — not its whole value, not a path inside it, and not a container around it in a way that changed it (a forward slice or a timeline also found no recorded read on, inside or around it) — so there is no write to start from: any value it has came from the initial state, the frozen run input or a closure, none of which the commit log can see.',
-    'not-an-array': 'The key was written, but its value at the point asked about is not an array (a scalar or object key, a deleted key, or a merge that degraded it), so element provenance does not apply: sliceForKey is the query for it.',
-    // ── how a fed edge was attributed — `ForwardEdge.basis` (slice/: FedBasis) ─
-    'per-write': "This fed edge is exact: the downstream write carries per-write read provenance (TraceEntry.readKeys, recorded under writeProvenance: 'reads-prefix') and that list names the key, so the value was read before the write it feeds.",
-    stage: 'This fed edge is conservative: the downstream write carries no per-write read provenance (the writeProvenance dial was off, or the log is mixed), so all that is known is that its stage read this key and wrote that path in some order, and the edge may not be real.',
-    // ── how an element's birth was attributed — `ElementBirth.basis` (slice/: AttributionBasis) ─
-    'append-verb': "The engine recorded the element in an append row's tail (how commitValues: 'delta' records an array's growth), so the commit that added it is known exactly, not inferred.",
-    'prefix-inference': 'A whole-value write (a set or a merge) kept the previous array as its prefix, so the new tail is attributed to that commit by inference: a write that replaced the array with one that happens to begin the same way looks identical.',
-    'whole-value': "This commit placed the array wholesale (there was no earlier array, or the new one does not begin with it), so every element's birth resets to this commit: exact, but coarse.",
-    // ── how a fold was derived — `FoldedState.basis` (time-travel/) ───────────
-    'initial+log': 'The fold started from the fold base that travelled with the log (initialState) and replayed the commit log onto it, so nothing seeded before the run is missing; rows it could not read are listed apart, in skipped.',
-    'log-only': 'No initialState travelled with this log (a snapshot stored before 9.17, a redacted snapshot or a hand-built log), so the fold started from an empty object: a key seeded before the run is whole only once a commit since wrote its whole value, and until then it holds just what its merges, appends and nested writes added, or nothing.',
-    // ── a row of a stored log that is not a commit bundle — `LogGap` ──────────
-    'log-gap': 'A row of the stored log could not be read as a commit bundle, so it keeps its index but contributes no state, and any fold that crosses it is missing whatever that row wrote.',
-    // ── untracked reads a stage also consumed — `CausalNode.incompleteSources` ─
-    'incomplete-sources': 'The stage also consumed read paths that bypass read tracking (args, env or an unshadowed silent read), so a slice through it may be incomplete: those reads produce no read-to-write edge to follow.',
-    // ── values scrubbed at write time — `FoldedState.redacted` / `redactedPaths`, a value basis ─
-    redacted: "Values at the paths listed in redactedPaths (a fold's, or a commit's in the range a key's value rests on) were scrubbed when they were written (by a redaction policy, or a write marked redacted), so where the answer holds the log's placeholder 'REDACTED', or lost a key under a container the placeholder replaced, it stands in for a value the log never recorded.",
-    // ── how one key's value was read off the log — `ValueBasis` (commitValueAtWithBasis) ─
-    deleted: "The key's last write in the range asked about left it absent (a delete of the key or of a container around it, or a set of a container that no longer holds it), so the answer is undefined because the record says the key was gone at that point, not because nothing was recorded.",
-    'from-initial-state': "No set or delete of the key, or of a container around it, is in the range asked about, so the answer rests on the value the key had before the run: folded from the initialState passed in when there was one, and otherwise only what the log's merges, appends and nested writes added to it (or nothing), which is partial for a key seeded before the run.",
-});
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"honesty.js","sourceRoot":"","sources":["../../../../src/lib/memory/honesty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC;IACzD,6EAA6E;IAC7E,wBAAwB,EACtB,+LAA+L;IACjM,aAAa,EACX,iUAAiU;IACnU,gBAAgB,EACd,6LAA6L;IAC/L,oBAAoB,EAClB,0IAA0I;IAC5I,aAAa,EACX,mJAAmJ;IACrJ,SAAS,EACP,8GAA8G;IAChH,mGAAmG;IACnG,WAAW,EACT,qIAAqI;IACvI,eAAe,EACb,uYAAuY;IACzY,cAAc,EACZ,0NAA0N;IAC5N,8EAA8E;IAC9E,WAAW,EACT,oOAAoO;IACtO,KAAK,EACH,yQAAyQ;IAC3Q,+FAA+F;IAC/F,aAAa,EACX,4KAA4K;IAC9K,kBAAkB,EAChB,uOAAuO;IACzO,aAAa,EACX,gLAAgL;IAClL,6EAA6E;IAC7E,aAAa,EACX,uNAAuN;IACzN,UAAU,EACR,6UAA6U;IAC/U,6EAA6E;IAC7E,SAAS,EACP,gLAAgL;IAClL,8EAA8E;IAC9E,oBAAoB,EAClB,sMAAsM;IACxM,+FAA+F;IAC/F,QAAQ,EACN,4WAA4W;IAC9W,wFAAwF;IACxF,OAAO,EACL,uRAAuR;IACzR,oBAAoB,EAClB,gWAAgW;CAClU,CAAC,CAAC","sourcesContent":["/**\n * honesty.ts — the ONE vocabulary for what a reader cannot see.\n *\n * WHY THIS FILE EXISTS. A recording cannot always answer what it is asked, and the library says\n * so in several places, each in its own words: a slice carries `HonestyNote`s and, when it has no\n * answer, a `missing` reason; a fed edge and an element birth carry a `basis`; a fold carries a\n * `basis` and its `redacted` paths; a stored log reports `LogGap`s; a causal node carries\n * `incompleteSources` and `truncated`. A reader that wants to EXPLAIN any of them to a person (a\n * why-panel, an agent tool) kept its own table of code → sentence, and tables kept apart drift.\n * This file is that table, once.\n *\n * WHAT IT HOLDS.\n *   - `HONESTY_CODES` — a frozen, closed registry: code → the ONE sentence that says what the code\n *     means. The shape of rustc's `--explain` and LSP's `Diagnostic.code`: the code is the stable\n *     key a consumer BRANCHES on; the sentence is for whoever reads the screen. It is not the\n *     per-instance `detail` a note carries (that names the key, the budget, the rows).\n *   - `HonestyCode` / `RegisteredCode` — what makes the registry the owner and not a suggestion:\n *     each public union of these codes (`HonestyNoteCode`, `MissingSliceReason`,\n *     `MissingProvenanceReason`, `FedBasis`, `AttributionBasis`, `FoldBasis`, and since 9.33.0 `ValueBasis` /\n *     `WriterBasis` — the basis twins of `commitValueAt` / `findLastWriter`) declares its members\n *     through `RegisteredCode`, so a member the registry does not hold fails to COMPILE. And\n *     `test/architecture/honesty-vocabulary.test.ts` asks the type checker for every exported type\n *     alias of `footprintjs/trace` that is a union of string literals: each one is inside the\n *     registry or is named, with its reason, as not an honesty vocabulary.\n *\n * NO OBJECT GAINS A FIELD from being registered. Three signals carry no code of their own — a\n * `LogGap` (`'log-gap'`), `CausalNode.incompleteSources` (`'incomplete-sources'`) and\n * `FoldedState.redacted` / `redactedPaths` (`'redacted'`) — and a `truncated: { byDepth, byNodes }`\n * field means `'truncated'`; they are registered so a reader explains them from the same place.\n *\n * NOT HERE: the two strings a redaction leaves where a value was. The engine writes those on every\n * redacted run; the log's lives in its own leaf, `memory/placeholders.ts` (the scope channel's with\n * the verdict, `memory/redaction.ts`), so that an app which only runs charts does not carry these\n * sentences in its bundle (`HONESTY_CODES` is a pure expression, so a bundler drops it wherever\n * nothing reads it).\n *\n * WHY L0. This file imports NOTHING, and `slice/` and `time-travel/` (L3) type their codes through\n * it, so it sits below them — the layer table is `scripts/layering.config.cjs`.\n *\n * @example\n * ```typescript\n * import { HONESTY_CODES } from 'footprintjs/trace';\n *\n * for (const { code } of forwardSlice.notes) console.log(code, '→', HONESTY_CODES[code]);\n * // reads-not-recorded → This log carries no recorded read at all (the readTracking: 'off' signature), …\n * HONESTY_CODES[foldedState.basis]; // 'log-only' → No initialState travelled with this log (…), …\n * ```\n */\n\n/**\n * Every honesty code the trace readers (`footprintjs/trace`) speak, with the one sentence that says\n * what it means.\n *\n * Frozen and closed: the keys are exactly the codes below, and {@link HonestyCode} is derived from\n * them. A new code is one new line here: a union declared through {@link RegisteredCode} cannot hold\n * a code that is not on it, and `test/architecture/honesty-vocabulary.test.ts` fails on an exported\n * type alias of `footprintjs/trace` that is a union of string literals neither inside the registry\n * nor named there as not an honesty vocabulary. The values are typed `string`, not literal types,\n * on purpose: the sentences are for a screen and may be reworded; a consumer branches on the KEY.\n */\nexport const HONESTY_CODES = /* @__PURE__ */ Object.freeze({\n  // ── a slice's notes — `HonestyNote.code` (slice/) ─────────────────────────\n  'conservative-fed-edges':\n    \"At least one 'fed' edge is stage-level (conservative): its write carries no per-write read provenance, so the edge may not be real — turn on writeProvenance: 'reads-prefix' for exact edges.\",\n  'nested-rows':\n    \"A write this answer rests on reached the key only through paths inside it (a subflow's input seed, an outputMapper merge-back, a fork child's namespace), so it changed part of the key's value, not the whole: earlier writes may account for the rest, and a reader of the key may not have read the part that write changed.\",\n  'pre-run-origin':\n    'The value being followed was absent or already there before the first write this log can see (initial state, frozen run input or a closure), so who put it there is outside the commit log.',\n  'reads-not-recorded':\n    \"This log carries no recorded read at all (the readTracking: 'off' signature), so 'nothing read this value' is unknowable here, not true.\",\n  'unknown-key':\n    \"This log has no write and no recorded read of the key, which is most likely a typo or the wrong run's log rather than a variable with no history.\",\n  truncated:\n    'A budget (maxDepth or maxNodes) cut the walk, so more of the answer exists beyond the horizon it stopped at.',\n  // ── why a slice has no answer — `missing` (slice/: MissingSliceReason, MissingProvenanceReason) ─\n  'empty-log':\n    'The commit log holds no commit at all (nothing has executed, or the log handed in is empty), so there is no history to answer from.',\n  'never-written':\n    'No commit in the range asked about wrote the key — not its whole value, not a path inside it, and not a container around it in a way that changed it (a forward slice or a timeline also found no recorded read on, inside or around it) — so there is no write to start from: any value it has came from the initial state, the frozen run input or a closure, none of which the commit log can see.',\n  'not-an-array':\n    'The key was written, but its value at the point asked about is not an array (a scalar or object key, a deleted key, or a merge that degraded it), so element provenance does not apply: sliceForKey is the query for it.',\n  // ── how a fed edge was attributed — `ForwardEdge.basis` (slice/: FedBasis) ─\n  'per-write':\n    \"This fed edge is exact: the downstream write carries per-write read provenance (TraceEntry.readKeys, recorded under writeProvenance: 'reads-prefix') and that list names the key, so the value was read before the write it feeds.\",\n  stage:\n    'This fed edge is conservative: the downstream write carries no per-write read provenance (the writeProvenance dial was off, or the log is mixed), so all that is known is that its stage read this key and wrote that path in some order, and the edge may not be real.',\n  // ── how an element's birth was attributed — `ElementBirth.basis` (slice/: AttributionBasis) ─\n  'append-verb':\n    \"The engine recorded the element in an append row's tail (how commitValues: 'delta' records an array's growth), so the commit that added it is known exactly, not inferred.\",\n  'prefix-inference':\n    'A whole-value write (a set or a merge) kept the previous array as its prefix, so the new tail is attributed to that commit by inference: a write that replaced the array with one that happens to begin the same way looks identical.',\n  'whole-value':\n    \"This commit placed the array wholesale (there was no earlier array, or the new one does not begin with it), so every element's birth resets to this commit: exact, but coarse.\",\n  // ── how a fold was derived — `FoldedState.basis` (time-travel/) ───────────\n  'initial+log':\n    'The fold started from the fold base that travelled with the log (initialState) and replayed the commit log onto it, so nothing seeded before the run is missing; rows it could not read are listed apart, in skipped.',\n  'log-only':\n    'No initialState travelled with this log (a snapshot stored before 9.17, a redacted snapshot or a hand-built log), so the fold started from an empty object: a key seeded before the run is whole only once a commit since wrote its whole value, and until then it holds just what its merges, appends and nested writes added, or nothing.',\n  // ── a row of a stored log that is not a commit bundle — `LogGap` ──────────\n  'log-gap':\n    'A row of the stored log could not be read as a commit bundle, so it keeps its index but contributes no state, and any fold that crosses it is missing whatever that row wrote.',\n  // ── untracked reads a stage also consumed — `CausalNode.incompleteSources` ─\n  'incomplete-sources':\n    'The stage also consumed read paths that bypass read tracking (args, env or an unshadowed silent read), so a slice through it may be incomplete: those reads produce no read-to-write edge to follow.',\n  // ── values scrubbed at write time — `FoldedState.redacted` / `redactedPaths`, a value basis ─\n  redacted:\n    \"Values at the paths listed in redactedPaths (a fold's, or a commit's in the range a key's value rests on) were scrubbed when they were written (by a redaction policy, or a write marked redacted), so where the answer holds the log's placeholder 'REDACTED', or lost a key under a container the placeholder replaced, it stands in for a value the log never recorded.\",\n  // ── how one key's value was read off the log — `ValueBasis` (commitValueAtWithBasis) ─\n  deleted:\n    \"The key's last write in the range asked about left it absent (a delete of the key or of a container around it, or a set of a container that no longer holds it), so the answer is undefined because the record says the key was gone at that point, not because nothing was recorded.\",\n  'from-initial-state':\n    \"No set or delete of the key, or of a container around it, is in the range asked about, so the answer rests on the value the key had before the run: folded from the initialState passed in when there was one, and otherwise only what the log's merges, appends and nested writes added to it (or nothing), which is partial for a key seeded before the run.\",\n} satisfies Record<string, string>);\n\n/** Any code in {@link HONESTY_CODES} — the key a reader looks an explanation up by. */\nexport type HonestyCode = keyof typeof HONESTY_CODES;\n\n/**\n * A union of honesty codes a type DECLARES: `T` must be a subset of {@link HonestyCode}, or the\n * declaration fails to compile (TS2344).\n *\n * `RegisteredCode<T>` is `T` — an identity at the type level — so the union keeps exactly the\n * members it was written with and does NOT widen to every code:\n * `type FoldBasis = RegisteredCode<'initial+log' | 'log-only'>`.\n */\nexport type RegisteredCode<T extends HonestyCode> = T;\n"]}

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

@@ -1,125 +0,0 @@
-/**
- * keyPaths.ts — which rows of a commit log touch a state key. ONE answer (F3, 9.33.0).
- *
- * WHY THIS FILE EXISTS. A key query (`commitValueAt`, `findLastWriter`, `causalChain`, the slice
- * layer) asks "which rows wrote `key`?". Each reader used to answer with its own `row.path === key`,
- * so a row written INSIDE the key — `cfg␟b`, which every subflow seed of an object, every
- * outputMapper merge-back and every fork child's namespace produces — was invisible to all of
- * them, while the fold (`stateAt`, the live commit) applied it. The fold said `{a:1,b:2}`; the key
- * queries said "never written". Every reader now asks here.
- *
- * THE PATH HALF (this file, L0 — it imports only the path codec and types):
- *   - {@link relation} — how a row's path sits against a key's path. A segment prefix on the
- *     DELIM-joined path, the way RFC 6901 prefixes a JSON Pointer: `cfg` is a prefix of `cfg␟a`,
- *     never of `cfgX`. A row is `'exact'` (on the key), `'inside'` (below it — it wrote part of the
- *     key's value) or `'around'` (above it — it wrote a container that holds the key).
- *   - {@link buildWriterIndex} / {@link writerCandidates} — one pass over a log, then the rows that
- *     can have written a key, found through its top-level key instead of a scan.
- *
- * THE RULES (defined here; the fold is L1 and the log readers L3, so `commitLogUtils.ts` applies
- * them — `writersOf`, `findLastWriter`, `commitValueAt`):
- *   - THE WRITER RULE — commit `c` WRITES key `K` iff `c` has a row `'exact'` or `'inside'` `K`,
- *     or a row `'around'` `K` across which the value at `K` differs (compared over the whole commit,
- *     not row by row: a value that changes and changes back inside one commit was not written).
- *     A top-level key has no `'around'` rows, so for it the rule is the path check alone.
- *     Why not every `'around'` row: `$update('cfg', { list: [3] })` is a `merge` row on `cfg`, but
- *     it never reaches `cfg␟a` — counting it named the wrong writer of `cfg␟a`.
- *   - THE VALUE RULE — the value of `K` at commit `i` is the fold of EVERY row under `K`'s top-level
- *     key up to `i`, anchored at that key's last `set`/`delete`, read at `K`: the fold `stateAt`
- *     does, restricted to one top-level key. Top-level keys never interact under the step, so the
- *     restriction is exact. Folding only the rows that touch `K` is NOT: an array union
- *     (`deepSmartMerge`) dedups the whole array, so a sibling element written beside `a␟1` changes
- *     where a later merge on `a` leaves `a[1]`.
- *
- * @example
- * ```typescript
- * relation('cfg\u001Fb', 'cfg'); // 'inside' — the row wrote part of cfg
- * relation('cfg', 'cfg\u001Fa'); // 'around' — the row wrote the container cfg.a lives in
- * relation('cfgX', 'cfg');       // undefined — a different key, not a prefix match
- * ```
- */
-import type { CommitBundle } from './types.js';
-/**
- * The WORK every key query has done — rows indexed and scanned, fold steps, around-verdicts, trie and
- * ancestor steps, binary searches, a causal walk's own loops — summed across calls. A deterministic cost
- * measure: `test/lib/memory/boundary/key-query-scaling.test.ts` asserts a causal walk's work grows linearly
- * in the log by COUNTING it (a wall-clock ratio failed on a busy machine). Never read by the library; one
- * integer add per unit of work it already does. Here, at L0, so every layer that does that work can count it.
- */
-export declare const queryWork: {
-    units: number;
-};
-/** How a row's path sits against a key's path. `undefined` from {@link relation} means disjoint. */
-export type PathRelation = 'exact' | 'inside' | 'around';
-/**
- * How the row path `rowPath` sits against the key `key` — both DELIM-joined `TraceEntry.path`
- * strings (a top-level key is a one-segment path). `'exact'` when they are equal, `'inside'` when
- * the row is below the key, `'around'` when the row is above it, `undefined` when neither is a
- * segment prefix of the other.
- */
-export declare function relation(rowPath: string, key: string): PathRelation | undefined;
-/** The top-level key a DELIM-joined path belongs to — its first segment. */
-export declare function rootOf(path: string): string;
-/**
- * One written path in a {@link WriterIndex} — a node of the path TRIE built over a log. A node exists for
- * every written path and every prefix of one.
- */
-export interface PathNode {
-    /** The DELIM-joined path this node stands for. */
-    readonly path: string;
-    /** ARRAY positions of the commits with a row exactly on this path — ascending, one per commit. */
-    readonly positions: number[];
-    /** The subset of {@link positions} whose row here is a `set` or a `delete` (it decides the value alone). */
-    readonly totals: number[];
-    /** Positions of commits whose row with a non-`delete` verb sits on this path (the rest are deletes only). */
-    readonly writes: number[];
-    /** The next segment → its node. */
-    readonly children: Map<string, PathNode>;
-    /** Memo of {@link subtreePositions}. */
-    subtree?: readonly number[];
-}
-/**
- * The positions in a log where each written path was written: a path trie per top-level key. Built in ONE
- * pass (`O(total path segments)`); a key's candidates then cost `O(depth + matches)` — its node, its
- * ancestors, its subtree — never a scan of every path under its top-level key.
- */
-export interface WriterIndex {
-    /** Every top-level key → the root of its trie. */
-    readonly roots: ReadonlyMap<string, PathNode>;
-}
-/**
- * One pass over `commitLog`: the path trie of every written path. Build it ONCE when a reader asks about
- * many keys (a causal walk, a forward slice) — or let `commitLogUtils · logModel` memoise it for a frozen log.
- */
-export declare function buildWriterIndex(commitLog: readonly CommitBundle[]): WriterIndex;
-/** Every path a row was written on, in trie order. */
-export declare function pathsWritten(index: WriterIndex): string[];
-/** The node for `key`, or undefined when no row was written on it or below it. */
-export declare function nodeAt(index: WriterIndex, key: string): PathNode | undefined;
-/** The nodes of `key`'s PROPER ancestors that exist in the index, top-level key first. */
-export declare function ancestorNodes(index: WriterIndex, key: string): PathNode[];
-/** Every commit with a row on `node`'s path or below it — ascending, memoised on the node. */
-export declare function subtreePositions(node: PathNode): readonly number[];
-/** The first index in an ascending list holding a value >= `value`. */
-export declare function lowerBound(sorted: readonly number[], value: number): number;
-/** The last value in an ascending list that is < `before`, or -1. */
-export declare function lastBefore(sorted: readonly number[], before: number): number;
-/** The values of an ascending list in the OPEN range (`after`, `before`). */
-export declare function between(sorted: readonly number[], after: number, before: number): readonly number[];
-/** The commits that can have written a key, split by what the writer rule still has to ask. */
-export interface WriterCandidates {
-    /** Commits with a row `'exact'` or `'inside'` the key — writers by the path alone. Ascending. */
-    readonly atOrInside: readonly number[];
-    /** Commits with a row `'around'` the key and none at or inside it — writers only if the value at the key changed. Ascending. */
-    readonly aroundOnly: readonly number[];
-}
-/** The path half of the writer rule over an index: every commit that can have written `key`. `O(depth + matches)`. */
-export declare function writerCandidates(index: WriterIndex, key: string): WriterCandidates;
-/** The ascending, de-duplicated union of ascending position lists. */
-export declare function ascendingUnion(lists: readonly (readonly number[])[]): number[];
-/**
- * Did this commit reach `key` ONLY through rows inside it — at least one row `'inside'` the key, and no
- * row on it or around it? Such a write changed part of the key's value, not the whole: the one test
- * behind every `'nested-rows'` code (a slice note, a causal edge's `basis`, `findLastWriterWithBasis`).
- */
-export declare function writesOnlyInside(bundle: CommitBundle, key: string): boolean;

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

@@ -1,227 +0,0 @@
-/**
- * keyPaths.ts — which rows of a commit log touch a state key. ONE answer (F3, 9.33.0).
- *
- * WHY THIS FILE EXISTS. A key query (`commitValueAt`, `findLastWriter`, `causalChain`, the slice
- * layer) asks "which rows wrote `key`?". Each reader used to answer with its own `row.path === key`,
- * so a row written INSIDE the key — `cfg␟b`, which every subflow seed of an object, every
- * outputMapper merge-back and every fork child's namespace produces — was invisible to all of
- * them, while the fold (`stateAt`, the live commit) applied it. The fold said `{a:1,b:2}`; the key
- * queries said "never written". Every reader now asks here.
- *
- * THE PATH HALF (this file, L0 — it imports only the path codec and types):
- *   - {@link relation} — how a row's path sits against a key's path. A segment prefix on the
- *     DELIM-joined path, the way RFC 6901 prefixes a JSON Pointer: `cfg` is a prefix of `cfg␟a`,
- *     never of `cfgX`. A row is `'exact'` (on the key), `'inside'` (below it — it wrote part of the
- *     key's value) or `'around'` (above it — it wrote a container that holds the key).
- *   - {@link buildWriterIndex} / {@link writerCandidates} — one pass over a log, then the rows that
- *     can have written a key, found through its top-level key instead of a scan.
- *
- * THE RULES (defined here; the fold is L1 and the log readers L3, so `commitLogUtils.ts` applies
- * them — `writersOf`, `findLastWriter`, `commitValueAt`):
- *   - THE WRITER RULE — commit `c` WRITES key `K` iff `c` has a row `'exact'` or `'inside'` `K`,
- *     or a row `'around'` `K` across which the value at `K` differs (compared over the whole commit,
- *     not row by row: a value that changes and changes back inside one commit was not written).
- *     A top-level key has no `'around'` rows, so for it the rule is the path check alone.
- *     Why not every `'around'` row: `$update('cfg', { list: [3] })` is a `merge` row on `cfg`, but
- *     it never reaches `cfg␟a` — counting it named the wrong writer of `cfg␟a`.
- *   - THE VALUE RULE — the value of `K` at commit `i` is the fold of EVERY row under `K`'s top-level
- *     key up to `i`, anchored at that key's last `set`/`delete`, read at `K`: the fold `stateAt`
- *     does, restricted to one top-level key. Top-level keys never interact under the step, so the
- *     restriction is exact. Folding only the rows that touch `K` is NOT: an array union
- *     (`deepSmartMerge`) dedups the whole array, so a sibling element written beside `a␟1` changes
- *     where a later merge on `a` leaves `a[1]`.
- *
- * @example
- * ```typescript
- * relation('cfg\u001Fb', 'cfg'); // 'inside' — the row wrote part of cfg
- * relation('cfg', 'cfg\u001Fa'); // 'around' — the row wrote the container cfg.a lives in
- * relation('cfgX', 'cfg');       // undefined — a different key, not a prefix match
- * ```
- */
-import { DELIM } from './paths.js';
-/**
- * The WORK every key query has done — rows indexed and scanned, fold steps, around-verdicts, trie and
- * ancestor steps, binary searches, a causal walk's own loops — summed across calls. A deterministic cost
- * measure: `test/lib/memory/boundary/key-query-scaling.test.ts` asserts a causal walk's work grows linearly
- * in the log by COUNTING it (a wall-clock ratio failed on a busy machine). Never read by the library; one
- * integer add per unit of work it already does. Here, at L0, so every layer that does that work can count it.
- */
-export const queryWork = { units: 0 };
-const DELIM_CODE = DELIM.charCodeAt(0);
-/**
- * How the row path `rowPath` sits against the key `key` — both DELIM-joined `TraceEntry.path`
- * strings (a top-level key is a one-segment path). `'exact'` when they are equal, `'inside'` when
- * the row is below the key, `'around'` when the row is above it, `undefined` when neither is a
- * segment prefix of the other.
- */
-export function relation(rowPath, key) {
-    if (rowPath === key)
-        return 'exact';
-    if (rowPath.length > key.length) {
-        return rowPath.charCodeAt(key.length) === DELIM_CODE && rowPath.startsWith(key) ? 'inside' : undefined;
-    }
-    return key.charCodeAt(rowPath.length) === DELIM_CODE && key.startsWith(rowPath) ? 'around' : undefined;
-}
-/** The top-level key a DELIM-joined path belongs to — its first segment. */
-export function rootOf(path) {
-    const cut = path.indexOf(DELIM);
-    return cut === -1 ? path : path.slice(0, cut);
-}
-function nodeOf(path) {
-    return { path, positions: [], totals: [], writes: [], children: new Map() };
-}
-/** Append `i` to an ascending list unless it is already its last element. */
-function pushOnce(list, i) {
-    if (list[list.length - 1] !== i)
-        list.push(i);
-}
-/**
- * One pass over `commitLog`: the path trie of every written path. Build it ONCE when a reader asks about
- * many keys (a causal walk, a forward slice) — or let `commitLogUtils · logModel` memoise it for a frozen log.
- */
-export function buildWriterIndex(commitLog) {
-    const roots = new Map();
-    for (let i = 0; i < commitLog.length; i++) {
-        const trace = commitLog[i].trace;
-        for (let row = 0; row < trace.length; row++) {
-            const { path, verb } = trace[row];
-            const segs = path.split(DELIM);
-            let node = roots.get(segs[0]);
-            if (node === undefined) {
-                node = nodeOf(segs[0]);
-                roots.set(segs[0], node);
-            }
-            for (let s = 1; s < segs.length; s++) {
-                let child = node.children.get(segs[s]);
-                if (child === undefined) {
-                    child = nodeOf(node.path + DELIM + segs[s]);
-                    node.children.set(segs[s], child);
-                }
-                node = child;
-            }
-            pushOnce(node.positions, i);
-            if (verb === 'set' || verb === 'delete')
-                pushOnce(node.totals, i);
-            if (verb !== 'delete')
-                pushOnce(node.writes, i);
-        }
-    }
-    return { roots };
-}
-/** Every path a row was written on, in trie order. */
-export function pathsWritten(index) {
-    const out = [];
-    const stack = [...index.roots.values()];
-    while (stack.length > 0) {
-        const node = stack.pop();
-        if (node.positions.length > 0)
-            out.push(node.path);
-        for (const child of node.children.values())
-            stack.push(child);
-    }
-    return out;
-}
-/** The node for `key`, or undefined when no row was written on it or below it. */
-export function nodeAt(index, key) {
-    const segs = key.split(DELIM);
-    queryWork.units += segs.length;
-    let node = index.roots.get(segs[0]);
-    for (let s = 1; node !== undefined && s < segs.length; s++)
-        node = node.children.get(segs[s]);
-    return node;
-}
-/** The nodes of `key`'s PROPER ancestors that exist in the index, top-level key first. */
-export function ancestorNodes(index, key) {
-    const segs = key.split(DELIM);
-    const out = [];
-    queryWork.units += segs.length;
-    let node = index.roots.get(segs[0]);
-    for (let s = 1; node !== undefined && s < segs.length; s++) {
-        out.push(node);
-        node = node.children.get(segs[s]);
-    }
-    return out;
-}
-/** Every commit with a row on `node`'s path or below it — ascending, memoised on the node. */
-export function subtreePositions(node) {
-    queryWork.units += 1;
-    if (node.subtree === undefined) {
-        if (node.children.size === 0)
-            node.subtree = node.positions;
-        else {
-            const lists = [node.positions];
-            for (const child of node.children.values())
-                lists.push(subtreePositions(child));
-            node.subtree = ascendingUnion(lists);
-            queryWork.units += node.subtree.length;
-        }
-    }
-    return node.subtree;
-}
-/** The first index in an ascending list holding a value >= `value`. */
-export function lowerBound(sorted, value) {
-    queryWork.units += 1;
-    let lo = 0;
-    let hi = sorted.length;
-    while (lo < hi) {
-        const mid = (lo + hi) >>> 1;
-        if (sorted[mid] < value)
-            lo = mid + 1;
-        else
-            hi = mid;
-    }
-    return lo;
-}
-/** The last value in an ascending list that is < `before`, or -1. */
-export function lastBefore(sorted, before) {
-    const at = lowerBound(sorted, before);
-    return at > 0 ? sorted[at - 1] : -1;
-}
-/** The values of an ascending list in the OPEN range (`after`, `before`). */
-export function between(sorted, after, before) {
-    const out = sorted.slice(lowerBound(sorted, after + 1), lowerBound(sorted, before));
-    queryWork.units += out.length;
-    return out;
-}
-/** The path half of the writer rule over an index: every commit that can have written `key`. `O(depth + matches)`. */
-export function writerCandidates(index, key) {
-    const node = nodeAt(index, key);
-    const written = node === undefined ? [] : subtreePositions(node);
-    const ancestors = ancestorNodes(index, key);
-    if (ancestors.length === 0)
-        return { atOrInside: written, aroundOnly: [] };
-    const already = new Set(written);
-    return {
-        atOrInside: written,
-        aroundOnly: ascendingUnion(ancestors.map((a) => a.positions)).filter((i) => !already.has(i)),
-    };
-}
-/** The ascending, de-duplicated union of ascending position lists. */
-export function ascendingUnion(lists) {
-    if (lists.length === 0)
-        return [];
-    if (lists.length === 1)
-        return [...lists[0]];
-    const all = new Set();
-    for (const list of lists)
-        for (const i of list)
-            all.add(i);
-    return [...all].sort((a, b) => a - b);
-}
-/**
- * Did this commit reach `key` ONLY through rows inside it — at least one row `'inside'` the key, and no
- * row on it or around it? Such a write changed part of the key's value, not the whole: the one test
- * behind every `'nested-rows'` code (a slice note, a causal edge's `basis`, `findLastWriterWithBasis`).
- */
-export function writesOnlyInside(bundle, key) {
-    let inside = false;
-    for (const t of bundle.trace) {
-        const r = relation(t.path, key);
-        if (r === 'exact' || r === 'around')
-            return false;
-        if (r === 'inside')
-            inside = true;
-    }
-    return inside;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyPaths.js","sourceRoot":"","sources":["../../../../src/lib/memory/keyPaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGnC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;AAKtC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,GAAW;IACnD,IAAI,OAAO,KAAK,GAAG;QAAE,OAAO,OAAO,CAAC;IACpC,IAAI,OAAO,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACzG,CAAC;IACD,OAAO,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AACzG,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,MAAM,CAAC,IAAY;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAChD,CAAC;AA+BD,SAAS,MAAM,CAAC,IAAY;IAC1B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;AAC9E,CAAC;AAED,6EAA6E;AAC7E,SAAS,QAAQ,CAAC,IAAc,EAAE,CAAS;IACzC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;QAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAAkC;IACjE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACjC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;YAC5C,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC/B,IAAI,IAAI,GAAyB,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACpD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvB,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YAC3B,CAAC;YACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACrC,IAAI,KAAK,GAAyB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACxB,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBACpC,CAAC;gBACD,IAAI,GAAG,KAAK,CAAC;YACf,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YAC5B,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,QAAQ;gBAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YAClE,IAAI,IAAI,KAAK,QAAQ;gBAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,CAAC;AACnB,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,YAAY,CAAC,KAAkB;IAC7C,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACxC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAc,CAAC;QACrC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,MAAM,CAAC,KAAkB,EAAE,GAAW;IACpD,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC9B,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC;IAC/B,IAAI,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,KAAK,SAAS,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE;QAAE,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9F,OAAO,IAAI,CAAC;AACd,CAAC;AAED,0FAA0F;AAC1F,MAAM,UAAU,aAAa,CAAC,KAAkB,EAAE,GAAW;IAC3D,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC9B,MAAM,GAAG,GAAe,EAAE,CAAC;IAC3B,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC;IAC/B,IAAI,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,KAAK,SAAS,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3D,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,gBAAgB,CAAC,IAAc;IAC7C,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC;IACrB,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAC/B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC;YAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;aACvD,CAAC;YACJ,MAAM,KAAK,GAA0B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACtD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;gBAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;YAChF,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;YACrC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC,OAAO,CAAC;AACtB,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,UAAU,CAAC,MAAyB,EAAE,KAAa;IACjE,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC;IACrB,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,IAAI,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC;IACvB,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC;QACf,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK;YAAE,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;;YACjC,EAAE,GAAG,GAAG,CAAC;IAChB,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,UAAU,CAAC,MAAyB,EAAE,MAAc;IAClE,MAAM,EAAE,GAAG,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,OAAO,CAAC,MAAyB,EAAE,KAAa,EAAE,MAAc;IAC9E,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpF,SAAS,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,CAAC;IAC9B,OAAO,GAAG,CAAC;AACb,CAAC;AAUD,sHAAsH;AACtH,MAAM,UAAU,gBAAgB,CAAC,KAAkB,EAAE,GAAW;IAC9D,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAChC,MAAM,OAAO,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACjE,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC5C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAC3E,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IACjC,OAAO;QACL,UAAU,EAAE,OAAO;QACnB,UAAU,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC7F,CAAC;AACJ,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,cAAc,CAAC,KAAqC;IAClE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAClC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,IAAI,IAAI,KAAK;QAAE,KAAK,MAAM,CAAC,IAAI,IAAI;YAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3D,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAoB,EAAE,GAAW;IAChE,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAClD,IAAI,CAAC,KAAK,QAAQ;YAAE,MAAM,GAAG,IAAI,CAAC;IACpC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * keyPaths.ts — which rows of a commit log touch a state key. ONE answer (F3, 9.33.0).\n *\n * WHY THIS FILE EXISTS. A key query (`commitValueAt`, `findLastWriter`, `causalChain`, the slice\n * layer) asks \"which rows wrote `key`?\". Each reader used to answer with its own `row.path === key`,\n * so a row written INSIDE the key — `cfg␟b`, which every subflow seed of an object, every\n * outputMapper merge-back and every fork child's namespace produces — was invisible to all of\n * them, while the fold (`stateAt`, the live commit) applied it. The fold said `{a:1,b:2}`; the key\n * queries said \"never written\". Every reader now asks here.\n *\n * THE PATH HALF (this file, L0 — it imports only the path codec and types):\n *   - {@link relation} — how a row's path sits against a key's path. A segment prefix on the\n *     DELIM-joined path, the way RFC 6901 prefixes a JSON Pointer: `cfg` is a prefix of `cfg␟a`,\n *     never of `cfgX`. A row is `'exact'` (on the key), `'inside'` (below it — it wrote part of the\n *     key's value) or `'around'` (above it — it wrote a container that holds the key).\n *   - {@link buildWriterIndex} / {@link writerCandidates} — one pass over a log, then the rows that\n *     can have written a key, found through its top-level key instead of a scan.\n *\n * THE RULES (defined here; the fold is L1 and the log readers L3, so `commitLogUtils.ts` applies\n * them — `writersOf`, `findLastWriter`, `commitValueAt`):\n *   - THE WRITER RULE — commit `c` WRITES key `K` iff `c` has a row `'exact'` or `'inside'` `K`,\n *     or a row `'around'` `K` across which the value at `K` differs (compared over the whole commit,\n *     not row by row: a value that changes and changes back inside one commit was not written).\n *     A top-level key has no `'around'` rows, so for it the rule is the path check alone.\n *     Why not every `'around'` row: `$update('cfg', { list: [3] })` is a `merge` row on `cfg`, but\n *     it never reaches `cfg␟a` — counting it named the wrong writer of `cfg␟a`.\n *   - THE VALUE RULE — the value of `K` at commit `i` is the fold of EVERY row under `K`'s top-level\n *     key up to `i`, anchored at that key's last `set`/`delete`, read at `K`: the fold `stateAt`\n *     does, restricted to one top-level key. Top-level keys never interact under the step, so the\n *     restriction is exact. Folding only the rows that touch `K` is NOT: an array union\n *     (`deepSmartMerge`) dedups the whole array, so a sibling element written beside `a␟1` changes\n *     where a later merge on `a` leaves `a[1]`.\n *\n * @example\n * ```typescript\n * relation('cfg\\u001Fb', 'cfg'); // 'inside' — the row wrote part of cfg\n * relation('cfg', 'cfg\\u001Fa'); // 'around' — the row wrote the container cfg.a lives in\n * relation('cfgX', 'cfg');       // undefined — a different key, not a prefix match\n * ```\n */\n\nimport { DELIM } from './paths.js';\nimport type { CommitBundle } from './types.js';\n\n/**\n * The WORK every key query has done — rows indexed and scanned, fold steps, around-verdicts, trie and\n * ancestor steps, binary searches, a causal walk's own loops — summed across calls. A deterministic cost\n * measure: `test/lib/memory/boundary/key-query-scaling.test.ts` asserts a causal walk's work grows linearly\n * in the log by COUNTING it (a wall-clock ratio failed on a busy machine). Never read by the library; one\n * integer add per unit of work it already does. Here, at L0, so every layer that does that work can count it.\n */\nexport const queryWork = { units: 0 };\n\n/** How a row's path sits against a key's path. `undefined` from {@link relation} means disjoint. */\nexport type PathRelation = 'exact' | 'inside' | 'around';\n\nconst DELIM_CODE = DELIM.charCodeAt(0);\n\n/**\n * How the row path `rowPath` sits against the key `key` — both DELIM-joined `TraceEntry.path`\n * strings (a top-level key is a one-segment path). `'exact'` when they are equal, `'inside'` when\n * the row is below the key, `'around'` when the row is above it, `undefined` when neither is a\n * segment prefix of the other.\n */\nexport function relation(rowPath: string, key: string): PathRelation | undefined {\n  if (rowPath === key) return 'exact';\n  if (rowPath.length > key.length) {\n    return rowPath.charCodeAt(key.length) === DELIM_CODE && rowPath.startsWith(key) ? 'inside' : undefined;\n  }\n  return key.charCodeAt(rowPath.length) === DELIM_CODE && key.startsWith(rowPath) ? 'around' : undefined;\n}\n\n/** The top-level key a DELIM-joined path belongs to — its first segment. */\nexport function rootOf(path: string): string {\n  const cut = path.indexOf(DELIM);\n  return cut === -1 ? path : path.slice(0, cut);\n}\n\n/**\n * One written path in a {@link WriterIndex} — a node of the path TRIE built over a log. A node exists for\n * every written path and every prefix of one.\n */\nexport interface PathNode {\n  /** The DELIM-joined path this node stands for. */\n  readonly path: string;\n  /** ARRAY positions of the commits with a row exactly on this path — ascending, one per commit. */\n  readonly positions: number[];\n  /** The subset of {@link positions} whose row here is a `set` or a `delete` (it decides the value alone). */\n  readonly totals: number[];\n  /** Positions of commits whose row with a non-`delete` verb sits on this path (the rest are deletes only). */\n  readonly writes: number[];\n  /** The next segment → its node. */\n  readonly children: Map<string, PathNode>;\n  /** Memo of {@link subtreePositions}. */\n  subtree?: readonly number[];\n}\n\n/**\n * The positions in a log where each written path was written: a path trie per top-level key. Built in ONE\n * pass (`O(total path segments)`); a key's candidates then cost `O(depth + matches)` — its node, its\n * ancestors, its subtree — never a scan of every path under its top-level key.\n */\nexport interface WriterIndex {\n  /** Every top-level key → the root of its trie. */\n  readonly roots: ReadonlyMap<string, PathNode>;\n}\n\nfunction nodeOf(path: string): PathNode {\n  return { path, positions: [], totals: [], writes: [], children: new Map() };\n}\n\n/** Append `i` to an ascending list unless it is already its last element. */\nfunction pushOnce(list: number[], i: number): void {\n  if (list[list.length - 1] !== i) list.push(i);\n}\n\n/**\n * One pass over `commitLog`: the path trie of every written path. Build it ONCE when a reader asks about\n * many keys (a causal walk, a forward slice) — or let `commitLogUtils · logModel` memoise it for a frozen log.\n */\nexport function buildWriterIndex(commitLog: readonly CommitBundle[]): WriterIndex {\n  const roots = new Map<string, PathNode>();\n  for (let i = 0; i < commitLog.length; i++) {\n    const trace = commitLog[i].trace;\n    for (let row = 0; row < trace.length; row++) {\n      const { path, verb } = trace[row];\n      const segs = path.split(DELIM);\n      let node: PathNode | undefined = roots.get(segs[0]);\n      if (node === undefined) {\n        node = nodeOf(segs[0]);\n        roots.set(segs[0], node);\n      }\n      for (let s = 1; s < segs.length; s++) {\n        let child: PathNode | undefined = node.children.get(segs[s]);\n        if (child === undefined) {\n          child = nodeOf(node.path + DELIM + segs[s]);\n          node.children.set(segs[s], child);\n        }\n        node = child;\n      }\n      pushOnce(node.positions, i);\n      if (verb === 'set' || verb === 'delete') pushOnce(node.totals, i);\n      if (verb !== 'delete') pushOnce(node.writes, i);\n    }\n  }\n  return { roots };\n}\n\n/** Every path a row was written on, in trie order. */\nexport function pathsWritten(index: WriterIndex): string[] {\n  const out: string[] = [];\n  const stack = [...index.roots.values()];\n  while (stack.length > 0) {\n    const node = stack.pop() as PathNode;\n    if (node.positions.length > 0) out.push(node.path);\n    for (const child of node.children.values()) stack.push(child);\n  }\n  return out;\n}\n\n/** The node for `key`, or undefined when no row was written on it or below it. */\nexport function nodeAt(index: WriterIndex, key: string): PathNode | undefined {\n  const segs = key.split(DELIM);\n  queryWork.units += segs.length;\n  let node = index.roots.get(segs[0]);\n  for (let s = 1; node !== undefined && s < segs.length; s++) node = node.children.get(segs[s]);\n  return node;\n}\n\n/** The nodes of `key`'s PROPER ancestors that exist in the index, top-level key first. */\nexport function ancestorNodes(index: WriterIndex, key: string): PathNode[] {\n  const segs = key.split(DELIM);\n  const out: PathNode[] = [];\n  queryWork.units += segs.length;\n  let node = index.roots.get(segs[0]);\n  for (let s = 1; node !== undefined && s < segs.length; s++) {\n    out.push(node);\n    node = node.children.get(segs[s]);\n  }\n  return out;\n}\n\n/** Every commit with a row on `node`'s path or below it — ascending, memoised on the node. */\nexport function subtreePositions(node: PathNode): readonly number[] {\n  queryWork.units += 1;\n  if (node.subtree === undefined) {\n    if (node.children.size === 0) node.subtree = node.positions;\n    else {\n      const lists: (readonly number[])[] = [node.positions];\n      for (const child of node.children.values()) lists.push(subtreePositions(child));\n      node.subtree = ascendingUnion(lists);\n      queryWork.units += node.subtree.length;\n    }\n  }\n  return node.subtree;\n}\n\n/** The first index in an ascending list holding a value >= `value`. */\nexport function lowerBound(sorted: readonly number[], value: number): number {\n  queryWork.units += 1;\n  let lo = 0;\n  let hi = sorted.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1;\n    if (sorted[mid] < value) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\n/** The last value in an ascending list that is < `before`, or -1. */\nexport function lastBefore(sorted: readonly number[], before: number): number {\n  const at = lowerBound(sorted, before);\n  return at > 0 ? sorted[at - 1] : -1;\n}\n\n/** The values of an ascending list in the OPEN range (`after`, `before`). */\nexport function between(sorted: readonly number[], after: number, before: number): readonly number[] {\n  const out = sorted.slice(lowerBound(sorted, after + 1), lowerBound(sorted, before));\n  queryWork.units += out.length;\n  return out;\n}\n\n/** The commits that can have written a key, split by what the writer rule still has to ask. */\nexport interface WriterCandidates {\n  /** Commits with a row `'exact'` or `'inside'` the key — writers by the path alone. Ascending. */\n  readonly atOrInside: readonly number[];\n  /** Commits with a row `'around'` the key and none at or inside it — writers only if the value at the key changed. Ascending. */\n  readonly aroundOnly: readonly number[];\n}\n\n/** The path half of the writer rule over an index: every commit that can have written `key`. `O(depth + matches)`. */\nexport function writerCandidates(index: WriterIndex, key: string): WriterCandidates {\n  const node = nodeAt(index, key);\n  const written = node === undefined ? [] : subtreePositions(node);\n  const ancestors = ancestorNodes(index, key);\n  if (ancestors.length === 0) return { atOrInside: written, aroundOnly: [] };\n  const already = new Set(written);\n  return {\n    atOrInside: written,\n    aroundOnly: ascendingUnion(ancestors.map((a) => a.positions)).filter((i) => !already.has(i)),\n  };\n}\n\n/** The ascending, de-duplicated union of ascending position lists. */\nexport function ascendingUnion(lists: readonly (readonly number[])[]): number[] {\n  if (lists.length === 0) return [];\n  if (lists.length === 1) return [...lists[0]];\n  const all = new Set<number>();\n  for (const list of lists) for (const i of list) all.add(i);\n  return [...all].sort((a, b) => a - b);\n}\n\n/**\n * Did this commit reach `key` ONLY through rows inside it — at least one row `'inside'` the key, and no\n * row on it or around it? Such a write changed part of the key's value, not the whole: the one test\n * behind every `'nested-rows'` code (a slice note, a causal edge's `basis`, `findLastWriterWithBasis`).\n */\nexport function writesOnlyInside(bundle: CommitBundle, key: string): boolean {\n  let inside = false;\n  for (const t of bundle.trace) {\n    const r = relation(t.path, key);\n    if (r === 'exact' || r === 'around') return false;\n    if (r === 'inside') inside = true;\n  }\n  return inside;\n}\n"]}