foottrace 1.0.3 → 1.1.0

package/dist/lib/ids/attemptId.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * attemptId — the address of one attempt under a stage execution.
+ *
+ * Format:
+ *   <runtimeStageId>@<n>              attempt n of the stage execution      'charge#4@2'
+ *   <runtimeStageId>@<n>.<k>@<m>      attempt m of the k-th call made        'charge#4@2.1@3'
+ *                                     during stage attempt n
+ *
+ * Every number after the runtimeStageId is a positive integer, counted from 1: attempt 1 is the first
+ * try, call 1 the first call the stage attempt made. Written without leading zeros, so one attempt has
+ * one spelling and an id is a safe join key.
+ *
+ * PARSED FROM THE RIGHT. A runtimeStageId always ends in `#<execution index>`, and the suffix grammar
+ * holds no `#`, so the LAST `#` of an attempt id is its execution delimiter whatever the stage id
+ * contains — `@`, `.` and `~` stay legal in stage ids, and no byte is newly reserved (the id doors'
+ * refusal, FootPrint's `refuseReservedId`, is untouched). The delimiter is read from the grammar's one
+ * owner, `runtimeStageId.ts`.
+ *
+ * Imports nothing but the runtime-ID grammar: a leaf of the record, checked by the package fence.
+ *
+ * @example
+ * ```typescript
+ * buildAttemptId('charge#4', 2);                              // 'charge#4@2'
+ * buildAttemptId('charge#4', 2, { ordinal: 1, attempt: 3 });  // 'charge#4@2.1@3'
+ * parseAttemptId('sf/v1.2@x#7@3'); // { runtimeStageId: 'sf/v1.2@x#7', attempt: 3 }
+ * parseAttemptId('charge#4');      // undefined — a stage execution, not an attempt
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAttemptId = exports.buildAttemptId = void 0;
+const runtimeStageId_js_1 = require("./runtimeStageId.js");
+/**
+ * What follows the last `#`: the execution index, `@` and the attempt, then — for a call — `.`, the
+ * call's ordinal, `@` and the call's attempt. Counts are canonical positive integers.
+ */
+const AFTER_EXECUTION_DELIMITER = /^(\d+)@([1-9]\d*)(?:\.([1-9]\d*)@([1-9]\d*))?$/;
+const EXECUTION_INDEX = /^\d+$/;
+/** True when `id` ends in `#<digits>` — the one shape every runtimeStageId has. */
+function endsInExecutionIndex(id) {
+    const at = id.lastIndexOf(runtimeStageId_js_1.EXECUTION_DELIMITER);
+    return at !== -1 && EXECUTION_INDEX.test(id.slice(at + 1));
+}
+/** Refuse a count the parser could not give back: a positive safe integer, or a `RangeError`. */
+function requireCount(name, value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new RangeError(`buildAttemptId: ${name} must be a positive integer (counted from 1), got ${String(value)}`);
+    }
+}
+/**
+ * Build the id of one attempt.
+ *
+ * @param runtimeStageId The stage execution the attempt belongs to (`[subflowPath/]stageId#index`).
+ * @param attempt The stage attempt, from 1.
+ * @param call For an attempt of a call made inside the stage attempt: the call's `ordinal` (1 for the
+ *   first call that stage attempt made) and its own `attempt` (from 1).
+ * @throws TypeError when `runtimeStageId` does not end in `#<execution index>`, and RangeError when a
+ *   count is not a positive integer — what `parseAttemptId` could not give back is never written.
+ */
+function buildAttemptId(runtimeStageId, attempt, call) {
+    if (typeof runtimeStageId !== 'string' || !endsInExecutionIndex(runtimeStageId)) {
+        throw new TypeError(`buildAttemptId: ${JSON.stringify(runtimeStageId)} is not a runtimeStageId (it must end in #<execution index>)`);
+    }
+    requireCount('attempt', attempt);
+    if (call === undefined)
+        return `${runtimeStageId}@${attempt}`;
+    requireCount('call ordinal', call.ordinal);
+    requireCount('call attempt', call.attempt);
+    return `${runtimeStageId}@${attempt}.${call.ordinal}@${call.attempt}`;
+}
+exports.buildAttemptId = buildAttemptId;
+/**
+ * Parse an attempt id into its parts, or `undefined` when `id` is not one (a bare runtimeStageId, a
+ * count of 0, a leading zero, a missing part). Never throws.
+ *
+ * `parseAttemptId(buildAttemptId(...parts))` gives the parts back, whatever the stage id contains.
+ */
+function parseAttemptId(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const at = id.lastIndexOf(runtimeStageId_js_1.EXECUTION_DELIMITER);
+    if (at === -1)
+        return undefined;
+    const parts = AFTER_EXECUTION_DELIMITER.exec(id.slice(at + 1));
+    if (!parts)
+        return undefined;
+    const [, index, attempt, ordinal, callAttempt] = parts;
+    const counts = [attempt, ordinal, callAttempt].filter((n) => n !== undefined).map(Number);
+    if (!counts.every(Number.isSafeInteger))
+        return undefined;
+    const runtimeStageId = id.slice(0, at + 1 + index.length);
+    if (ordinal === undefined)
+        return { runtimeStageId, attempt: counts[0] };
+    return { runtimeStageId, attempt: counts[0], call: { ordinal: counts[1], attempt: counts[2] } };
+}
+exports.parseAttemptId = parseAttemptId;

