foottrace 1.0.3 → 1.2.0

package/dist/types/lib/memory/sink.d.ts

@@ -0,0 +1,148 @@
+/**
+ * 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
+ * ```
+ */
+import type { LogAddress } from './eventPosition.js';
+import type { CommitBundle } from './types.js';
+/**
+ * What a writer puts beside the record — on a log's `opened` / `closed` entry, or as a note's data.
+ * A plain object that survives `structuredClone`; opaque to foottrace: stored and returned, never read.
+ */
+export type Meta = Readonly<Record<string, unknown>>;
+/** How a log's writer said it ended. A pause ends this log; it is not a failure. */
+export type LogOutcome = 'ok' | 'failed' | 'paused';
+/** The outcomes a `closed` entry may carry, in one place for the writer's and the reader's checks. */
+export declare const LOG_OUTCOMES: readonly LogOutcome[];
+/**
+ * One stored entry: what a sink keeps per call, discriminated by `kind` (the method that received it).
+ * A note's own kind is stored as `note`.
+ */
+export type RecordEntry = {
+    readonly kind: 'opened';
+    readonly address: LogAddress;
+    readonly at: number;
+    /** The fold base — the state before the log's first commit. */
+    readonly initialState: Record<string, unknown>;
+    readonly meta?: Meta;
+} | {
+    readonly kind: 'commit';
+    readonly address: LogAddress;
+    readonly at: number;
+    /** The log's own bundle, frozen, its position stamped as `idx`. */
+    readonly bundle: CommitBundle;
+} | {
+    readonly kind: 'note';
+    readonly address: LogAddress;
+    readonly at: number;
+    /** The note's own kind, as the writer named it (`note('attempt', …)` → `'attempt'`). */
+    readonly note: string;
+    readonly data: Meta;
+} | {
+    readonly kind: 'closed';
+    readonly address: LogAddress;
+    readonly at: number;
+    readonly outcome: LogOutcome;
+    /** The log's length when it closed — how many commits the stored log must hold to be whole. */
+    readonly commits: number;
+    readonly meta?: Meta;
+};
+/**
+ * Where a log's entries go as they land — the port an adapter implements (memory, a file, S3, a table).
+ *
+ * Every method is called synchronously from the writer; an adapter that writes somewhere slow queues
+ * the entry and drains in `flush`. A method may throw, or return a promise that rejects: the log
+ * counts it (`EventLog · sinkFailures`), reports it to `onFailure`, and goes on — a failing sink never
+ * stops the writer. The entries an adapter is handed are its to keep: the bundle is frozen and shared
+ * with the log, everything else is the adapter's own copy.
+ */
+export interface RecordSink {
+    /** A log opened at `address` with its fold base. Called once, from the log's constructor. */
+    opened(entry: {
+        readonly address: LogAddress;
+        readonly at: number;
+        readonly initialState: Record<string, unknown>;
+        readonly meta?: Meta;
+    }): void;
+    /** A bundle landed in the log at `address` (its position is `bundle.idx`). */
+    commit(entry: {
+        readonly address: LogAddress;
+        readonly at: number;
+        readonly bundle: CommitBundle;
+    }): void;
+    /** The writer noted something beside the log — `kind` and `data` are opaque. */
+    note(entry: {
+        readonly address: LogAddress;
+        readonly at: number;
+        readonly kind: string;
+        readonly data: Meta;
+    }): void;
+    /** The log at `address` closed with `outcome`, holding `commits` bundles. */
+    closed(entry: {
+        readonly address: LogAddress;
+        readonly at: number;
+        readonly outcome: LogOutcome;
+        readonly commits: number;
+        readonly meta?: Meta;
+    }): void;
+    /** Drain whatever the adapter queued. The log never calls it; whoever owns the sink does. */
+    flush?(): Promise<void>;
+    /** Told of every entry this sink did not take — the entry and what went wrong. A throw here is ignored. */
+    onFailure?(failure: {
+        readonly entry: RecordEntry;
+        readonly error: unknown;
+    }): void;
+}
+/** A plain object — not null, not an array, not a primitive. */
+export declare function isEntryObject(value: unknown): value is Record<string, unknown>;
+/**
+ * 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.
+ */
+export declare function sendEntry(sink: RecordSink, entry: RecordEntry): unknown;
+/**
+ * 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']
+ * ```
+ */
+export declare function memorySink(): RecordSink & {
+    readonly entries: readonly RecordEntry[];
+};

package/dist/types/lib/memory/types.d.ts

