footprintjs 10.0.1 → 10.2.0

package/dist/lib/sinks/fileSink.js

@@ -0,0 +1,392 @@
+"use strict";
+/**
+ * sinks/fileSink.ts — the record, one JSON line per entry, in a file (design §3.5, §4, packet P6). NODE ONLY: the
+ * one file in `src/` that imports a Node built-in, reachable only through the `footprintjs/sinks` door.
+ *
+ * WHY A FILE, WHY THIS SHAPE. A run's record must outlive the process that made it — a killed process, a crashed
+ * host, a serverless freeze. Each entry the log hands over is encoded, checked and given its own offset in the file,
+ * and its write is handed to the I/O pool AT ONCE (a positional write — no entry waits for the event loop to turn);
+ * the pool's threads perform them while the main thread runs on. A process killed after a pool thread wrote an entry
+ * keeps it. Until then it is not on disk: microseconds on a free pool, but the pool (4 threads by default) is shared
+ * with DNS lookups, zlib, crypto and other fs work, so while it is busy the window is as long as that work — and since
+ * writes complete out of order, a kill can lose an entry in the middle (the reader reports the hole). `flush()` waits for every write and
+ * `fsync`s — the step that also survives the machine losing power, and the one the executor awaits after each run's
+ * closing entry.
+ *
+ * THE THREAT MODEL, as code — every resource bounded, nothing that can stall the run:
+ *   - ONLY THE PATH THE APP GIVES. Resolved once and opened once, at `fileSink(path)`; every entry goes to that open
+ *     file. A symbolic link at the path is refused (`O_NOFOLLOW`, where the platform has it), and so is anything
+ *     that is not a regular file, a file with another hard link, another owner, or group/world write. A file the
+ *     sink creates is `0o600`.
+ *   - ATOMIC PER ENTRY. A line is encoded in full first — an entry JSON cannot write (a `BigInt`, a cycle) is
+ *     refused whole — then written at its own offset. A write that fails part-way leaves a hole up to the next
+ *     entry's offset; the reader splits at it (NUL), so a torn line never swallows the one after it (an existing
+ *     file with a torn tail gets a newline first).
+ *   - BOUNDED: `maxEntryBytes` (one line, 8 MiB — refused by name, before it is encoded when its length already
+ *     says so), `maxQueuedBytes` (accepted, not yet written, 16 MiB — past it an entry is DROPPED and counted, never
+ *     buffered without limit), `maxBytes` (the file, 64 MiB — once full, every further entry is refused and counted;
+ *     a closing entry may use a 64 KiB reserve so a full file can still say how the run ended), `flushTimeoutMs`
+ *     (10 s — then `flush()` rejects). Every refusal throws from the sink method, which the log counts
+ *     (`getSnapshot().sink`); a write that fails later rejects that entry's promise, counted the same way.
+ *   - ASYNCHRONOUS WRITES ONLY. No method blocks on the disk; the file is released asynchronously, after every
+ *     write and every started fsync.
+ *   - NO SECRET ON DISK is the EXECUTOR's law, applied before any entry reaches an adapter (`runner/recordSink.ts`):
+ *     this file writes what it is handed and reads nothing else.
+ *   - ONE WRITER PER FILE. A second sink on a file this process has open is refused (by device and inode, across the
+ *     CommonJS and ESM builds). ANOTHER PROCESS writing the same path is not seen at open: each writes at its own
+ *     offsets and would overwrite the other. `flush()` checks the file's size against what this sink placed and rejects
+ *     (a loss the run counts) when another writer's bytes reach past it — best effort: an overwrite this sink's own
+ *     later writes cover is not seen. Give each process its own file.
+ *
+ * WHAT JSON KEEPS. A line holds what `JSON.stringify` keeps: a `Date` becomes its ISO string, a `Map` / `Set` an
+ * empty object, `undefined` disappears. A record of plain JSON values reads back exactly (`readRecordFile` →
+ * `readStoredRecord`); for richer values, bring an adapter with a richer encoding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRecordFile = exports.fileSink = exports.DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS = exports.DEFAULT_FILE_SINK_MAX_QUEUED_BYTES = exports.DEFAULT_FILE_SINK_MAX_ENTRY_BYTES = exports.DEFAULT_FILE_SINK_MAX_BYTES = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
+/** The default cap on a record file: 64 MiB. */
+exports.DEFAULT_FILE_SINK_MAX_BYTES = 64 * 1024 * 1024;
+/** The default cap on ONE entry's line: 8 MiB. */
+exports.DEFAULT_FILE_SINK_MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+/** The default cap on bytes accepted but not yet written: 16 MiB. */
+exports.DEFAULT_FILE_SINK_MAX_QUEUED_BYTES = 16 * 1024 * 1024;
+/** The default bound on `flush()`: 10 s. */
+exports.DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS = 10_000;
+/** How far past `maxBytes` a CLOSING entry may still go, so a full file can say how the run ended: 64 KiB. */
+const CLOSE_RESERVE_BYTES = 64 * 1024;
+/** The default cap `readRecordFile` reads: 256 MiB. */
+const DEFAULT_READ_MAX_BYTES = 256 * 1024 * 1024;
+/**
+ * A record sink that appends each entry to `path` as one JSON line — the crash-safe record on a Node host.
+ *
+ * Every method returns at once: the line is encoded, checked against every bound, given its offset and handed to
+ * the I/O pool. The method's promise settles when that line is written; a write that fails rejects it, and the run
+ * counts the loss.
+ *
+ * @throws TypeError when `path` is not a non-empty string or does not name a regular file the writer owns alone;
+ *   RangeError for a bound that is not a whole number ≥ 1; the operating system's error when
+ *   the file cannot be opened (a symbolic link at `path` included). Made once, at setup — never during a run.
+ *
+ * @example
+ * ```typescript
+ * import { fileSink, readRecordFile } from 'footprintjs/sinks';
+ * import { readStoredRecord } from 'foottrace';
+ *
+ * const sink = fileSink('/var/footprint/orders.jsonl');
+ * const executor = new FlowChartExecutor(chart, { sink });
+ * await executor.run({ input });
+ * // …later, or after a crash:
+ * const record = readStoredRecord(readRecordFile('/var/footprint/orders.jsonl').entries);
+ * record.root(runId)?.complete; // false for a run that never ended
+ * ```
+ */
+function fileSink(path, options) {
+    if (typeof path !== 'string' || path === '')
+        throw new TypeError('fileSink: path must be a non-empty string');
+    const maxBytes = bound('maxBytes', options?.maxBytes, exports.DEFAULT_FILE_SINK_MAX_BYTES, 1);
+    const maxEntryBytes = bound('maxEntryBytes', options?.maxEntryBytes, exports.DEFAULT_FILE_SINK_MAX_ENTRY_BYTES, 1);
+    const maxQueuedBytes = bound('maxQueuedBytes', options?.maxQueuedBytes, exports.DEFAULT_FILE_SINK_MAX_QUEUED_BYTES, 1);
+    const flushTimeoutMs = bound('flushTimeoutMs', options?.flushTimeoutMs, exports.DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS, 1);
+    const absolute = (0, node_path_1.resolve)(path);
+    // NOT `O_APPEND`: each entry is written at the offset it was given when it was queued (a positional write), so
+    // every entry is handed to the I/O pool the moment it is accepted — none waits for the event loop to turn.
+    const fd = (0, node_fs_1.openSync)(absolute, node_fs_1.constants.O_RDWR | node_fs_1.constants.O_CREAT | (node_fs_1.constants.O_NOFOLLOW ?? 0), 0o600);
+    let identity;
+    let size;
+    let needsNewline; // the file ends with a torn line: the first entry starts a new one
+    try {
+        const stat = (0, node_fs_1.fstatSync)(fd);
+        if (!stat.isFile())
+            throw new TypeError(`fileSink: ${absolute} is not a regular file`);
+        refuseForeign(absolute, stat);
+        identity = `${stat.dev}:${stat.ino}`;
+        // One writer per file, in this process: a second sink would place its entries over the first's.
+        if (OPEN_FILES.has(identity))
+            throw new TypeError(`fileSink: ${absolute} already has an open sink in this process`);
+        size = stat.size;
+        needsNewline = size > 0 && !endsWithNewline(fd, size);
+    }
+    catch (error) {
+        (0, node_fs_1.closeSync)(fd);
+        throw error;
+    }
+    OPEN_FILES.add(identity);
+    const encoder = new TextEncoder();
+    let next = size; // the offset the next accepted entry is written at — what `maxBytes` bounds
+    let written = size; // bytes known on disk
+    let queuedBytes = 0; // accepted, not yet written (in the I/O pool's hands)
+    let inFlight = 0;
+    let syncing = 0;
+    let full = false;
+    let closing = false;
+    let released = false;
+    let drained = [];
+    let closedSignal;
+    const whenReleased = new Promise((resolve) => (closedSignal = resolve));
+    /** Release the file once nothing is in flight and no fsync is pending — asynchronously; an error is ignored. */
+    const releaseIfIdle = () => {
+        if (!closing || released || inFlight > 0 || syncing > 0)
+            return;
+        released = true;
+        OPEN_FILES.delete(identity);
+        (0, node_fs_1.close)(fd, () => closedSignal?.());
+    };
+    /** Everything accepted is written: start each waiting flush's fsync, then release if closing. */
+    const settleDrained = () => {
+        if (inFlight > 0)
+            return;
+        const waiting = drained;
+        drained = [];
+        for (const start of waiting)
+            start();
+        releaseIfIdle();
+    };
+    /** One entry: refused whole with a named bound (the log counts it), or submitted — never in part, never blocking. */
+    const enqueue = (entry) => {
+        if (closing)
+            throw new Error(`fileSink: ${absolute} is closed`);
+        // The cheap refusals first: a full file or a full queue costs no encoding.
+        if (full && entry.kind !== 'closed')
+            throw fileFull(absolute, maxBytes, entry.kind);
+        // A closing entry is exempt from the queue bound (as from `maxBytes`, within its reserve): how a log ended is
+        // the one entry a full queue must not drop.
+        const isClosingEntry = entry.kind === 'closed';
+        if (!isClosingEntry && queuedBytes >= maxQueuedBytes)
+            throw queueFull(absolute, queuedBytes, maxQueuedBytes, entry.kind);
+        const json = JSON.stringify(entry); // an entry JSON cannot write (a BigInt, a cycle) throws here, whole
+        // A string's length never exceeds its UTF-8 size: an entry already too long is refused before it is encoded.
+        if (json.length + 1 > maxEntryBytes)
+            throw tooLarge(absolute, entry.kind, maxEntryBytes);
+        const encoded = encoder.encode(`${needsNewline ? '\n' : ''}${json}\n`);
+        if (encoded.length > maxEntryBytes + 1)
+            throw tooLarge(absolute, entry.kind, maxEntryBytes);
+        const limit = entry.kind === 'closed' ? maxBytes + CLOSE_RESERVE_BYTES : maxBytes;
+        if (next + encoded.length > limit) {
+            if (entry.kind !== 'closed')
+                full = true;
+            throw fileFull(absolute, maxBytes, entry.kind);
+        }
+        if (!isClosingEntry && queuedBytes + encoded.length > maxQueuedBytes) {
+            throw queueFull(absolute, queuedBytes, maxQueuedBytes, entry.kind);
+        }
+        needsNewline = false;
+        const at = next;
+        next += encoded.length;
+        queuedBytes += encoded.length;
+        inFlight += 1;
+        return new Promise((resolve, reject) => {
+            writeAt(fd, encoded, at, (error, wrote) => {
+                inFlight -= 1;
+                queuedBytes -= encoded.length;
+                written += wrote;
+                // A line cut short leaves a hole up to the next entry's offset: the reader splits at it (NUL), so a torn
+                // line never swallows the entry after it.
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+                settleDrained();
+            });
+        });
+    };
+    return {
+        path: absolute,
+        get bytes() {
+            return written;
+        },
+        get queuedBytes() {
+            return queuedBytes;
+        },
+        get full() {
+            return full;
+        },
+        opened: ({ address, at, initialState, meta }) => enqueue({ kind: 'opened', address, at, initialState, ...(meta === undefined ? {} : { meta }) }),
+        commit: ({ address, at, bundle }) => enqueue({ kind: 'commit', address, at, bundle }),
+        note: ({ address, at, kind, data }) => enqueue({ kind: 'note', address, at, note: kind, data }),
+        closed: ({ address, at, outcome, commits, meta }) => enqueue({ kind: 'closed', address, at, outcome, commits, ...(meta === undefined ? {} : { meta }) }),
+        flush: () => {
+            if (closing)
+                return Promise.reject(new Error(`fileSink: ${absolute} is closed`));
+            const work = new Promise((resolve, reject) => {
+                drained.push(() => {
+                    syncing += 1;
+                    (0, node_fs_1.fsync)(fd, (error) => {
+                        if (error) {
+                            syncing -= 1;
+                            reject(error);
+                            releaseIfIdle();
+                            return;
+                        }
+                        // Another writer (another process on the same path) grew the file past what this sink placed: its
+                        // entries and ours overlap. Said, never silent.
+                        (0, node_fs_1.fstat)(fd, (statError, stat) => {
+                            syncing -= 1;
+                            if (statError)
+                                reject(statError);
+                            else if (stat.size > next) {
+                                reject(new Error(`fileSink: ${absolute} was written by another writer (one sink per file)`));
+                            }
+                            else
+                                resolve();
+                            releaseIfIdle();
+                        });
+                    });
+                });
+                settleDrained();
+            });
+            return withTimeout(work, flushTimeoutMs, `fileSink: flush() of ${absolute} did not finish in ${flushTimeoutMs}ms`);
+        },
+        close: () => {
+            if (!closing) {
+                closing = true;
+                releaseIfIdle();
+            }
+            return whenReleased;
+        },
+    };
+}
+exports.fileSink = fileSink;
+/**
+ * Files a sink of this process has open, by device and inode — one writer per file. Kept on the global object, so
+ * the package's CommonJS and ESM builds (two module instances in one process) share it.
+ */
+const OPEN_FILES = (globalThis[Symbol.for('footprintjs.fileSink.open')] ??=
+    new Set());
+function fileFull(path, maxBytes, kind) {
+    return new RangeError(`fileSink: ${path} is full (maxBytes ${maxBytes}); this ${kind} entry was not written`);
+}
+function queueFull(path, queued, maxQueuedBytes, kind) {
+    return new RangeError(`fileSink: ${path} has ${queued} bytes waiting (maxQueuedBytes ${maxQueuedBytes}); this ${kind} entry was dropped`);
+}
+/** A bound read off the options: absent → the default; else a whole number ≥ `min`, or a RangeError naming it. */
+function bound(name, value, fallback, min) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value < min) {
+        throw new RangeError(`fileSink: ${name} must be a whole number, at least ${min}`);
+    }
+    return value;
+}
+function tooLarge(path, kind, maxEntryBytes) {
+    return new RangeError(`fileSink: a ${kind} entry larger than maxEntryBytes (${maxEntryBytes}) was not written to ${path}`);
+}
+/** Write all of `buffer` at `position` (asynchronously, as many writes as it takes); `wrote` is how much went out. */
+function writeAt(fd, buffer, position, done) {
+    const step = (offset) => {
+        (0, node_fs_1.write)(fd, buffer, offset, buffer.length - offset, position + offset, (error, n) => {
+            if (error)
+                done(error, offset);
+            else if (n === 0)
+                done(new Error('fileSink: the disk took no bytes'), offset);
+            else if (offset + n < buffer.length)
+                step(offset + n);
+            else
+                done(null, buffer.length);
+        });
+    };
+    step(0);
+}
+/** `work`, or a rejection naming the bound once `ms` passed — the work goes on, nobody waits for it. */
+function withTimeout(work, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), ms);
+        // A timer that only bounds a wait never keeps the process alive on its own.
+        timer.unref?.();
+        Promise.prototype.then.call(work, () => {
+            clearTimeout(timer);
+            resolve();
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+/**
+ * Refuse a file someone else could read or rewrite behind the sink: a hard link (another name for the same bytes —
+ * the sink would append into it), a file owned by another user, or one others may write. A file the sink creates is
+ * `0o600` and passes; a pre-existing one must already be private to the writer. (Not on Windows, whose modes and
+ * owners do not map: there `O_NOFOLLOW` is absent too — the guide names both.)
+ */
+function refuseForeign(path, stat) {
+    if (stat.nlink > 1)
+        throw new TypeError(`fileSink: ${path} has other hard links — refusing to write through one`);
+    const uid = typeof node_process_1.getuid === 'function' ? (0, node_process_1.getuid)() : undefined;
+    if (uid !== undefined && stat.uid !== uid)
+        throw new TypeError(`fileSink: ${path} belongs to another user`);
+    if (uid !== undefined && (stat.mode & 0o022) !== 0) {
+        throw new TypeError(`fileSink: ${path} is writable by others — make it 0o600 (or remove it) first`);
+    }
+}
+/** Whether the file's last byte is a newline — read once, when the sink opens an existing file. */
+function endsWithNewline(fd, size) {
+    const last = new Uint8Array(1);
+    return (0, node_fs_1.readSync)(fd, last, 0, 1, size - 1) === 1 && last[0] === 0x0a;
+}
+/**
+ * Read a record file back, line by line — the entries for `readStoredRecord`, and every line that could not be
+ * read, by number, never a failed read. A stored key named `__proto__` stays data (`JSON.parse` makes it an own
+ * property). The file is untrusted: a file larger than `maxBytes` (default 256 MiB) is refused before it is read.
+ *
+ * @throws RangeError when the file is larger than `maxBytes`; the operating system's error when it cannot be read.
+ */
+function readRecordFile(path, options) {
+    if (typeof path !== 'string' || path === '')
+        throw new TypeError('readRecordFile: path must be a non-empty string');
+    const maxBytes = bound('maxBytes', options?.maxBytes, DEFAULT_READ_MAX_BYTES, 1);
+    // One descriptor for the check AND the read (a file that grows between them is still bounded); a regular file
+    // only (a FIFO would block, a device never end); at most `maxBytes` read.
+    // O_NONBLOCK: a FIFO at the path must not block the open before the regular-file check refuses it.
+    const fd = (0, node_fs_1.openSync)(path, node_fs_1.constants.O_RDONLY | (node_fs_1.constants.O_NOFOLLOW ?? 0) | (node_fs_1.constants.O_NONBLOCK ?? 0));
+    let raw;
+    try {
+        const stat = (0, node_fs_1.fstatSync)(fd);
+        if (!stat.isFile())
+            throw new TypeError(`readRecordFile: ${path} is not a regular file`);
+        if (stat.size > maxBytes) {
+            throw new RangeError(`readRecordFile: ${path} holds ${stat.size} bytes, past the limit of ${maxBytes}`);
+        }
+        const buffer = new Uint8Array(Math.min(stat.size, maxBytes) + 1);
+        let read = 0;
+        for (;;) {
+            const n = (0, node_fs_1.readSync)(fd, buffer, read, buffer.length - read, read);
+            if (n === 0)
+                break;
+            read += n;
+            if (read === buffer.length) {
+                throw new RangeError(`readRecordFile: ${path} grew past the limit of ${maxBytes} bytes while being read`);
+            }
+        }
+        raw = buffer.subarray(0, read);
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+    const text = new TextDecoder('utf-8').decode(raw);
+    const entries = [];
+    const unreadable = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        // A run of NUL bytes is a hole a cut-short write left before the next entry's offset: it ends the torn part,
+        // so the entry after it reads on its own (the same line number names both pieces).
+        const line = lines[i];
+        // A hole is reported, never skipped: bytes that never reached the disk may be a whole entry lost mid-file.
+        if (line.includes('\0'))
+            unreadable.push({ line: i + 1, reason: 'a hole — bytes that never reached the disk' });
+        for (const piece of line.split(/\0+/)) {
+            if (piece.trim() === '')
+                continue;
+            try {
+                entries.push(JSON.parse(piece));
+            }
+            catch {
+                unreadable.push({ line: i + 1, reason: 'not JSON — a torn or corrupt line' });
+            }
+        }
+    }
+    return { entries, unreadable };
+}
+exports.readRecordFile = readRecordFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileSink.js","sourceRoot":"","sources":["../../../src/lib/sinks/fileSink.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * sinks/fileSink.ts — the record, one JSON line per entry, in a file (design §3.5, §4, packet P6). NODE ONLY: the\n * one file in `src/` that imports a Node built-in, reachable only through the `footprintjs/sinks` door.\n *\n * WHY A FILE, WHY THIS SHAPE. A run's record must outlive the process that made it — a killed process, a crashed\n * host, a serverless freeze. Each entry the log hands over is encoded, checked and given its own offset in the file,\n * and its write is handed to the I/O pool AT ONCE (a positional write — no entry waits for the event loop to turn);\n * the pool's threads perform them while the main thread runs on. A process killed after a pool thread wrote an entry\n * keeps it. Until then it is not on disk: microseconds on a free pool, but the pool (4 threads by default) is shared\n * with DNS lookups, zlib, crypto and other fs work, so while it is busy the window is as long as that work — and since\n * writes complete out of order, a kill can lose an entry in the middle (the reader reports the hole). `flush()` waits for every write and\n * `fsync`s — the step that also survives the machine losing power, and the one the executor awaits after each run's\n * closing entry.\n *\n * THE THREAT MODEL, as code — every resource bounded, nothing that can stall the run:\n *   - ONLY THE PATH THE APP GIVES. Resolved once and opened once, at `fileSink(path)`; every entry goes to that open\n *     file. A symbolic link at the path is refused (`O_NOFOLLOW`, where the platform has it), and so is anything\n *     that is not a regular file, a file with another hard link, another owner, or group/world write. A file the\n *     sink creates is `0o600`.\n *   - ATOMIC PER ENTRY. A line is encoded in full first — an entry JSON cannot write (a `BigInt`, a cycle) is\n *     refused whole — then written at its own offset. A write that fails part-way leaves a hole up to the next\n *     entry's offset; the reader splits at it (NUL), so a torn line never swallows the one after it (an existing\n *     file with a torn tail gets a newline first).\n *   - BOUNDED: `maxEntryBytes` (one line, 8 MiB — refused by name, before it is encoded when its length already\n *     says so), `maxQueuedBytes` (accepted, not yet written, 16 MiB — past it an entry is DROPPED and counted, never\n *     buffered without limit), `maxBytes` (the file, 64 MiB — once full, every further entry is refused and counted;\n *     a closing entry may use a 64 KiB reserve so a full file can still say how the run ended), `flushTimeoutMs`\n *     (10 s — then `flush()` rejects). Every refusal throws from the sink method, which the log counts\n *     (`getSnapshot().sink`); a write that fails later rejects that entry's promise, counted the same way.\n *   - ASYNCHRONOUS WRITES ONLY. No method blocks on the disk; the file is released asynchronously, after every\n *     write and every started fsync.\n *   - NO SECRET ON DISK is the EXECUTOR's law, applied before any entry reaches an adapter (`runner/recordSink.ts`):\n *     this file writes what it is handed and reads nothing else.\n *   - ONE WRITER PER FILE. A second sink on a file this process has open is refused (by device and inode, across the\n *     CommonJS and ESM builds). ANOTHER PROCESS writing the same path is not seen at open: each writes at its own\n *     offsets and would overwrite the other. `flush()` checks the file's size against what this sink placed and rejects\n *     (a loss the run counts) when another writer's bytes reach past it — best effort: an overwrite this sink's own\n *     later writes cover is not seen. Give each process its own file.\n *\n * WHAT JSON KEEPS. A line holds what `JSON.stringify` keeps: a `Date` becomes its ISO string, a `Map` / `Set` an\n * empty object, `undefined` disappears. A record of plain JSON values reads back exactly (`readRecordFile` →\n * `readStoredRecord`); for richer values, bring an adapter with a richer encoding.\n */\n\nimport { close, closeSync, constants, fstat, fstatSync, fsync, openSync, readSync, write } from 'node:fs';\nimport { resolve as resolvePath } from 'node:path';\nimport { getuid } from 'node:process';\n\nimport type { RecordEntry, RecordSink } from 'foottrace/write';\n\n/** The default cap on a record file: 64 MiB. */\nexport const DEFAULT_FILE_SINK_MAX_BYTES = 64 * 1024 * 1024;\n/** The default cap on ONE entry's line: 8 MiB. */\nexport const DEFAULT_FILE_SINK_MAX_ENTRY_BYTES = 8 * 1024 * 1024;\n/** The default cap on bytes accepted but not yet written: 16 MiB. */\nexport const DEFAULT_FILE_SINK_MAX_QUEUED_BYTES = 16 * 1024 * 1024;\n/** The default bound on `flush()`: 10 s. */\nexport const DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS = 10_000;\n/** How far past `maxBytes` a CLOSING entry may still go, so a full file can say how the run ended: 64 KiB. */\nconst CLOSE_RESERVE_BYTES = 64 * 1024;\n/** The default cap `readRecordFile` reads: 256 MiB. */\nconst DEFAULT_READ_MAX_BYTES = 256 * 1024 * 1024;\n\n/** `fileSink`'s options — every resource the sink can spend, bounded. */\nexport interface FileSinkOptions {\n  /**\n   * The most bytes the file may hold (the bytes already in it count). Once an entry would pass it, the file is FULL:\n   * that entry and every later one is refused and counted by the run, never written — except a closing entry, which\n   * may use 64 KiB more so a full file can still say how the run ended. Default 64 MiB.\n   */\n  readonly maxBytes?: number;\n  /** The largest ONE entry's line may be; a larger entry is refused whole (`maxEntryBytes` named). Default 8 MiB. */\n  readonly maxEntryBytes?: number;\n  /**\n   * The most bytes accepted and not yet on disk. Writes are asynchronous, so a sink slower than the run queues; past\n   * this bound an entry is DROPPED and counted (never buffered without limit, never a stall). Default 16 MiB.\n   */\n  readonly maxQueuedBytes?: number;\n  /** How long `flush()` (drain the queue, then `fsync`) may take before it rejects. Default 10 s. */\n  readonly flushTimeoutMs?: number;\n}\n\n/** A record sink that appends to one file — `RecordSink` plus what the app needs to manage the file. */\nexport interface FileSink extends RecordSink {\n  /** The absolute path the sink writes to — resolved once, when it was made. */\n  readonly path: string;\n  /**\n   * Bytes this sink knows are on disk: the file's size when it opened plus every byte its writes completed — a\n   * running sum, not the file's end (writes complete out of order; a failed one leaves a hole).\n   */\n  readonly bytes: number;\n  /** Bytes accepted and not yet written. */\n  readonly queuedBytes: number;\n  /** `true` once an entry was refused for `maxBytes`: the file is full, and only a closing entry may still go. */\n  readonly full: boolean;\n  /**\n   * Release the file. Idempotent. Every entry after it is refused (the run counts it), and `flush()` rejects;\n   * entries already accepted are still written (and a flush already started finishes), then the file is closed —\n   * the promise settles then.\n   */\n  close(): Promise<void>;\n}\n\n/**\n * A record sink that appends each entry to `path` as one JSON line — the crash-safe record on a Node host.\n *\n * Every method returns at once: the line is encoded, checked against every bound, given its offset and handed to\n * the I/O pool. The method's promise settles when that line is written; a write that fails rejects it, and the run\n * counts the loss.\n *\n * @throws TypeError when `path` is not a non-empty string or does not name a regular file the writer owns alone;\n *   RangeError for a bound that is not a whole number ≥ 1; the operating system's error when\n *   the file cannot be opened (a symbolic link at `path` included). Made once, at setup — never during a run.\n *\n * @example\n * ```typescript\n * import { fileSink, readRecordFile } from 'footprintjs/sinks';\n * import { readStoredRecord } from 'foottrace';\n *\n * const sink = fileSink('/var/footprint/orders.jsonl');\n * const executor = new FlowChartExecutor(chart, { sink });\n * await executor.run({ input });\n * // …later, or after a crash:\n * const record = readStoredRecord(readRecordFile('/var/footprint/orders.jsonl').entries);\n * record.root(runId)?.complete; // false for a run that never ended\n * ```\n */\nexport function fileSink(path: string, options?: FileSinkOptions): FileSink {\n  if (typeof path !== 'string' || path === '') throw new TypeError('fileSink: path must be a non-empty string');\n  const maxBytes = bound('maxBytes', options?.maxBytes, DEFAULT_FILE_SINK_MAX_BYTES, 1);\n  const maxEntryBytes = bound('maxEntryBytes', options?.maxEntryBytes, DEFAULT_FILE_SINK_MAX_ENTRY_BYTES, 1);\n  const maxQueuedBytes = bound('maxQueuedBytes', options?.maxQueuedBytes, DEFAULT_FILE_SINK_MAX_QUEUED_BYTES, 1);\n  const flushTimeoutMs = bound('flushTimeoutMs', options?.flushTimeoutMs, DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS, 1);\n  const absolute = resolvePath(path);\n  // NOT `O_APPEND`: each entry is written at the offset it was given when it was queued (a positional write), so\n  // every entry is handed to the I/O pool the moment it is accepted — none waits for the event loop to turn.\n  const fd = openSync(absolute, constants.O_RDWR | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0), 0o600);\n  let identity: string;\n  let size: number;\n  let needsNewline: boolean; // the file ends with a torn line: the first entry starts a new one\n  try {\n    const stat = fstatSync(fd);\n    if (!stat.isFile()) throw new TypeError(`fileSink: ${absolute} is not a regular file`);\n    refuseForeign(absolute, stat);\n    identity = `${stat.dev}:${stat.ino}`;\n    // One writer per file, in this process: a second sink would place its entries over the first's.\n    if (OPEN_FILES.has(identity)) throw new TypeError(`fileSink: ${absolute} already has an open sink in this process`);\n    size = stat.size;\n    needsNewline = size > 0 && !endsWithNewline(fd, size);\n  } catch (error) {\n    closeSync(fd);\n    throw error;\n  }\n  OPEN_FILES.add(identity);\n\n  const encoder = new TextEncoder();\n  let next = size; // the offset the next accepted entry is written at — what `maxBytes` bounds\n  let written = size; // bytes known on disk\n  let queuedBytes = 0; // accepted, not yet written (in the I/O pool's hands)\n  let inFlight = 0;\n  let syncing = 0;\n  let full = false;\n  let closing = false;\n  let released = false;\n  let drained: (() => void)[] = [];\n  let closedSignal: (() => void) | undefined;\n  const whenReleased = new Promise<void>((resolve) => (closedSignal = resolve));\n\n  /** Release the file once nothing is in flight and no fsync is pending — asynchronously; an error is ignored. */\n  const releaseIfIdle = (): void => {\n    if (!closing || released || inFlight > 0 || syncing > 0) return;\n    released = true;\n    OPEN_FILES.delete(identity);\n    close(fd, () => closedSignal?.());\n  };\n\n  /** Everything accepted is written: start each waiting flush's fsync, then release if closing. */\n  const settleDrained = (): void => {\n    if (inFlight > 0) return;\n    const waiting = drained;\n    drained = [];\n    for (const start of waiting) start();\n    releaseIfIdle();\n  };\n\n  /** One entry: refused whole with a named bound (the log counts it), or submitted — never in part, never blocking. */\n  const enqueue = (entry: RecordEntry): Promise<void> => {\n    if (closing) throw new Error(`fileSink: ${absolute} is closed`);\n    // The cheap refusals first: a full file or a full queue costs no encoding.\n    if (full && entry.kind !== 'closed') throw fileFull(absolute, maxBytes, entry.kind);\n    // A closing entry is exempt from the queue bound (as from `maxBytes`, within its reserve): how a log ended is\n    // the one entry a full queue must not drop.\n    const isClosingEntry = entry.kind === 'closed';\n    if (!isClosingEntry && queuedBytes >= maxQueuedBytes)\n      throw queueFull(absolute, queuedBytes, maxQueuedBytes, entry.kind);\n    const json = JSON.stringify(entry); // an entry JSON cannot write (a BigInt, a cycle) throws here, whole\n    // A string's length never exceeds its UTF-8 size: an entry already too long is refused before it is encoded.\n    if (json.length + 1 > maxEntryBytes) throw tooLarge(absolute, entry.kind, maxEntryBytes);\n    const encoded = encoder.encode(`${needsNewline ? '\\n' : ''}${json}\\n`);\n    if (encoded.length > maxEntryBytes + 1) throw tooLarge(absolute, entry.kind, maxEntryBytes);\n    const limit = entry.kind === 'closed' ? maxBytes + CLOSE_RESERVE_BYTES : maxBytes;\n    if (next + encoded.length > limit) {\n      if (entry.kind !== 'closed') full = true;\n      throw fileFull(absolute, maxBytes, entry.kind);\n    }\n    if (!isClosingEntry && queuedBytes + encoded.length > maxQueuedBytes) {\n      throw queueFull(absolute, queuedBytes, maxQueuedBytes, entry.kind);\n    }\n    needsNewline = false;\n    const at = next;\n    next += encoded.length;\n    queuedBytes += encoded.length;\n    inFlight += 1;\n    return new Promise<void>((resolve, reject) => {\n      writeAt(fd, encoded, at, (error, wrote) => {\n        inFlight -= 1;\n        queuedBytes -= encoded.length;\n        written += wrote;\n        // A line cut short leaves a hole up to the next entry's offset: the reader splits at it (NUL), so a torn\n        // line never swallows the entry after it.\n        if (error) reject(error);\n        else resolve();\n        settleDrained();\n      });\n    });\n  };\n\n  return {\n    path: absolute,\n    get bytes() {\n      return written;\n    },\n    get queuedBytes() {\n      return queuedBytes;\n    },\n    get full() {\n      return full;\n    },\n    opened: ({ address, at, initialState, meta }) =>\n      enqueue({ kind: 'opened', address, at, initialState, ...(meta === undefined ? {} : { meta }) }),\n    commit: ({ address, at, bundle }) => enqueue({ kind: 'commit', address, at, bundle }),\n    note: ({ address, at, kind, data }) => enqueue({ kind: 'note', address, at, note: kind, data }),\n    closed: ({ address, at, outcome, commits, meta }) =>\n      enqueue({ kind: 'closed', address, at, outcome, commits, ...(meta === undefined ? {} : { meta }) }),\n    flush: () => {\n      if (closing) return Promise.reject(new Error(`fileSink: ${absolute} is closed`));\n      const work = new Promise<void>((resolve, reject) => {\n        drained.push(() => {\n          syncing += 1;\n          fsync(fd, (error) => {\n            if (error) {\n              syncing -= 1;\n              reject(error);\n              releaseIfIdle();\n              return;\n            }\n            // Another writer (another process on the same path) grew the file past what this sink placed: its\n            // entries and ours overlap. Said, never silent.\n            fstat(fd, (statError, stat) => {\n              syncing -= 1;\n              if (statError) reject(statError);\n              else if (stat.size > next) {\n                reject(new Error(`fileSink: ${absolute} was written by another writer (one sink per file)`));\n              } else resolve();\n              releaseIfIdle();\n            });\n          });\n        });\n        settleDrained();\n      });\n      return withTimeout(\n        work,\n        flushTimeoutMs,\n        `fileSink: flush() of ${absolute} did not finish in ${flushTimeoutMs}ms`,\n      );\n    },\n    close: () => {\n      if (!closing) {\n        closing = true;\n        releaseIfIdle();\n      }\n      return whenReleased;\n    },\n  };\n}\n\n/**\n * Files a sink of this process has open, by device and inode — one writer per file. Kept on the global object, so\n * the package's CommonJS and ESM builds (two module instances in one process) share it.\n */\nconst OPEN_FILES: Set<string> = ((globalThis as Record<symbol, unknown>)[Symbol.for('footprintjs.fileSink.open')] ??=\n  new Set<string>()) as Set<string>;\n\nfunction fileFull(path: string, maxBytes: number, kind: string): RangeError {\n  return new RangeError(`fileSink: ${path} is full (maxBytes ${maxBytes}); this ${kind} entry was not written`);\n}\n\nfunction queueFull(path: string, queued: number, maxQueuedBytes: number, kind: string): RangeError {\n  return new RangeError(\n    `fileSink: ${path} has ${queued} bytes waiting (maxQueuedBytes ${maxQueuedBytes}); this ${kind} entry was dropped`,\n  );\n}\n\n/** A bound read off the options: absent → the default; else a whole number ≥ `min`, or a RangeError naming it. */\nfunction bound(name: string, value: number | undefined, fallback: number, min: number): number {\n  if (value === undefined) return fallback;\n  if (!Number.isSafeInteger(value) || value < min) {\n    throw new RangeError(`fileSink: ${name} must be a whole number, at least ${min}`);\n  }\n  return value;\n}\n\nfunction tooLarge(path: string, kind: string, maxEntryBytes: number): RangeError {\n  return new RangeError(\n    `fileSink: a ${kind} entry larger than maxEntryBytes (${maxEntryBytes}) was not written to ${path}`,\n  );\n}\n\n/** Write all of `buffer` at `position` (asynchronously, as many writes as it takes); `wrote` is how much went out. */\nfunction writeAt(\n  fd: number,\n  buffer: Uint8Array,\n  position: number,\n  done: (error: Error | null, wrote: number) => void,\n): void {\n  const step = (offset: number): void => {\n    write(fd, buffer, offset, buffer.length - offset, position + offset, (error, n) => {\n      if (error) done(error, offset);\n      else if (n === 0) done(new Error('fileSink: the disk took no bytes'), offset);\n      else if (offset + n < buffer.length) step(offset + n);\n      else done(null, buffer.length);\n    });\n  };\n  step(0);\n}\n\n/** `work`, or a rejection naming the bound once `ms` passed — the work goes on, nobody waits for it. */\nfunction withTimeout(work: Promise<void>, ms: number, message: string): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    const timer = setTimeout(() => reject(new Error(message)), ms);\n    // A timer that only bounds a wait never keeps the process alive on its own.\n    (timer as { unref?: () => void }).unref?.();\n    Promise.prototype.then.call(\n      work,\n      () => {\n        clearTimeout(timer);\n        resolve();\n      },\n      (error: unknown) => {\n        clearTimeout(timer);\n        reject(error);\n      },\n    );\n  });\n}\n\n/**\n * Refuse a file someone else could read or rewrite behind the sink: a hard link (another name for the same bytes —\n * the sink would append into it), a file owned by another user, or one others may write. A file the sink creates is\n * `0o600` and passes; a pre-existing one must already be private to the writer. (Not on Windows, whose modes and\n * owners do not map: there `O_NOFOLLOW` is absent too — the guide names both.)\n */\nfunction refuseForeign(path: string, stat: { readonly nlink: number; readonly uid: number; readonly mode: number }) {\n  if (stat.nlink > 1) throw new TypeError(`fileSink: ${path} has other hard links — refusing to write through one`);\n  const uid = typeof getuid === 'function' ? getuid() : undefined;\n  if (uid !== undefined && stat.uid !== uid) throw new TypeError(`fileSink: ${path} belongs to another user`);\n  if (uid !== undefined && (stat.mode & 0o022) !== 0) {\n    throw new TypeError(`fileSink: ${path} is writable by others — make it 0o600 (or remove it) first`);\n  }\n}\n\n/** Whether the file's last byte is a newline — read once, when the sink opens an existing file. */\nfunction endsWithNewline(fd: number, size: number): boolean {\n  const last = new Uint8Array(1);\n  return readSync(fd, last, 0, 1, size - 1) === 1 && last[0] === 0x0a;\n}\n\n/** A record file read back: every parsed line, and every line that could not be. */\nexport interface RecordFile {\n  /** The parsed entries, in file order — untrusted input for `readStoredRecord` (`foottrace`). */\n  readonly entries: readonly unknown[];\n  /** Each line that is not JSON (a torn last line, a corrupt one), by its 1-based number. Blank lines are skipped. */\n  readonly unreadable: readonly { readonly line: number; readonly reason: string }[];\n}\n\n/**\n * Read a record file back, line by line — the entries for `readStoredRecord`, and every line that could not be\n * read, by number, never a failed read. A stored key named `__proto__` stays data (`JSON.parse` makes it an own\n * property). The file is untrusted: a file larger than `maxBytes` (default 256 MiB) is refused before it is read.\n *\n * @throws RangeError when the file is larger than `maxBytes`; the operating system's error when it cannot be read.\n */\nexport function readRecordFile(path: string, options?: { readonly maxBytes?: number }): RecordFile {\n  if (typeof path !== 'string' || path === '') throw new TypeError('readRecordFile: path must be a non-empty string');\n  const maxBytes = bound('maxBytes', options?.maxBytes, DEFAULT_READ_MAX_BYTES, 1);\n  // One descriptor for the check AND the read (a file that grows between them is still bounded); a regular file\n  // only (a FIFO would block, a device never end); at most `maxBytes` read.\n  // O_NONBLOCK: a FIFO at the path must not block the open before the regular-file check refuses it.\n  const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));\n  let raw: Uint8Array;\n  try {\n    const stat = fstatSync(fd);\n    if (!stat.isFile()) throw new TypeError(`readRecordFile: ${path} is not a regular file`);\n    if (stat.size > maxBytes) {\n      throw new RangeError(`readRecordFile: ${path} holds ${stat.size} bytes, past the limit of ${maxBytes}`);\n    }\n    const buffer = new Uint8Array(Math.min(stat.size, maxBytes) + 1);\n    let read = 0;\n    for (;;) {\n      const n = readSync(fd, buffer, read, buffer.length - read, read);\n      if (n === 0) break;\n      read += n;\n      if (read === buffer.length) {\n        throw new RangeError(`readRecordFile: ${path} grew past the limit of ${maxBytes} bytes while being read`);\n      }\n    }\n    raw = buffer.subarray(0, read);\n  } finally {\n    closeSync(fd);\n  }\n  const text = new TextDecoder('utf-8').decode(raw);\n  const entries: unknown[] = [];\n  const unreadable: { line: number; reason: string }[] = [];\n  const lines = text.split('\\n');\n  for (let i = 0; i < lines.length; i++) {\n    // A run of NUL bytes is a hole a cut-short write left before the next entry's offset: it ends the torn part,\n    // so the entry after it reads on its own (the same line number names both pieces).\n    const line = lines[i];\n    // A hole is reported, never skipped: bytes that never reached the disk may be a whole entry lost mid-file.\n    if (line.includes('\\0')) unreadable.push({ line: i + 1, reason: 'a hole — bytes that never reached the disk' });\n    for (const piece of line.split(/\\0+/)) {\n      if (piece.trim() === '') continue;\n      try {\n        entries.push(JSON.parse(piece));\n      } catch {\n        unreadable.push({ line: i + 1, reason: 'not JSON — a torn or corrupt line' });\n      }\n    }\n  }\n  return { entries, unreadable };\n}\n"]}

package/dist/recorders.js

@@ -25,7 +25,7 @@
  * Pass directly to chart.recorder(). No wrapping, no proxying -- just the class + shortcuts.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeRecorder = exports.windowed = exports.milestone = exports.adaptive = exports.manifest = exports.debug = exports.metrics = exports.narrative = void 0;
+exports.attempts = exports.CompositeRecorder = exports.memoryStore = exports.windowed = exports.milestone = exports.adaptive = exports.manifest = exports.debug = exports.metrics = exports.narrative = void 0;
 const CombinedNarrativeRecorder_js_1 = require("./lib/engine/narrative/CombinedNarrativeRecorder.js");
 const AdaptiveNarrativeFlowRecorder_js_1 = require("./lib/engine/narrative/recorders/AdaptiveNarrativeFlowRecorder.js");
 const ManifestFlowRecorder_js_1 = require("./lib/engine/narrative/recorders/ManifestFlowRecorder.js");
@@ -86,6 +86,14 @@ function windowed(maxEntries) {
     return new WindowedNarrativeFlowRecorder_js_1.WindowedNarrativeFlowRecorder(maxEntries);
 }
 exports.windowed = windowed;
+var AttemptRecorder_js_1 = require("./lib/recorder/AttemptRecorder.js");
+Object.defineProperty(exports, "memoryStore", { enumerable: true, get: function () { return AttemptRecorder_js_1.memoryStore; } });
 var index_js_1 = require("./lib/recorder/index.js");
 Object.defineProperty(exports, "CompositeRecorder", { enumerable: true, get: function () { return index_js_1.CompositeRecorder; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorders.js","sourceRoot":"","sources":["../src/recorders.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;GAOG;;;AAGH,sGAAgG;AAehG,wHAAkH;AAElH,sGAAgG;AAChG,0HAAoH;AACpH,wHAAkH;AAGlH,6EAAuE;AAEvE,+EAAyE;AAezE,SAAgB,SAAS,CAAC,OAA0C;IAClE,OAAO,IAAI,wDAAyB,CAAC,OAAO,CAAC,CAAC;AAChD,CAAC;AAFD,8BAEC;AAYD,SAAgB,OAAO,CAAC,OAA+B;IACrD,MAAM,GAAG,GAAG,IAAI,kCAAc,CAAC,OAAO,CAAoB,CAAC;IAC3D,GAAG,CAAC,KAAK,GAAG;QACV,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC;IACtC,CAAC,CAAC;IACF,GAAG,CAAC,MAAM,GAAG;QACX,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC;IACvC,CAAC,CAAC;IACF,GAAG,CAAC,OAAO,GAAG;QACZ,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,YAAY,CAAC;IACxC,CAAC,CAAC;IACF,GAAG,CAAC,KAAK,GAAG,UAAgC,IAAY;QACtD,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC,CAAC;IACF,GAAG,CAAC,GAAG,GAAG;QACR,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC,CAAC;IACF,OAAO,GAAG,CAAC;AACb,CAAC;AAlBD,0BAkBC;AAQD,SAAgB,KAAK,CAAC,OAA8B;IAClD,MAAM,GAAG,GAAG,IAAI,gCAAa,CAAC,OAAO,CAAkB,CAAC;IACxD,GAAG,CAAC,IAAI,GAAG;QACT,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC,CAAC;IACF,OAAO,GAAG,CAAC;AACb,CAAC;AAND,sBAMC;AAQD,SAAgB,QAAQ;IACtB,MAAM,GAAG,GAAG,IAAI,8CAAoB,EAAsB,CAAC;IAC3D,GAAG,CAAC,OAAO,GAAG;QACZ,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC,CAAC;IACF,OAAO,GAAG,CAAC;AACb,CAAC;AAND,4BAMC;AAED,qCAAqC;AAErC,SAAgB,QAAQ;IACtB,OAAO,IAAI,gEAA6B,EAAE,CAAC;AAC7C,CAAC;AAFD,4BAEC;AACD,SAAgB,SAAS;IACvB,OAAO,IAAI,kEAA8B,EAAE,CAAC;AAC9C,CAAC;AAFD,8BAEC;AACD,SAAgB,QAAQ,CAAC,UAAmB;IAC1C,OAAO,IAAI,gEAA6B,CAAC,UAAU,CAAC,CAAC;AACvD,CAAC;AAFD,4BAEC;AAqBD,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA","sourcesContent":["/**\n * footprintjs/recorders — Factory functions for built-in recorders.\n *\n * Prefer these factory functions over constructing recorder classes directly.\n * Each factory returns the recorder instance enriched with short convenience methods.\n *\n * ```ts\n * import { narrative, metrics, debug, manifest } from 'footprintjs/recorders';\n *\n * const result = await chart\n *   .recorder(narrative())\n *   .recorder(metrics())\n *   .run();\n * ```\n *\n * @module recorders\n */\n/**\n * footprintjs/recorders -- Factory functions for built-in recorders.\n *\n * Import: import { narrative, metrics, debug, manifest } from 'footprintjs/recorders';\n *\n * Each factory returns the raw recorder instance with added short convenience methods.\n * Pass directly to chart.recorder(). No wrapping, no proxying -- just the class + shortcuts.\n */\n\nimport type { CombinedNarrativeRecorderOptions } from './lib/engine/narrative/CombinedNarrativeRecorder.js';\nimport { CombinedNarrativeRecorder } from './lib/engine/narrative/CombinedNarrativeRecorder.js';\nimport type {\n  BreakRenderContext,\n  CombinedNarrativeEntry,\n  DecisionRenderContext,\n  EmitRenderContext,\n  ErrorRenderContext,\n  ForkRenderContext,\n  LoopRenderContext,\n  NarrativeFormatter,\n  OpRenderContext,\n  SelectedRenderContext,\n  StageRenderContext,\n  SubflowRenderContext,\n} from './lib/engine/narrative/narrativeTypes.js';\nimport { AdaptiveNarrativeFlowRecorder } from './lib/engine/narrative/recorders/AdaptiveNarrativeFlowRecorder.js';\nimport type { ManifestEntry } from './lib/engine/narrative/recorders/ManifestFlowRecorder.js';\nimport { ManifestFlowRecorder } from './lib/engine/narrative/recorders/ManifestFlowRecorder.js';\nimport { MilestoneNarrativeFlowRecorder } from './lib/engine/narrative/recorders/MilestoneNarrativeFlowRecorder.js';\nimport { WindowedNarrativeFlowRecorder } from './lib/engine/narrative/recorders/WindowedNarrativeFlowRecorder.js';\nimport type { EmitEvent, EmitRecorder } from './lib/recorder/EmitRecorder.js';\nimport type { DebugEntry, DebugRecorderOptions } from './lib/scope/recorders/DebugRecorder.js';\nimport { DebugRecorder } from './lib/scope/recorders/DebugRecorder.js';\nimport type { AggregatedMetrics, MetricRecorderOptions, StageMetrics } from './lib/scope/recorders/MetricRecorder.js';\nimport { MetricRecorder } from './lib/scope/recorders/MetricRecorder.js';\n\n// ---- Narrative ----\n\n/**\n * ScopeRecorder factory for combined flow+data narrative.\n *\n * The returned recorder is a `CombinedNarrativeRecorder` — attach it to a\n * chart/executor, then read structured entries via `.getEntries()` after\n * the run. For flat strings, call `.getEntries().map(e => e.text)` locally.\n * Each instance has its own generated ID; detach using `recorder.id`.\n * Its formatting options affect this instance, not the executor's own view.\n */\nexport type NarrativeInstance = CombinedNarrativeRecorder;\n\nexport function narrative(options?: CombinedNarrativeRecorderOptions): NarrativeInstance {\n  return new CombinedNarrativeRecorder(options);\n}\n\n// ---- Metrics ----\n\nexport type MetricsInstance = MetricRecorder & {\n  reads(): number;\n  writes(): number;\n  commits(): number;\n  stage(name: string): StageMetrics | undefined;\n  all(): AggregatedMetrics;\n};\n\nexport function metrics(options?: MetricRecorderOptions): MetricsInstance {\n  const rec = new MetricRecorder(options) as MetricsInstance;\n  rec.reads = function (this: MetricRecorder) {\n    return this.getMetrics().totalReads;\n  };\n  rec.writes = function (this: MetricRecorder) {\n    return this.getMetrics().totalWrites;\n  };\n  rec.commits = function (this: MetricRecorder) {\n    return this.getMetrics().totalCommits;\n  };\n  rec.stage = function (this: MetricRecorder, name: string) {\n    return this.getStageMetrics(name);\n  };\n  rec.all = function (this: MetricRecorder) {\n    return this.getMetrics();\n  };\n  return rec;\n}\n\n// ---- Debug ----\n\nexport type DebugInstance = DebugRecorder & {\n  logs(): DebugEntry[];\n};\n\nexport function debug(options?: DebugRecorderOptions): DebugInstance {\n  const rec = new DebugRecorder(options) as DebugInstance;\n  rec.logs = function (this: DebugRecorder) {\n    return this.getEntries();\n  };\n  return rec;\n}\n\n// ---- Manifest ----\n\nexport type ManifestInstance = ManifestFlowRecorder & {\n  entries(): ManifestEntry[];\n};\n\nexport function manifest(): ManifestInstance {\n  const rec = new ManifestFlowRecorder() as ManifestInstance;\n  rec.entries = function (this: ManifestFlowRecorder) {\n    return this.getManifest();\n  };\n  return rec;\n}\n\n// ---- Flow recorder strategies ----\n\nexport function adaptive() {\n  return new AdaptiveNarrativeFlowRecorder();\n}\nexport function milestone() {\n  return new MilestoneNarrativeFlowRecorder();\n}\nexport function windowed(maxEntries?: number) {\n  return new WindowedNarrativeFlowRecorder(maxEntries);\n}\n\n// ---- Re-exported types ----\nexport type {\n  BreakRenderContext,\n  CombinedNarrativeRecorderOptions,\n  DecisionRenderContext,\n  EmitEvent,\n  EmitRecorder,\n  EmitRenderContext,\n  ErrorRenderContext,\n  ForkRenderContext,\n  LoopRenderContext,\n  NarrativeFormatter,\n  OpRenderContext,\n  SelectedRenderContext,\n  StageRenderContext,\n  SubflowRenderContext,\n};\nexport type { AggregatedMetrics, MetricRecorderOptions, StageMetrics };\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\nexport { CompositeRecorder } from './lib/recorder/index.js';\n"]}
+const AttemptRecorder_js_2 = require("./lib/recorder/AttemptRecorder.js");
+/** Collect payload-free attempts during traversal; storage adapters are optional and provider-neutral. */
+function attempts(options) {
+    return new AttemptRecorder_js_2.AttemptRecorder(options);
+}
+exports.attempts = attempts;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorders.js","sourceRoot":"","sources":["../src/recorders.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;GAOG;;;AAGH,sGAAgG;AAgBhG,wHAAkH;AAElH,sGAAgG;AAChG,0HAAoH;AACpH,wHAAkH;AAGlH,6EAAuE;AAEvE,+EAAyE;AAezE,SAAgB,SAAS,CAAC,OAA0C;IAClE,OAAO,IAAI,wDAAyB,CAAC,OAAO,CAAC,CAAC;AAChD,CAAC;AAFD,8BAEC;AAYD,SAAgB,OAAO,CAAC,OAA+B;IACrD,MAAM,GAAG,GAAG,IAAI,kCAAc,CAAC,OAAO,CAAoB,CAAC;IAC3D,GAAG,CAAC,KAAK,GAAG;QACV,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC;IACtC,CAAC,CAAC;IACF,GAAG,CAAC,MAAM,GAAG;QACX,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC;IACvC,CAAC,CAAC;IACF,GAAG,CAAC,OAAO,GAAG;QACZ,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,YAAY,CAAC;IACxC,CAAC,CAAC;IACF,GAAG,CAAC,KAAK,GAAG,UAAgC,IAAY;QACtD,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC,CAAC;IACF,GAAG,CAAC,GAAG,GAAG;QACR,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC,CAAC;IACF,OAAO,GAAG,CAAC;AACb,CAAC;AAlBD,0BAkBC;AAQD,SAAgB,KAAK,CAAC,OAA8B;IAClD,MAAM,GAAG,GAAG,IAAI,gCAAa,CAAC,OAAO,CAAkB,CAAC;IACxD,GAAG,CAAC,IAAI,GAAG;QACT,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC,CAAC;IACF,OAAO,GAAG,CAAC;AACb,CAAC;AAND,sBAMC;AAQD,SAAgB,QAAQ;IACtB,MAAM,GAAG,GAAG,IAAI,8CAAoB,EAAsB,CAAC;IAC3D,GAAG,CAAC,OAAO,GAAG;QACZ,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC,CAAC;IACF,OAAO,GAAG,CAAC;AACb,CAAC;AAND,4BAMC;AAED,qCAAqC;AAErC,SAAgB,QAAQ;IACtB,OAAO,IAAI,gEAA6B,EAAE,CAAC;AAC7C,CAAC;AAFD,4BAEC;AACD,SAAgB,SAAS;IACvB,OAAO,IAAI,kEAA8B,EAAE,CAAC;AAC9C,CAAC;AAFD,8BAEC;AACD,SAAgB,QAAQ,CAAC,UAAmB;IAC1C,OAAO,IAAI,gEAA6B,CAAC,UAAU,CAAC,CAAC;AACvD,CAAC;AAFD,4BAEC;AAmCD,wEAAgE;AAAvD,iHAAA,WAAW,OAAA;AAEpB,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAE1B,0EAAoE;AACpE,0GAA0G;AAC1G,SAAgB,QAAQ,CAAC,OAAgC;IACvD,OAAO,IAAI,oCAAe,CAAC,OAAO,CAAC,CAAC;AACtC,CAAC;AAFD,4BAEC","sourcesContent":["/**\n * footprintjs/recorders — Factory functions for built-in recorders.\n *\n * Prefer these factory functions over constructing recorder classes directly.\n * Each factory returns the recorder instance enriched with short convenience methods.\n *\n * ```ts\n * import { narrative, metrics, debug, manifest } from 'footprintjs/recorders';\n *\n * const result = await chart\n *   .recorder(narrative())\n *   .recorder(metrics())\n *   .run();\n * ```\n *\n * @module recorders\n */\n/**\n * footprintjs/recorders -- Factory functions for built-in recorders.\n *\n * Import: import { narrative, metrics, debug, manifest } from 'footprintjs/recorders';\n *\n * Each factory returns the raw recorder instance with added short convenience methods.\n * Pass directly to chart.recorder(). No wrapping, no proxying -- just the class + shortcuts.\n */\n\nimport type { CombinedNarrativeRecorderOptions } from './lib/engine/narrative/CombinedNarrativeRecorder.js';\nimport { CombinedNarrativeRecorder } from './lib/engine/narrative/CombinedNarrativeRecorder.js';\nimport type {\n  AttemptRenderContext,\n  BreakRenderContext,\n  CombinedNarrativeEntry,\n  DecisionRenderContext,\n  EmitRenderContext,\n  ErrorRenderContext,\n  ForkRenderContext,\n  LoopRenderContext,\n  NarrativeFormatter,\n  OpRenderContext,\n  SelectedRenderContext,\n  StageRenderContext,\n  SubflowRenderContext,\n} from './lib/engine/narrative/narrativeTypes.js';\nimport { AdaptiveNarrativeFlowRecorder } from './lib/engine/narrative/recorders/AdaptiveNarrativeFlowRecorder.js';\nimport type { ManifestEntry } from './lib/engine/narrative/recorders/ManifestFlowRecorder.js';\nimport { ManifestFlowRecorder } from './lib/engine/narrative/recorders/ManifestFlowRecorder.js';\nimport { MilestoneNarrativeFlowRecorder } from './lib/engine/narrative/recorders/MilestoneNarrativeFlowRecorder.js';\nimport { WindowedNarrativeFlowRecorder } from './lib/engine/narrative/recorders/WindowedNarrativeFlowRecorder.js';\nimport type { EmitEvent, EmitRecorder } from './lib/recorder/EmitRecorder.js';\nimport type { DebugEntry, DebugRecorderOptions } from './lib/scope/recorders/DebugRecorder.js';\nimport { DebugRecorder } from './lib/scope/recorders/DebugRecorder.js';\nimport type { AggregatedMetrics, MetricRecorderOptions, StageMetrics } from './lib/scope/recorders/MetricRecorder.js';\nimport { MetricRecorder } from './lib/scope/recorders/MetricRecorder.js';\n\n// ---- Narrative ----\n\n/**\n * ScopeRecorder factory for combined flow+data narrative.\n *\n * The returned recorder is a `CombinedNarrativeRecorder` — attach it to a\n * chart/executor, then read structured entries via `.getEntries()` after\n * the run. For flat strings, call `.getEntries().map(e => e.text)` locally.\n * Each instance has its own generated ID; detach using `recorder.id`.\n * Its formatting options affect this instance, not the executor's own view.\n */\nexport type NarrativeInstance = CombinedNarrativeRecorder;\n\nexport function narrative(options?: CombinedNarrativeRecorderOptions): NarrativeInstance {\n  return new CombinedNarrativeRecorder(options);\n}\n\n// ---- Metrics ----\n\nexport type MetricsInstance = MetricRecorder & {\n  reads(): number;\n  writes(): number;\n  commits(): number;\n  stage(name: string): StageMetrics | undefined;\n  all(): AggregatedMetrics;\n};\n\nexport function metrics(options?: MetricRecorderOptions): MetricsInstance {\n  const rec = new MetricRecorder(options) as MetricsInstance;\n  rec.reads = function (this: MetricRecorder) {\n    return this.getMetrics().totalReads;\n  };\n  rec.writes = function (this: MetricRecorder) {\n    return this.getMetrics().totalWrites;\n  };\n  rec.commits = function (this: MetricRecorder) {\n    return this.getMetrics().totalCommits;\n  };\n  rec.stage = function (this: MetricRecorder, name: string) {\n    return this.getStageMetrics(name);\n  };\n  rec.all = function (this: MetricRecorder) {\n    return this.getMetrics();\n  };\n  return rec;\n}\n\n// ---- Debug ----\n\nexport type DebugInstance = DebugRecorder & {\n  logs(): DebugEntry[];\n};\n\nexport function debug(options?: DebugRecorderOptions): DebugInstance {\n  const rec = new DebugRecorder(options) as DebugInstance;\n  rec.logs = function (this: DebugRecorder) {\n    return this.getEntries();\n  };\n  return rec;\n}\n\n// ---- Manifest ----\n\nexport type ManifestInstance = ManifestFlowRecorder & {\n  entries(): ManifestEntry[];\n};\n\nexport function manifest(): ManifestInstance {\n  const rec = new ManifestFlowRecorder() as ManifestInstance;\n  rec.entries = function (this: ManifestFlowRecorder) {\n    return this.getManifest();\n  };\n  return rec;\n}\n\n// ---- Flow recorder strategies ----\n\nexport function adaptive() {\n  return new AdaptiveNarrativeFlowRecorder();\n}\nexport function milestone() {\n  return new MilestoneNarrativeFlowRecorder();\n}\nexport function windowed(maxEntries?: number) {\n  return new WindowedNarrativeFlowRecorder(maxEntries);\n}\n\n// ---- Re-exported types ----\nexport type {\n  AttemptRenderContext,\n  BreakRenderContext,\n  CombinedNarrativeRecorderOptions,\n  DecisionRenderContext,\n  EmitEvent,\n  EmitRecorder,\n  EmitRenderContext,\n  ErrorRenderContext,\n  ForkRenderContext,\n  LoopRenderContext,\n  NarrativeFormatter,\n  OpRenderContext,\n  SelectedRenderContext,\n  StageRenderContext,\n  SubflowRenderContext,\n};\nexport type { AggregatedMetrics, MetricRecorderOptions, StageMetrics };\nexport type {\n  AttemptAggregate,\n  AttemptDecisionRow,\n  AttemptMetricRef,\n  AttemptQuery,\n  AttemptRecorderOptions,\n  AttemptRow,\n  AttemptRunRow,\n  AttemptRunStats,\n  AttemptStats,\n  AttemptStorageStats,\n  AttemptStore,\n  PhysicalAttemptRow,\n} from './lib/recorder/attemptMetricsTypes.js';\nexport { memoryStore } from './lib/recorder/AttemptRecorder.js';\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\nexport { CompositeRecorder } from './lib/recorder/index.js';\nimport type { AttemptRecorderOptions } from './lib/recorder/attemptMetricsTypes.js';\nimport { AttemptRecorder } from './lib/recorder/AttemptRecorder.js';\n/** Collect payload-free attempts during traversal; storage adapters are optional and provider-neutral. */\nexport function attempts(options?: AttemptRecorderOptions): AttemptRecorder {\n  return new AttemptRecorder(options);\n}\n"]}

package/dist/sinks.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * footprintjs/sinks — where a run's crash-safe record goes on a Node host (10.1, design §3.5).
+ *
+ * NODE ONLY. This door imports `node:fs`; it is the one door that does (`test/architecture/layering.test.ts`), so
+ * every other door stays loadable in a browser. The port itself — `RecordSink`, and the reference `memorySink()` —
+ * is foottrace's (`foottrace/write`); the reader is `readStoredRecord` (`foottrace`).
+ *
+ * @example
+ * ```typescript
+ * import { flowChart, FlowChartExecutor } from 'footprintjs';
+ * import { fileSink, readRecordFile } from 'footprintjs/sinks';
+ * import { readStoredRecord } from 'foottrace';
+ *
+ * const executor = new FlowChartExecutor(chart, { sink: fileSink('/var/footprint/orders.jsonl') });
+ * await executor.run({ input });
+ *
+ * // After a crash — in another process:
+ * const record = readStoredRecord(readRecordFile('/var/footprint/orders.jsonl').entries);
+ * for (const log of record.logs.values()) if (!log.complete) console.log('never finished:', log.address);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRecordFile = exports.fileSink = exports.DEFAULT_FILE_SINK_MAX_QUEUED_BYTES = exports.DEFAULT_FILE_SINK_MAX_ENTRY_BYTES = exports.DEFAULT_FILE_SINK_MAX_BYTES = exports.DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS = void 0;
+var fileSink_js_1 = require("./lib/sinks/fileSink.js");
+Object.defineProperty(exports, "DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS", { enumerable: true, get: function () { return fileSink_js_1.DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS; } });
+Object.defineProperty(exports, "DEFAULT_FILE_SINK_MAX_BYTES", { enumerable: true, get: function () { return fileSink_js_1.DEFAULT_FILE_SINK_MAX_BYTES; } });
+Object.defineProperty(exports, "DEFAULT_FILE_SINK_MAX_ENTRY_BYTES", { enumerable: true, get: function () { return fileSink_js_1.DEFAULT_FILE_SINK_MAX_ENTRY_BYTES; } });
+Object.defineProperty(exports, "DEFAULT_FILE_SINK_MAX_QUEUED_BYTES", { enumerable: true, get: function () { return fileSink_js_1.DEFAULT_FILE_SINK_MAX_QUEUED_BYTES; } });
+Object.defineProperty(exports, "fileSink", { enumerable: true, get: function () { return fileSink_js_1.fileSink; } });
+Object.defineProperty(exports, "readRecordFile", { enumerable: true, get: function () { return fileSink_js_1.readRecordFile; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/trace.js

@@ -38,4 +38,4 @@ Object.defineProperty(exports, "SequenceStore", { enumerable: true, get: functio
 var TopologyRecorder_js_1 = require("./lib/recorder/TopologyRecorder.js");
 Object.defineProperty(exports, "TopologyRecorder", { enumerable: true, get: function () { return TopologyRecorder_js_1.TopologyRecorder; } });
 Object.defineProperty(exports, "topologyRecorder", { enumerable: true, get: function () { return TopologyRecorder_js_1.topologyRecorder; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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