footprintjs 9.46.0 → 9.46.1

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

@@ -3,10 +3,12 @@
  *
  * Like a stack frame in a compiler/runtime:
  * - A RecordFrame — the record half (C3): the heap, the address, the
- *   first-touch base, the lazy transaction buffer, the readKeys list
+ *   first-touch base, the lazy transaction buffer and every write's scrub
+ *   (C4), the readKeys list
  * - Links to parent/child/next contexts (call stack frames)
  * - What belongs to a stage inside a run: retention of reads and writes, the
- *   redaction verdict per write, the dev-mode warnings, the commit observer
+ *   redaction decision per write (`redaction.ts · decideWrite`) and where the
+ *   frame writes (`runAddress.ts`), the dev-mode warnings, the commit observer
  * - DiagnosticCollector for logs, errors, metrics
  */
 import { type DiagnosticChannel, DiagnosticCollector } from './DiagnosticCollector.js';
@@ -206,10 +208,10 @@ export declare class StageContext {
      * and stores nothing under `'off'` (entry skipped entirely — nothing to
      * leak). A field-level verdict scrubs a clone BEFORE the dial sees it, so
      * a summary preview can never show the secret either. The verdict is the
-     * one `stageWrite` asked the rule for BEFORE staging, carried to commit
-     * with the value. The staged write itself is unaffected — redaction of
-     * the committed payload is handled by the transaction buffer's
-     * `redactedPaths`.
+     * one `stageWrite` decided BEFORE staging, carried to commit with the
+     * value. The staged write itself is unaffected — redaction of the
+     * committed payload is the record frame's scrub of that write
+     * (`RecordFrame · write`, then `scrub.ts` at commit).
      */
     private trackWrite;
     /**
@@ -243,14 +245,19 @@ export declare class StageContext {
     /**
      * THE ONE FUNNEL every staged write passes through — facade writes AND
      * the paths that bypass the facade (subflow seed, `outputMapper`
-     * merge-back, resume re-seed). The ONE decision is made here: an explicit
-     * per-call flag makes the value secret outright (and marks the key for the
-     * rest of the run, the declare-once contract); otherwise the installed
-     * rule decides from the user-level path. It stages the write, registers
-     * the redacted paths the commit log and mirror will scrub (whole key, or
-     * the fields inside the value), and keeps the run's marked-keys set in
-     * step (a whole verdict marks its key; a delete clears the mark). Returns
-     * the verdict so the caller retains and reports under the same decision.
+     * merge-back, resume re-seed). Two owners (C4): the run's rule DECIDES,
+     * the record frame WRITES the verdict's bytes, in four steps
+     * (`redaction.ts`, "The write decision"):
+     *   1. the verdict — `decideWrite`, under the rule active as the write begins;
+     *   2. identity inheritance — `inheritByIdentity`, against this frame's
+     *      selected reads as they stand after step 1;
+     *   3. the bytes — `RecordFrame · write`, the op and its scrub (the whole
+     *      value, or the fields inside it);
+     *   4. the marks — `markStagedWrite`, only once the write staged, so a
+     *      write that fails to stage marks nothing.
+     * Each step reads the rule (and the selected reads) when it acts, as this
+     * funnel always did. Returns the verdict so the caller retains and reports
+     * under the same decision.
      */
     private stageWrite;
     /**