@@ -2,10 +2,11 @@
  * types.ts — the record's types: a bundle, its rows, its patches, its encoding, and the
  * execution tree as the record's readers read it.
  *
- * Imports nothing. The standalone record names nothing outside itself: the engine's frame
+ * Imports only the record's leaf attention type. The record names nothing outside itself: the engine's frame
  * types — the stage snapshot, flow messages and retention dials — remain in FootPrint's
  * `frameTypes.ts`. The closed record graph is enforced by scripts/check-layering.mjs.
  */
+import type { Attention } from '../cause/types.js';
 /** A flat key-value bag representing a state patch (overwrite or merge). */
 export interface MemoryPatch {
     [key: string]: any;
@@ -194,6 +195,8 @@ export type CommitValuesMode = 'full' | 'delta';
  * ```
  */
 export interface ExecutionTree {
+    /** Optional recorded business attention; absence does not assert health. */
+    readonly attention?: readonly Attention[];
     /** The stage's id (prefixed inside a subflow). `commitStops` reads the root's to place a subflow's seed. */
     readonly id?: string;
     /** `[subflowPath/]stageId#executionIndex` — what a reader keys on. A node without one is not a stage. */

package/dist/types/lib/time-travel/bundles.d.ts

@@ -19,6 +19,8 @@ import type { CommitBundle, ExecutionTree } from '../memory/types.js';
 import type { LogGap } from './types.js';
 /** A plain object — not null, not an array, not a primitive. */
 export declare function isPlainish(value: unknown): value is Record<string, unknown>;
+/** A row every reader refuses with `reason` — a gap that keeps its index. */
+export declare function absentRow(reason: string): object;
 /**
  * Read a source's `executionTree` as an {@link ExecutionTree}, or as absent.
  *

package/dist/types/lib/time-travel/index.d.ts

@@ -17,6 +17,8 @@ export { filterStops, splitAxis } from './axis.js';
 export { isCommitBundle } from './bundles.js';
 export { commitStops, commitStopsStrategy } from './commitStops.js';
 export { stateAt } from './stateAt.js';
+export type { StoredLog, StoredNote, StoredRecord, StoredRecordLimits } from './storedRecord.js';
+export { readStoredRecord } from './storedRecord.js';
 export { tagStops } from './tagStops.js';
 export { timeTravel } from './timeTravel.js';
 export type { AxisRefusal, AxisSplit, BookendedAxis, FoldBasis, FoldedState, FoldSource, LogGap, Mark, Move, MoveRefusal, Stop, StopKind, TimeTravel, TimeTravelOptions, TimeTravelSource, TimeTravelStrategy, } from './types.js';

package/dist/types/lib/time-travel/storedRecord.d.ts

@@ -0,0 +1,195 @@
+/**
+ * storedRecord.ts — reading back what a sink stored (1.1.0).
+ *
+ * WHY THIS FILE EXISTS. A log that writes to a `RecordSink` (`foottrace/write`) leaves its record in
+ * storage AS IT LANDS: an `opened` entry with the fold base, one `commit` entry per bundle, `note`
+ * entries, and a `closed` entry with how the log ended. A run that is killed never writes its
+ * `closed` entry. This reader turns stored entries back into logs a person or a model can read —
+ * and says, before any fold, which of them never finished (`complete: false`) and what each one is
+ * missing.
+ *
+ * WHAT IT READS. Entries come back from storage unvalidated (a parsed file, a table scan) — untrusted
+ * input — so it takes `Iterable<unknown>` and checks each one where it is read: the 9.18.0 law for
+ * stored recordings, no cast at the seam. An entry it does not read into a log is never dropped in
+ * silence: it is listed in `unread` with its position and the reason.
+ *
+ * THE LAWS IT KEEPS.
+ *   1. Grouped by address. Every entry names its log (`logRunId` + `drillPath`); entries of many
+ *      logs may arrive interleaved, and each log keeps its own entries in arrival order.
+ *   2. A commit sits at its own index. `EventLog · record` stamps `bundle.idx` before the sink sees
+ *      the bundle, so a commit lost on the way (a sink that failed once — the writer goes on) leaves a
+ *      GAP at its index instead of shifting every commit after it; so does a bundle that is not a
+ *      readable bundle. Every gap keeps its index, and the fold reports it (`skipped`) with the same
+ *      reason the stored log gives (`gaps`). One place, one entry: the first READABLE commit entry
+ *      for an index stands (a torn first delivery yields to a readable redelivery), the first
+ *      `opened` stands, and every other entry for a place already held — a redelivery or a conflict,
+ *      the very same object included — is listed in `unread`. Payloads are never compared, so no
+ *      stored value is walked.
+ *   3. Complete means the writer finished — and the reader read it all. A log is `complete` when a
+ *      `closed` entry covers every stored commit (`closed.commits` is past the last index); the
+ *      covering close with the largest `commits` gives the `outcome` and the length, so no loss an
+ *      earlier close showed can hide behind a later one. A log that was closed and then went on (a
+ *      later commit) is not complete until it is closed again. A closed log whose store lost commits
+ *      is complete AND has gaps (`closed.commits` makes even a lost LAST commit a gap). A log a limit
+ *      cut, and every log once reading stopped at the `entries` limit, is not complete: what the
+ *      reader did not read could have gone on.
+ *   4. Opaque stays opaque. `meta` and a note's `kind` and `data` are handed back as stored, never
+ *      read or merged.
+ *   5. Read, never touched. Nothing here copies, freezes or edits the entries it is given — not the
+ *      base, not `meta`: the stored log hands back their own values.
+ *   6. Bounded work (see {@link StoredRecordLimits}). Every walk is a loop over the input, never a
+ *      recursion, and never through an input's own iterator except the input itself; the work per
+ *      entry is bounded by the address limits; the rows a log holds are its stored commits plus gaps
+ *      from ONE budget for the whole record, spent on the logs that need the fewest gaps first (so a
+ *      corrupt log asking for the most is the one cut); and reading stops after `entries` entries. Whatever a
+ *      limit stops is listed in `unread` by name — never a hang, never a silent cut.
+ *
+ * Entries are data. An entry whose fields throw while it is checked (a getter, a revoked proxy) is
+ * listed in `unread`, and what the reader computes with — the kind, a commit's index and bundle, a
+ * close's length — is taken once, as checked. An in-memory accessor that changes or throws on a later
+ * read is out of contract, as everywhere in the record (docs/extraction.md): parsed JSON and structured
+ * clones carry none.
+ *
+ * DAG position: memory ← time-travel; this file is a reader beside `timeTravel` and imports only
+ * record files.
+ */
+import type { LogAddress } from '../memory/eventPosition.js';
+import { type LogOutcome, type Meta, type RecordEntry } from '../memory/sink.js';
+import type { CommitBundle } from '../memory/types.js';
+import type { LogGap, TimeTravelSource } from './types.js';
+/** A note the writer kept beside a log (`EventLog · note`), as stored. */
+export interface StoredNote {
+    /** The note's kind, as the writer named it. */
+    readonly kind: string;
+    /** When it was written (epoch ms). */
+    readonly at: number;
+    /** What the writer put in it — opaque. */
+    readonly data: Meta;
+}
+/** One log read back from a sink's entries. */
+export interface StoredLog {
+    /** Which log this is: the run leg that owned it and the mounts it sits under (root: `drillPath: []`). */
+    readonly address: LogAddress;
+    /** The fold base the `opened` entry carried; ABSENT when no readable `opened` entry was stored. */
+    readonly initialState?: Record<string, unknown>;
+    /**
+     * The bundles, each at its own index (`bundle.idx`). An index with no readable bundle holds an empty
+     * stand-in (it belongs to no stage and carries nothing) and is named in {@link gaps} — check `gaps`
+     * before a causal query, which takes the bundles as they are; fold {@link source}, not this, so the
+     * fold reports them.
+     */
+    readonly commitLog: readonly CommitBundle[];
+    /** Every index of {@link commitLog} that holds no readable bundle, with why — empty when the log is whole. */
+    readonly gaps: readonly LogGap[];
+    /**
+     * The notes, in arrival order. A store that delivers an entry twice as two copies repeats its note:
+     * payloads are never compared (the very same object twice is listed in `unread` instead).
+     */
+    readonly notes: readonly StoredNote[];
+    /**
+     * `true` when a `closed` entry covers every stored commit and the reader read the log whole: the
+     * writer said it ended. `false` for a log that never closed — a crashed run, or one still going —
+     * for one that went on after its last close, and for one the reader did not read whole (a limit
+     * cut it, or reading stopped at the `entries` limit — see `StoredRecord.unread`).
+     */
+    readonly complete: boolean;
+    /** How the covering `closed` entry said the log ended; ABSENT while the log is not complete. */
+    readonly outcome?: LogOutcome;
+    /**
+     * What the writer put on the `opened` entry and on the covering `closed` entry (present only while
+     * the log is complete) — opaque, never merged.
+     */
+    readonly meta: {
+        readonly opened?: Meta;
+        readonly closed?: Meta;
+    };
+    /**
+     * The entries this log was read from, in arrival order, as stored — the evidence the rest is read
+     * from (each entry's `at`, every `closed` entry). An entry listed in `StoredRecord.unread` is not
+     * here. A commit's bundle is the stored row: {@link gaps} names one that is not a readable bundle.
+     */
+    readonly entries: readonly RecordEntry[];
+    /**
+     * The log as `timeTravel` and `stateAt` read it: `{ commitLog, initialState?, subflowResults? }`. A
+     * gap is a row the fold refuses with the same reason {@link gaps} gives (`skipped`), so a fold that
+     * crosses one says so. `subflowResults` holds every stored mount log of the run leg — this one too,
+     * when it is a mount — keyed by each mount's runtimeStageId (the last segment of its `drillPath`):
+     * one flat map per leg, as a live snapshot's, so the cursor marks those stops as mounts and
+     * `drill(mountRuntimeStageId)` opens the mount's own stored log. A mount log's head commit stamped
+     * with its own mount id is its seed (it opens `start`, as on a live cursor). The same object on
+     * every call.
+     */
+    source(): TimeTravelSource;
+}
+/** Every log a sink's entries hold, and every entry no log holds. */
+export interface StoredRecord {
+    /** Every log, keyed by its address as a JSON array — `["<logRunId>", ...drillPath]` — in first-arrival order. */
+    readonly logs: ReadonlyMap<string, StoredLog>;
+    /** The root log of the run leg `logRunId` (`drillPath: []`), or `undefined` when none was stored. */
+    root(logRunId: string): StoredLog | undefined;
+    /** The log at `address`, or `undefined` when none was stored. */
+    log(address: LogAddress): StoredLog | undefined;
+    /**
+     * Entries not read into any log, by position in the input, with the reason: an entry that could not
+     * be read, one past a limit of the reader, or one for a place another entry holds (a second `opened`,
+     * a second commit for an index, the same entry again). In input order; empty when every entry was
+     * read. A commit that could not be read at all, or that a limit cut, leaves no row: its index is a
+     * gap only when a later stored commit or a close reaches past it.
+     */
+    readonly unread: readonly {
+        readonly index: number;
+        readonly reason: string;
+    }[];
+}
+/**
+ * The reader's limits — what bounds its work on untrusted input. Each defaults to the value below; a
+ * caller that reads larger records raises it. Whatever a limit stops is listed in `unread` by name.
+ */
+export interface StoredRecordLimits {
+    /**
+     * Entries read; past it, reading stops, one `unread` item says so, and no log reads complete.
+     * Default 16,777,216 (2^24).
+     */
+    readonly entries?: number;
+    /**
+     * Gaps held across the WHOLE record — rows for commits the store does not have — spent on the logs
+     * that need the fewest first. A commit (or a close) that would need more is unread. Default
+     * 1,048,576 (2^20). The other rows a log holds are its stored commits.
+     */
+    readonly missingCommits?: number;
+    /** Segments in an address's `drillPath`. Default 1,024. */
+    readonly drillDepth?: number;
+    /** Characters in an address — its `logRunId` and `drillPath` segments together. Default 65,536. */
+    readonly addressLength?: number;
+}
+/** The defaults — internal to the package; documented on {@link StoredRecordLimits}. */
+export declare const DEFAULT_LIMITS: Required<StoredRecordLimits>;
+/**
+ * Read a sink's stored entries back into logs.
+ *
+ * Bounded on untrusted input: no recursion, no payload walk, work per entry bounded by the address
+ * limits, at most `limits.missingCommits` gap rows across the record, and at most `limits.entries`
+ * entries read — whatever a limit stops is listed in `unread` by name.
+ *
+ * @param entries What a `RecordSink` stored (`memorySink().entries`, or entries parsed back from a
+ *   file or a table), in the order they were written — typed `unknown` because stored entries come
+ *   back unvalidated; each is checked here.
+ * @param limits Raise a default to read a larger record ({@link StoredRecordLimits}).
+ * @returns Every log by address, the run-leg roots, and every entry not read into a log.
+ * @throws RangeError when a limit is not a non-negative integer or `Infinity`; TypeError when
+ *   `entries` is not iterable; whatever the input's own iterator throws. Never for an entry that is
+ *   data (parsed JSON, a structured clone).
+ *
+ * @example
+ * ```typescript
+ * import { readStoredRecord, stateAt, timeTravel } from 'foottrace';
+ *
+ * const stored = readStoredRecord(entries);       // e.g. JSON lines read back after a crash
+ * const run = stored.root('run-1');
+ * run?.complete;                                   // false — it never closed
+ * run?.notes.map((n) => n.kind);                   // ['attempt', 'attempt'] — kept as they happened
+ * timeTravel(run!.source()).last();                // the cursor over what landed
+ * stateAt(run!.source(), run!.commitLog.length - 1).skipped; // a lost commit, by index and reason
+ * ```
+ */
+export declare function readStoredRecord(entries: Iterable<unknown>, limits?: StoredRecordLimits): StoredRecord;

package/dist/types/lib/time-travel/types.d.ts

@@ -452,7 +452,10 @@ export interface TimeTravel<TMeta = unknown> {
     /**
      * A cursor over the subflow mounted at `mountRuntimeStageId` — the same
      * interface, its own log, its own fold base. `undefined` when that mount is
-     * not in this run's subflow results.
+     * not in this run's subflow results, and when it is this cursor's own mount,
+     * one it was drilled out of, or the log it already reads (1.1.0: a stored or
+     * hand-built log can name one, and a viewer that opens every mount must not
+     * loop).
      *
      * A stop inside a subflow is NOT a stop of this cursor: subflows run in
      * isolated runtimes and commit to their own log, so the outer axis holds

package/dist/types/write.d.ts

@@ -15,6 +15,11 @@
  * The step's encoding is two dials (`RecordEncoding`): `commitValues` (`'full'` | `'delta'`) and
  * `writeProvenance` (`'off'` | `'reads-prefix'`, `WriteProvenanceMode`).
  *
+ * A log can also hand every entry to a `RecordSink` AS IT LANDS (`new EventLog(base, { sink,
+ * address })`): `opened`, `commit`, `note`, `closed` — so a run that never ends still leaves its
+ * record. `memorySink` is the reference adapter; `readStoredRecord` (`foottrace`) reads the stored
+ * entries back. A failing sink never stops the writer (`EventLog · sinkFailures`).
+ *
  * Every type this door names is the record's own: nothing here loads or names the engine
  * (test/architecture/layering.test.ts). Its names and the bytes they write are promised under the
  * record fixtures' re-pin policy (test/fixtures/README.md): a refactor never moves a byte.
@@ -41,6 +46,8 @@
  */
 export { EventLog } from './lib/memory/EventLog.js';
 export { SharedMemory } from './lib/memory/SharedMemory.js';
+export type { RecordEntry, RecordSink } from './lib/memory/sink.js';
+export { memorySink } from './lib/memory/sink.js';
 export type { CommitStamp } from './lib/memory/recordCommit.js';
 export type { RecordEncoding, WriteScrub, WriteVerb } from './lib/memory/RecordFrame.js';
 export { RecordFrame } from './lib/memory/RecordFrame.js';

package/dist/write.js

@@ -16,6 +16,11 @@
  * The step's encoding is two dials (`RecordEncoding`): `commitValues` (`'full'` | `'delta'`) and
  * `writeProvenance` (`'off'` | `'reads-prefix'`, `WriteProvenanceMode`).
  *
+ * A log can also hand every entry to a `RecordSink` AS IT LANDS (`new EventLog(base, { sink,
+ * address })`): `opened`, `commit`, `note`, `closed` — so a run that never ends still leaves its
+ * record. `memorySink` is the reference adapter; `readStoredRecord` (`foottrace`) reads the stored
+ * entries back. A failing sink never stops the writer (`EventLog · sinkFailures`).
+ *
  * Every type this door names is the record's own: nothing here loads or names the engine
  * (test/architecture/layering.test.ts). Its names and the bytes they write are promised under the
  * record fixtures' re-pin policy (test/fixtures/README.md): a refactor never moves a byte.
@@ -41,12 +46,14 @@
  * @module write
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_PLACEHOLDER = exports.freezeRecord = exports.deepFreeze = exports.RecordFrame = exports.SharedMemory = exports.EventLog = void 0;
+exports.LOG_PLACEHOLDER = exports.freezeRecord = exports.deepFreeze = exports.RecordFrame = exports.memorySink = exports.SharedMemory = exports.EventLog = void 0;
 // The heap and the log.
 var EventLog_js_1 = require("./lib/memory/EventLog.js");
 Object.defineProperty(exports, "EventLog", { enumerable: true, get: function () { return EventLog_js_1.EventLog; } });
 var SharedMemory_js_1 = require("./lib/memory/SharedMemory.js");
 Object.defineProperty(exports, "SharedMemory", { enumerable: true, get: function () { return SharedMemory_js_1.SharedMemory; } });
+var sink_js_1 = require("./lib/memory/sink.js");
+Object.defineProperty(exports, "memorySink", { enumerable: true, get: function () { return sink_js_1.memorySink; } });
 var RecordFrame_js_1 = require("./lib/memory/RecordFrame.js");
 Object.defineProperty(exports, "RecordFrame", { enumerable: true, get: function () { return RecordFrame_js_1.RecordFrame; } });
 var freeze_js_1 = require("./lib/capture/freeze.js");

package/package.json

@@ -1,45 +1,99 @@
 {
   "name": "foottrace",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "type": "commonjs",
-  "description": "Execution records, replay, time travel and honest attribution — independent of the engine that produced them",
+  "description": "Execution records, replay, time travel and honest attribution \u2014 independent of the engine that produced them",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan <sanjay@footprintjs.dev>",
-  "repository": { "type": "git", "url": "git+https://github.com/footprintjs/foottrace.git" },
-  "bugs": { "url": "https://github.com/footprintjs/foottrace/issues" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/footprintjs/foottrace.git"
+  },
+  "bugs": {
+    "url": "https://github.com/footprintjs/foottrace/issues"
+  },
   "homepage": "https://github.com/footprintjs/foottrace#readme",
-  "engines": { "node": ">=22" },
+  "engines": {
+    "node": ">=22"
+  },
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
-  "files": ["dist/"],
+  "files": [
+    "dist/"
+  ],
   "exports": {
-    ".": { "import": { "types": "./dist/esm/index.d.ts", "default": "./dist/esm/index.js" }, "require": { "types": "./dist/types/index.d.ts", "default": "./dist/index.js" } },
-    "./write": { "import": { "types": "./dist/esm/write.d.ts", "default": "./dist/esm/write.js" }, "require": { "types": "./dist/types/write.d.ts", "default": "./dist/write.js" } },
-    "./paths": { "import": { "types": "./dist/esm/paths.d.ts", "default": "./dist/esm/paths.js" }, "require": { "types": "./dist/types/paths.d.ts", "default": "./dist/paths.js" } },
-    "./package.json": "./package.json"
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./write": {
+      "import": {
+        "types": "./dist/esm/write.d.ts",
+        "default": "./dist/esm/write.js"
+      },
+      "require": {
+        "types": "./dist/types/write.d.ts",
+        "default": "./dist/write.js"
+      }
+    },
+    "./paths": {
+      "import": {
+        "types": "./dist/esm/paths.d.ts",
+        "default": "./dist/esm/paths.js"
+      },
+      "require": {
+        "types": "./dist/types/paths.d.ts",
+        "default": "./dist/paths.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./cause": {
+      "import": {
+        "types": "./dist/esm/cause.d.ts",
+        "default": "./dist/esm/cause.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "write": [
+        "dist/types/write.d.ts"
+      ],
+      "paths": [
+        "dist/types/paths.d.ts"
+      ],
+      "cause": [
+        "dist/esm/cause.d.ts"
+      ]
+    }
   },
-  "typesVersions": { "*": { "write": ["dist/types/write.d.ts"], "paths": ["dist/types/paths.d.ts"] } },
   "scripts": {
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.esm.json && node scripts/postbuild-esm.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc -p tsconfig.test.json",
     "check:layering": "node scripts/check-layering.mjs",
-    "check:package": "publint && attw --pack",
+    "check:package": "publint && attw --pack --exclude-entrypoints cause --profile strict && attw --pack --entrypoints cause --profile esm-only",
     "lint": "eslint 'src/**/*.ts'",
     "format": "prettier --check 'src/**/*.ts' 'test/**/*.ts'",
     "test:examples": "tsc -p examples/tsconfig.json",
     "check": "npm run build && npm run typecheck && npm test && npm run check:layering && npm run lint && npm run format && npm run check:package && npm run test:examples"
   },
-  "dependencies": {},
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.1",
     "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^8.71.1",
     "@typescript-eslint/parser": "^8.71.1",
     "@vitest/coverage-v8": "4.1.11",
+    "esbuild": "0.28.2",
     "eslint": "^8.57.1",
     "fast-check": "^4.4.0",
     "prettier": "^2.8.1",