package/dist/lib/memory/EventLog.js

@@ -25,11 +25,94 @@
  * contract for state) and a `SharedArrayBuffer` (every copy shares its memory). A frozen RegExp's
  * `lastIndex` is read-only, so a `/g` or `/y` regex read from a bundle throws when `exec` or
  * `replace` advance it.
+ *
+ * A SINK (1.1.0, optional). `new EventLog(base, { sink, address, meta? })` also hands every entry to a
+ * `RecordSink` AS IT LANDS (`sink.ts`): `opened` from the constructor (the base, as the sink's own
+ * copy), `commit` from `record` after the bundle is frozen and appended (the bundle as served),
+ * `note` from `note`, `closed` from `close`. The log's own record never depends on the sink: the
+ * bundle is in `steps` before the sink sees it, and nothing the sink does reaches the writer — a
+ * throw, a rejected promise or an entry the log refuses to send (a `note` whose data is not a plain
+ * object that survives `structuredClone`) is counted (`sinkFailures`) and reported to
+ * `sink.onFailure`, and the writer goes on; a `meta` that will not copy is lost on its own and its
+ * entry still goes. Without a sink, nothing here runs: the one-argument log writes the same bytes,
+ * and has the same own fields, it always did.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventLog = void 0;
 const freeze_js_1 = require("../capture/freeze.js");
+const sink_js_1 = require("./sink.js");
 const utils_js_1 = require("./utils.js");
