footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/sinks/fileSink.d.ts

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+import type { RecordSink } from 'foottrace/write';
+/** The default cap on a record file: 64 MiB. */
+export declare const DEFAULT_FILE_SINK_MAX_BYTES: number;
+/** The default cap on ONE entry's line: 8 MiB. */
+export declare const DEFAULT_FILE_SINK_MAX_ENTRY_BYTES: number;
+/** The default cap on bytes accepted but not yet written: 16 MiB. */
+export declare const DEFAULT_FILE_SINK_MAX_QUEUED_BYTES: number;
+/** The default bound on `flush()`: 10 s. */
+export declare const DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS = 10000;
+/** `fileSink`'s options — every resource the sink can spend, bounded. */
+export interface FileSinkOptions {
+    /**
+     * The most bytes the file may hold (the bytes already in it count). Once an entry would pass it, the file is FULL:
+     * that entry and every later one is refused and counted by the run, never written — except a closing entry, which
+     * may use 64 KiB more so a full file can still say how the run ended. Default 64 MiB.
+     */
+    readonly maxBytes?: number;
+    /** The largest ONE entry's line may be; a larger entry is refused whole (`maxEntryBytes` named). Default 8 MiB. */
+    readonly maxEntryBytes?: number;
+    /**
+     * The most bytes accepted and not yet on disk. Writes are asynchronous, so a sink slower than the run queues; past
+     * this bound an entry is DROPPED and counted (never buffered without limit, never a stall). Default 16 MiB.
+     */
+    readonly maxQueuedBytes?: number;
+    /** How long `flush()` (drain the queue, then `fsync`) may take before it rejects. Default 10 s. */
+    readonly flushTimeoutMs?: number;
+}
+/** A record sink that appends to one file — `RecordSink` plus what the app needs to manage the file. */
+export interface FileSink extends RecordSink {
+    /** The absolute path the sink writes to — resolved once, when it was made. */
+    readonly path: string;
+    /**
+     * Bytes this sink knows are on disk: the file's size when it opened plus every byte its writes completed — a
+     * running sum, not the file's end (writes complete out of order; a failed one leaves a hole).
+     */
+    readonly bytes: number;
+    /** Bytes accepted and not yet written. */
+    readonly queuedBytes: number;
+    /** `true` once an entry was refused for `maxBytes`: the file is full, and only a closing entry may still go. */
+    readonly full: boolean;
+    /**
+     * Release the file. Idempotent. Every entry after it is refused (the run counts it), and `flush()` rejects;
+     * entries already accepted are still written (and a flush already started finishes), then the file is closed —
+     * the promise settles then.
+     */
+    close(): Promise<void>;
+}
+/**
+ * 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
+ * ```
+ */
+export declare function fileSink(path: string, options?: FileSinkOptions): FileSink;
+/** A record file read back: every parsed line, and every line that could not be. */
+export interface RecordFile {
+    /** The parsed entries, in file order — untrusted input for `readStoredRecord` (`foottrace`). */
+    readonly entries: readonly unknown[];
+    /** Each line that is not JSON (a torn last line, a corrupt one), by its 1-based number. Blank lines are skipped. */
+    readonly unreadable: readonly {
+        readonly line: number;
+        readonly reason: string;
+    }[];
+}
+/**
+ * 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.
+ */
+export declare function readRecordFile(path: string, options?: {
+    readonly maxBytes?: number;
+}): RecordFile;

package/dist/esm/lib/sinks/fileSink.js

@@ -0,0 +1,387 @@
+/**
+ * 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.
+ */
+import { close, closeSync, constants, fstat, fstatSync, fsync, openSync, readSync, write } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { getuid } from 'node:process';
+/** The default cap on a record file: 64 MiB. */
+export const DEFAULT_FILE_SINK_MAX_BYTES = 64 * 1024 * 1024;
+/** The default cap on ONE entry's line: 8 MiB. */
+export const DEFAULT_FILE_SINK_MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+/** The default cap on bytes accepted but not yet written: 16 MiB. */
+export const DEFAULT_FILE_SINK_MAX_QUEUED_BYTES = 16 * 1024 * 1024;
+/** The default bound on `flush()`: 10 s. */
+export const 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
+ * ```
+ */
+export 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, DEFAULT_FILE_SINK_MAX_BYTES, 1);
+    const maxEntryBytes = bound('maxEntryBytes', options?.maxEntryBytes, DEFAULT_FILE_SINK_MAX_ENTRY_BYTES, 1);
+    const maxQueuedBytes = bound('maxQueuedBytes', options?.maxQueuedBytes, DEFAULT_FILE_SINK_MAX_QUEUED_BYTES, 1);
+    const flushTimeoutMs = bound('flushTimeoutMs', options?.flushTimeoutMs, DEFAULT_FILE_SINK_FLUSH_TIMEOUT_MS, 1);
+    const absolute = resolvePath(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 = openSync(absolute, constants.O_RDWR | constants.O_CREAT | (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 = 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) {
+        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);
+        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;
+                    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.
+                        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;
+        },
+    };
+}
+/**
+ * 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) => {
+        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 getuid === 'function' ? 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 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.
+ */
+export 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 = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    let raw;
+    try {
+        const stat = 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 = 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 {
+        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 };
+}
+//# 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"]}