+/** True when `value` has a callable `then` — an adapter that answered with a promise. */
+function isThenable(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value !== null &&
+        typeof value.then === 'function');
+}
+/**
+ * The address, copied segment by segment and frozen — the log's identity cannot be edited through the
+ * caller's object, and a path with a hole or a non-string segment is refused rather than copied as one.
+ */
+function frozenAddress(address) {
+    const { logRunId, drillPath } = (address ?? {});
+    const refused = () => new TypeError('EventLog: a sink needs an address — { logRunId: string, drillPath: string[] }');
+    if (typeof logRunId !== 'string' || !Array.isArray(drillPath))
+        throw refused();
+    const segments = [];
+    for (let i = 0; i < drillPath.length; i++) {
+        const segment = drillPath[i];
+        if (typeof segment !== 'string')
+            throw refused();
+        segments.push(segment);
+    }
+    return Object.freeze({ logRunId, drillPath: Object.freeze(segments) });
+}
+/** A writer's payload as the sink keeps it: a plain object, copied — or a `TypeError` naming `field`. */
+function copiedPayload(value, field) {
+    if (!(0, sink_js_1.isEntryObject)(value))
+        throw new TypeError(`EventLog: ${field} must be a plain object`);
+    return structuredClone(value);
+}
+/**
+ * The entry with its `meta` copied — or, when `meta` cannot be copied, the entry WITHOUT it and the
+ * error: the structural facts (the base, how the log ended, its length) still go; only `meta` is lost.
+ */
+function withCopiedMeta(entry) {
+    if (entry.meta === undefined)
+        return { ready: entry };
+    try {
+        return { ready: { ...entry, meta: copiedPayload(entry.meta, 'meta') } };
+    }
+    catch (error) {
+        const { meta: _dropped, ...rest } = entry;
+        return { ready: rest, dropped: error };
+    }
+}
+/**
+ * The entry as the sink may keep it: a payload checked and copied (the writer keeps its own object),
+ * the bundle served. `dropped` is a `meta` that could not be copied (the entry goes without it). Throws
+ * when the entry itself cannot be sent; the caller counts it as a lost entry.
+ */
+function detached(entry) {
+    switch (entry.kind) {
+        case 'opened':
+            return withCopiedMeta(entry);
+        case 'commit':
+            return { ready: { ...entry, bundle: (0, freeze_js_1.serveRecord)(entry.bundle) } };
+        case 'note':
+            if (typeof entry.note !== 'string')
+                throw new TypeError('EventLog.note: kind must be a string');
+            return { ready: { ...entry, data: copiedPayload(entry.data, 'note data') } };
+        case 'closed':
+            if (!sink_js_1.LOG_OUTCOMES.includes(entry.outcome)) {
+                throw new TypeError(`EventLog.close: outcome must be ${sink_js_1.LOG_OUTCOMES.join(', ')}`);
+            }
+            return withCopiedMeta(entry);
+    }
+}
+/** Swallows a rejection nobody waits for. */
+function ignore() {
+    // A failure report that fails changes nothing: the loss is already counted.
+}
 class EventLog {
     /** Base snapshot BEFORE the first stage mutates anything. */
     base;
@@ -37,12 +120,39 @@ class EventLog {
     steps = [];
     sourceAddress;
     sourceAddressRetired = false;
-    constructor(initialMemory) {
+    /**
+     * @param initialMemory The fold base — the state before the first commit (copied).
+     * @param options With a `sink`: every entry goes to it as it lands, under `address` — which also
+     *   becomes this log's {@link address} — and `meta` rides the `opened` entry. The sink is told
+     *   `opened` before the constructor returns.
+     * @throws TypeError when `options` names no sink, a malformed address, or a base that is not a plain
+     *   object (the `opened` entry carries it) — a writer's mistake, refused at the door. Nothing the sink
+     *   itself does is ever thrown.
+     */
+    constructor(initialMemory, options) {
         // Normalised to an object: the base is a STATE, and every fold over it
         // (`materialise`, `stateAt`) applies path writes to it. `undefined` —
         // what a run with no `initialContext` used to store here — made every
         // one of those folds throw on the first `set`.
         this.base = initialMemory === undefined ? {} : structuredClone(initialMemory);
+        if (options === undefined)
+            return;
+        if (!(0, sink_js_1.isEntryObject)(options.sink))
+            throw new TypeError('EventLog: options.sink must be a RecordSink');
+        if (!(0, sink_js_1.isEntryObject)(this.base)) {
+            throw new TypeError('EventLog: a log that writes to a sink needs a plain-object base — its opened entry carries it');
+        }
+        const address = frozenAddress(options.address);
+        this.sourceAddress = address;
+        this.sink = options.sink;
+        this.lostEntries = 0;
+        this.send({
+            kind: 'opened',
+            address,
+            at: Date.now(),
+            initialState: this.getInitialState(),
+            ...(options.meta === undefined ? {} : { meta: options.meta }),
+        });
     }
     /**
      * The fold BASE — the state as it stood before the first commit.
@@ -99,6 +209,124 @@ class EventLog {
         bundle.idx = this.steps.length;
         (0, freeze_js_1.freezeRecord)(bundle, 'indices');
         this.steps.push(bundle);
+        if (this.sink !== undefined)
+            this.send({ kind: 'commit', address: this.sourceAddress, at: Date.now(), bundle });
+    }
+    /**
+     * Note something beside the log, in the sink, as it happens — for evidence that must survive a run
+     * that never closes (an attempt that ended, before the next one starts). `kind` and `data` are the
+     * writer's: opaque to the record. Notes never enter the log's bundles, so the log's bytes are the
+     * same with or without them. Without a sink, nothing happens.
+     *
+     * Never throws: a `kind` that is not a string, `data` that is not a plain object surviving
+     * `structuredClone`, or a sink that fails is counted in {@link sinkFailures} and reported to
+     * `sink.onFailure`. The sink keeps its own copy of `data`.
+     */
+    note(kind, data) {
+        if (this.sink === undefined)
+            return;
+        this.send({ kind: 'note', address: this.sourceAddress, at: Date.now(), note: kind, data });
+    }
+    /**
+     * Tell the sink this log ended — `outcome` and, for the reader's check that the stored log is
+     * whole, how many commits it holds now. `meta` rides the entry, copied. Without a sink, nothing
+     * happens. The log itself stays as it is: a later `record` still lands, and still reaches the sink
+     * (a reader then reads the log as not complete until it is closed again).
+     *
+     * Never throws: an unknown outcome, a `meta` that is not a plain object surviving `structuredClone`,
+     * or a sink that fails is counted in {@link sinkFailures} and reported to `sink.onFailure`.
+     */
+    close(outcome, meta) {
+        if (this.sink === undefined)
+            return;
+        this.send({
+            kind: 'closed',
+            address: this.sourceAddress,
+            at: Date.now(),
+            outcome,
+            commits: this.steps.length,
+            ...(meta === undefined ? {} : { meta }),
+        });
+    }
+    /**
+     * How many entries the sink did not take: a sink method that threw or whose promise rejected, and an
+     * entry the log refused to send — plus each `meta` the log could not copy (that entry went without
+     * it). Counted as each happens (a rejection, when it settles); 0 without a sink. The stored record
+     * says the same from its side: a missing commit is a gap.
+     */
+    get sinkFailures() {
+        return this.lostEntries ?? 0;
+    }
+    /**
+     * One entry to the sink. Nothing here reaches the writer: a refusal, a throw or a rejection is a lost
+     * entry; a `meta` that cannot be copied is lost on its own — counted and reported — and the entry goes
+     * without it.
+     */
+    send(entry) {
+        const sink = this.sink;
+        if (sink === undefined)
+            return;
+        let sent = entry;
+        try {
+            const { ready, dropped } = detached(entry);
+            sent = Object.freeze(ready);
+            if (dropped !== undefined)
+                this.lost(sink, entry, dropped);
+            const returned = (0, sink_js_1.sendEntry)(sink, sent);
+            if (isThenable(returned))
+                this.watch(sink, sent, returned);
+        }
+        catch (error) {
+            this.lost(sink, sent, error);
+        }
+    }
+    /**
+     * Count the rejection of an adapter's promise once. A native promise is watched through the real
+     * `Promise.prototype.then` (an own `then` on it is not trusted); any other thenable is adopted into a
+     * fresh promise first, whose settling functions run once. Either way the rejection is handled.
+     */
+    watch(sink, entry, returned) {
+        let counted = false;
+        const onRejected = (error) => {
+            if (counted)
+                return;
+            counted = true;
+            this.lost(sink, entry, error);
+        };
+        if (returned instanceof Promise)
+            Promise.prototype.then.call(returned, undefined, onRejected);
+        else
+            new Promise((resolve) => resolve(returned)).then(undefined, onRejected);
+    }
+    /**
+     * Count a lost entry and tell the sink's `onFailure`, if it listens; a report that fails is ignored.
+     * A loss caused while `onFailure` runs — until the promise it returns settles, when it returns one —
+     * (it wrote to this log again, through the same failing sink) is counted and not reported again: one
+     * report deep, never a runaway.
+     */
+    lost(sink, entry, error) {
+        this.lostEntries = (this.lostEntries ?? 0) + 1;
+        if (this.reporting === true)
+            return;
+        this.reporting = true;
+        let pending = false;
+        try {
+            const reported = sink.onFailure?.({ entry, error });
+            if (isThenable(reported)) {
+                pending = true;
+                const done = () => {
+                    this.reporting = false;
+                };
+                new Promise((resolve) => resolve(reported)).then(done, done);
+            }
+        }
+        catch {
+            ignore();
+        }
+        finally {
+            if (!pending)
+                this.reporting = false;
+        }
     }
     /**
      * Every recorded commit bundle, AS SERVED (9.44.2): a new array each call; a bundle freezing sealed
@@ -122,7 +350,10 @@ class EventLog {
     get length() {
         return this.steps.length;
     }
-    /** Immutable identity of this log, absent until the engine binds it. */
+    /**
+     * Immutable identity of this log: the sink's address when the log was built with one, otherwise
+     * absent until the engine binds it.
+     */
     get address() {
         return this.sourceAddress;
     }
@@ -138,8 +369,16 @@ class EventLog {
             return undefined;
         return Object.freeze({ runId, ...this.sourceAddress, committedThroughIdx: this.steps.length - 1 });
     }
-    /** Wipes history (useful for test resets). */
+    /**
+     * Wipes history (useful for test resets).
+     *
+     * @throws Error on a log built with a sink: what the sink stored cannot be wiped, and a second
+     *   history under the same address would read back as one corrupted log. Start a fresh EventLog.
+     */
     clear() {
+        if (this.sink !== undefined) {
+            throw new Error('EventLog.clear: this log writes to a sink, and a stored record cannot be wiped — use a new EventLog');
+        }
         this.steps = [];
         // A reset prefix cannot reuse old coordinates, even if another stage of
         // the SAME leg binds it again. Keep clear's data behavior, but retire

package/dist/lib/memory/honesty.js

@@ -24,10 +24,11 @@
  *     alias of `foottrace` 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.
+ * NO OBJECT GAINS A FIELD from being registered. Four signals carry no code of their own — a
+ * `LogGap` (`'log-gap'`), `CausalNode.incompleteSources` (`'incomplete-sources'`),
+ * `FoldedState.redacted` / `redactedPaths` (`'redacted'`) and an entry of `StoredRecord.unread`
+ * (`'unread-entry'`, 1.1.0) — 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
@@ -84,6 +85,8 @@ exports.HONESTY_CODES = Object.freeze({
     '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.',
+    // ── an entry a sink stored that no log could hold — `StoredRecord.unread` (1.1.0) ─
+    'unread-entry': "An entry a sink stored was not read into any log (it could not be read as an opened, commit, note or closed entry, it lay past one of the reader's limits, or another entry holds its place), so whatever it said (a base, a commit, a note or how the log ended) is not in the record read back.",
     // ── 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 ─

package/dist/lib/memory/sink.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * sink.ts — the record's sink port: where a log's entries go AS THEY LAND, so a run that never ends
+ * still leaves its record behind.
+ *
+ * A log that is given a sink (`new EventLog(base, { sink, address })`) hands it four kinds of entry,
+ * each stamped with the log's address and the time it was written (`at`, epoch ms):
+ *
+ *   - `opened` — once, from the constructor: the fold base (`initialState`, the sink's own copy);
+ *   - `commit` — per `record()`, AFTER the bundle is frozen: the log's own bundle, as served;
+ *   - `note`   — per `note(kind, data)`: something the writer wants kept beside the log, as it happens;
+ *   - `closed` — per `close(outcome)`: how the log ended, and how many commits it held then (`commits`).
+ *
+ * These are RECORD facts. What the writer means by them rides `meta` (on `opened` / `closed`) and a
+ * note's `kind` and `data`: opaque here — stored and handed back, never read or interpreted. Nothing in
+ * this file names an engine.
+ *
+ * THE STORED FORM. A sink stores each entry as a {@link RecordEntry}: the method's entry plus the
+ * method's name as `kind`. A note's own kind cannot also be called `kind`, so it is stored as `note`.
+ * `memorySink` is the reference adapter; `readStoredRecord` (`foottrace`) reads the entries back.
+ *
+ * @example
+ * ```typescript
+ * import { EventLog, memorySink } from 'foottrace/write';
+ * import { readStoredRecord } from 'foottrace';
+ *
+ * const sink = memorySink();
+ * const log = new EventLog({ count: 0 }, { sink, address: { logRunId: 'run-1', drillPath: [] } });
+ * log.note('attempt', { attempt: 1, outcome: 'failed' });
+ * // … the process dies here: no `closed` entry …
+ * readStoredRecord(sink.entries).root('run-1')?.complete; // false — and its note is still there
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorySink = exports.sendEntry = exports.isEntryObject = exports.LOG_OUTCOMES = void 0;
+const freeze_js_1 = require("../capture/freeze.js");
+/** The outcomes a `closed` entry may carry, in one place for the writer's and the reader's checks. */
+exports.LOG_OUTCOMES = Object.freeze(['ok', 'failed', 'paused']);
+/** A plain object — not null, not an array, not a primitive. */
+function isEntryObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+exports.isEntryObject = isEntryObject;
+/** `{ meta }` when there is one, `{}` otherwise — an absent field stays absent. */
+function withMeta(meta) {
+    return meta === undefined ? {} : { meta };
+}
+/**
+ * Hand `entry` to the sink's method for its kind, as that method's entry; returns what the method
+ * returned (a promise from an async adapter). Throws whatever the method throws — the log catches.
+ */
+function sendEntry(sink, entry) {
+    const { address, at } = entry;
+    switch (entry.kind) {
+        case 'opened':
+            return sink.opened({ address, at, initialState: entry.initialState, ...withMeta(entry.meta) });
+        case 'commit':
+            return sink.commit({ address, at, bundle: entry.bundle });
+        case 'note':
+            return sink.note({ address, at, kind: entry.note, data: entry.data });
+        case 'closed':
+            return sink.closed({ address, at, outcome: entry.outcome, commits: entry.commits, ...withMeta(entry.meta) });
+    }
+}
+exports.sendEntry = sendEntry;
+/**
+ * A sink that keeps every entry in memory, in arrival order — the reference adapter: what any adapter
+ * must give back for `readStoredRecord` to read the same record. `entries` is a new array on each read.
+ * What it keeps is frozen as far as freezing reaches — the base, `meta` and a note's `data` are the
+ * copies a log hands it, and the bundle is already frozen — so no reader can rewrite its containers. A
+ * Date's time, a Map's or Set's entries and a buffer's bytes are not sealed by freezing (`deepFreeze`'s
+ * stated limit). A caller that hands it objects directly hands them over: they are frozen in place.
+ *
+ * @example
+ * ```typescript
+ * const sink = memorySink();
+ * const log = new EventLog({}, { sink, address: { logRunId: 'run-1', drillPath: [] } });
+ * log.close('ok');
+ * sink.entries.map((e) => e.kind); // ['opened', 'closed']
+ * ```
+ */
+function memorySink() {
+    const stored = [];
+    const keep = (entry) => {
+        stored.push((0, freeze_js_1.deepFreeze)(entry));
+    };
+    return {
+        get entries() {
+            return stored.slice();
+        },
+        opened: ({ address, at, initialState, meta }) => keep({ kind: 'opened', address, at, initialState, ...withMeta(meta) }),
+        commit: ({ address, at, bundle }) => keep({ kind: 'commit', address, at, bundle }),
+        note: ({ address, at, kind, data }) => keep({ kind: 'note', address, at, note: kind, data }),
+        closed: ({ address, at, outcome, commits, meta }) => keep({ kind: 'closed', address, at, outcome, commits, ...withMeta(meta) }),
+        flush: () => Promise.resolve(),
+    };
+}
+exports.memorySink = memorySink;

package/dist/lib/time-travel/bundles.js

@@ -17,7 +17,7 @@
  * not the recording.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readLog = exports.isCommitBundle = exports.bundleRefusal = exports.readTree = exports.isPlainish = void 0;
+exports.readLog = exports.isCommitBundle = exports.bundleRefusal = exports.readTree = exports.absentRow = exports.isPlainish = void 0;
 const verbs_js_1 = require("../memory/verbs.js");
 /**
  * The stand-in a gap leaves at its index: a commit that belongs to no stage
@@ -43,6 +43,20 @@ function isPlainish(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 exports.isPlainish = isPlainish;
+/**
+ * Rows that hold an index for a commit the record does not have (1.1.0) — what a STORED log could not
+ * supply at a position: no readable commit entry (`storedRecord.ts`). Each
+ * carries the reason every reader then reports for its index, so the fold, the cursor and the stored
+ * log say the same thing about it. Kept by identity (a JSON copy of one is an ordinary unreadable row).
+ */
+const ABSENT_ROWS = new WeakMap();
+/** A row every reader refuses with `reason` — a gap that keeps its index. */
+function absentRow(reason) {
+    const row = Object.freeze({});
+    ABSENT_ROWS.set(row, reason);
+    return row;
+}
+exports.absentRow = absentRow;
 /**
  * Read a source's `executionTree` as an {@link ExecutionTree}, or as absent.
  *
@@ -81,6 +95,9 @@ exports.readTree = readTree;
  * compatibility break dressed up as validation.
  */
 function bundleRefusal(row) {
+    const absent = typeof row === 'object' && row !== null ? ABSENT_ROWS.get(row) : undefined;
+    if (absent !== undefined)
+        return absent;
     if (!isPlainish(row)) {
         return `not an object (${row === null ? 'null' : Array.isArray(row) ? 'array' : typeof row})`;
     }

package/dist/lib/time-travel/commitStops.js

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.commitStopsStrategy = exports.commitStops = void 0;
 const runtimeStageId_js_1 = require("../ids/runtimeStageId.js");
 const commitLogUtils_js_1 = require("../memory/commitLogUtils.js");
+const bundles_js_1 = require("./bundles.js");
 /**
  * Every `runtimeStageId` in the execution tree that the engine marked as a
  * subflow mount. Authoritative, as is a bundle's recorded `phase: 'exit'`
@@ -92,7 +93,7 @@ function commitStops(commitLog, executionTree, subflowResults) {
     // the MOUNT's commit, made before any of them ran. It gets no stop of its
     // own; it belongs to the `'start'` bookend, which is where a reader looks
     // for "the input this chart began with" anyway. See {@link seedCommits}.
-    const seeds = seedCommits(commitLog, executionTree);
+    const seeds = seedCommits(commitLog, executionTree, subflowResults);
     const firsts = [];
     for (const [id, i] of (0, commitLogUtils_js_1.buildCommitIndex)(commitLog))
         if (id && i >= seeds)
@@ -163,6 +164,22 @@ function phasesOf(commitLog, haveTree) {
         return commitLog.map((bundle) => bundle.phase);
     return haveTree ? [] : (0, commitLogUtils_js_1.inferLegacyPhases)(commitLog);
 }
+/**
+ * True when the results map's entry for `head` IS this log — its history opens with this very bundle.
+ * The log is then that mount's own, and its head run is the mount's seed (R13: a seed carries its
+ * mount's runtimeStageId). This is what a TREE-LESS cursor over a mount log reads in place of the
+ * tree's root — a stored log read back by `readStoredRecord`, or a log whose stage after the seed was
+ * lost — so the seed opens `start` instead of standing as a stop (marked as its own mount).
+ */
+function opensOwnMount(subflowResults, head, first) {
+    if (!(0, bundles_js_1.isPlainish)(subflowResults))
+        return false;
+    const result = subflowResults[head];
+    if (!(0, bundles_js_1.isPlainish)(result) || !(0, bundles_js_1.isPlainish)(result.treeContext))
+        return false;
+    const history = result.treeContext.history;
+    return Array.isArray(history) && history[0] === first;
+}
 /** `commitStops` as a {@link TimeTravelStrategy} — the default for `timeTravel`. */
 exports.commitStopsStrategy = { stopsFor: commitStops };
 /**
@@ -183,7 +200,7 @@ exports.commitStopsStrategy = { stopsFor: commitStops };
  * whose id carries the same subflow path. Without a tree such a log reads as
  * one stop.
  */
-function seedCommits(commitLog, executionTree) {
+function seedCommits(commitLog, executionTree, subflowResults) {
     const head = commitLog[0]?.runtimeStageId;
     if (head === undefined)
         return 0;
@@ -196,6 +213,8 @@ function seedCommits(commitLog, executionTree) {
     let next = 1;
     while (next < commitLog.length && commitLog[next].runtimeStageId === head)
         next++;
+    if (executionTree === undefined && opensOwnMount(subflowResults, head, commitLog[0]))
+        return next;
     const address = (0, runtimeStageId_js_1.stageIdOf)(head);
     if (next >= commitLog.length) {
         const rootId = executionTree?.id;

package/dist/lib/time-travel/index.js

@@ -14,7 +14,7 @@
  * zero-dependency id grammar).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeTravel = exports.tagStops = exports.stateAt = exports.commitStopsStrategy = exports.commitStops = exports.isCommitBundle = exports.splitAxis = exports.filterStops = void 0;
+exports.timeTravel = exports.tagStops = exports.readStoredRecord = exports.stateAt = exports.commitStopsStrategy = exports.commitStops = exports.isCommitBundle = exports.splitAxis = exports.filterStops = void 0;
 var axis_js_1 = require("./axis.js");
 Object.defineProperty(exports, "filterStops", { enumerable: true, get: function () { return axis_js_1.filterStops; } });
 Object.defineProperty(exports, "splitAxis", { enumerable: true, get: function () { return axis_js_1.splitAxis; } });
@@ -25,6 +25,8 @@ Object.defineProperty(exports, "commitStops", { enumerable: true, get: function
 Object.defineProperty(exports, "commitStopsStrategy", { enumerable: true, get: function () { return commitStops_js_1.commitStopsStrategy; } });
 var stateAt_js_1 = require("./stateAt.js");
 Object.defineProperty(exports, "stateAt", { enumerable: true, get: function () { return stateAt_js_1.stateAt; } });
+var storedRecord_js_1 = require("./storedRecord.js");
+Object.defineProperty(exports, "readStoredRecord", { enumerable: true, get: function () { return storedRecord_js_1.readStoredRecord; } });
 var tagStops_js_1 = require("./tagStops.js");
 Object.defineProperty(exports, "tagStops", { enumerable: true, get: function () { return tagStops_js_1.tagStops; } });
 var timeTravel_js_1 = require("./timeTravel.js");