@letta-ai/dreams 0.0.1 → 0.0.3

package/dist/local/sync-control.js

@@ -0,0 +1,381 @@
+"use strict";
+/**
+ * Sync control plane ([LET-10237] / [LET-10314]): durable triggers, pause, cadence.
+ *
+ * Global pause + singleton worker lease live on `sync_runtime`. Per-source
+ * cadence, retry, and degraded diagnostics live on `sync_triggers` so Claude
+ * and Codex cannot strand each other's wakes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_UPLOAD_ROW_BUDGET = exports.MAX_TRAILING_PASSES = exports.RETRY_BACKOFF_MS = exports.CADENCE_MS = exports.DEFAULT_SOURCE_ID = void 0;
+exports.uploadRowBudget = uploadRowBudget;
+exports.readTrigger = readTrigger;
+exports.readRuntime = readRuntime;
+exports.recordSyncRequest = recordSyncRequest;
+exports.setPaused = setPaused;
+exports.isPaused = isPaused;
+exports.cadenceDue = cadenceDue;
+exports.observeTrigger = observeTrigger;
+exports.completeSyncPass = completeSyncPass;
+exports.markRuntimeDegraded = markRuntimeDegraded;
+exports.earliestUploadRetryAt = earliestUploadRetryAt;
+exports.markRuntimeRunning = markRuntimeRunning;
+exports.normalizeStaleRunning = normalizeStaleRunning;
+exports.triggerPending = triggerPending;
+exports.sourceIsRunnable = sourceIsRunnable;
+exports.nextRunnableSourceId = nextRunnableSourceId;
+exports.effectiveSyncState = effectiveSyncState;
+exports.retryDueFromError = retryDueFromError;
+exports.fallbackRetryAt = fallbackRetryAt;
+const db_1 = require("./db");
+const source_adapters_1 = require("./source-adapters");
+/** CLI/worker default source id — Claude via deterministic registry ([LET-10313]). */
+exports.DEFAULT_SOURCE_ID = (0, source_adapters_1.defaultSourceAdapter)().sourceId;
+exports.CADENCE_MS = 3 * 60 * 60 * 1000;
+exports.RETRY_BACKOFF_MS = 60_000;
+exports.MAX_TRAILING_PASSES = 2;
+exports.DEFAULT_UPLOAD_ROW_BUDGET = 32;
+/** Soft upload row budget for one worker pass (overridable in tests). */
+function uploadRowBudget() {
+    const raw = process.env.DREAMS_SYNC_UPLOAD_ROW_BUDGET;
+    if (raw) {
+        const n = Number(raw);
+        if (Number.isSafeInteger(n) && n > 0)
+            return n;
+    }
+    return exports.DEFAULT_UPLOAD_ROW_BUDGET;
+}
+function ensureLocalSource(db, sourceId) {
+    const adapter = (0, source_adapters_1.getSourceAdapterById)(sourceId);
+    const now = (0, db_1.nowIso)();
+    db.prepare(`INSERT INTO sources (id, source_type, source_key, display_name, adapter_version, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, 'detected', ?, ?)
+     ON CONFLICT(id) DO NOTHING`).run(sourceId, adapter.sourceType, adapter.sourceKey, adapter.displayName, adapter.adapterVersion, now, now);
+}
+function ensureTrigger(db, sourceId) {
+    ensureLocalSource(db, sourceId);
+    db.prepare("INSERT INTO sync_triggers (source_id, updated_at) VALUES (?, ?) ON CONFLICT(source_id) DO NOTHING").run(sourceId, (0, db_1.nowIso)());
+}
+function ensureRuntime(db) {
+    db.prepare(`INSERT INTO sync_runtime (id, paused, state, updated_at)
+     VALUES (1, 0, 'idle', ?)
+     ON CONFLICT(id) DO NOTHING`).run((0, db_1.nowIso)());
+}
+function parseHints(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return [...new Set(parsed.filter((v) => typeof v === "string" && v.length > 0))];
+    }
+    catch {
+        return [];
+    }
+}
+function readTrigger(db, sourceId = exports.DEFAULT_SOURCE_ID) {
+    const row = db
+        .prepare("SELECT requested_gen, processed_gen, forced, session_hints FROM sync_triggers WHERE source_id = ?")
+        .get(sourceId);
+    if (!row)
+        return { requested_gen: 0, processed_gen: 0, forced: false, session_hints: [] };
+    return {
+        requested_gen: row.requested_gen,
+        processed_gen: row.processed_gen,
+        forced: row.forced === 1,
+        session_hints: parseHints(row.session_hints),
+    };
+}
+function globalPaused(db) {
+    ensureRuntime(db);
+    return db.prepare("SELECT paused FROM sync_runtime WHERE id = 1").get().paused === 1;
+}
+function globalWorkerState(db) {
+    ensureRuntime(db);
+    const row = db.prepare("SELECT state, paused FROM sync_runtime WHERE id = 1").get();
+    if (row.paused === 1)
+        return "paused";
+    return row.state || "idle";
+}
+/**
+ * Per-source schedule view + global pause. Cadence/retry fields come from
+ * `sync_triggers`; `paused` and global `running` come from `sync_runtime`.
+ */
+function readRuntime(db, sourceId = exports.DEFAULT_SOURCE_ID) {
+    ensureRuntime(db);
+    ensureTrigger(db, sourceId);
+    const paused = globalPaused(db);
+    const globalState = globalWorkerState(db);
+    const row = db
+        .prepare(`SELECT state, last_attempt_at, last_success_at, last_error_at, last_error_code, last_error_message, next_due_at
+       FROM sync_triggers WHERE source_id = ?`)
+        .get(sourceId);
+    let state = row.state || "idle";
+    if (paused)
+        state = "paused";
+    else if (globalState === "running")
+        state = "running";
+    return {
+        paused,
+        state,
+        last_attempt_at: row.last_attempt_at,
+        last_success_at: row.last_success_at,
+        last_error_at: row.last_error_at,
+        last_error_code: row.last_error_code ?? null,
+        last_error_message: row.last_error_message,
+        next_due_at: row.next_due_at,
+    };
+}
+/** Atomic pause check + trigger record. Returns null when paused. */
+function recordSyncRequest(db, options = {}) {
+    const sourceId = options.sourceId ?? exports.DEFAULT_SOURCE_ID;
+    return (0, db_1.tx)(db, () => {
+        ensureRuntime(db);
+        ensureTrigger(db, sourceId);
+        if (globalPaused(db))
+            return { paused: true };
+        const before = readTrigger(db, sourceId);
+        const hints = new Set(before.session_hints);
+        if (options.sessionHint)
+            hints.add(options.sessionHint);
+        const forced = Boolean(options.forced) || before.forced;
+        db.prepare(`UPDATE sync_triggers
+         SET requested_gen = requested_gen + 1,
+             forced = ?,
+             session_hints = ?,
+             updated_at = ?
+       WHERE source_id = ?`).run(forced ? 1 : 0, JSON.stringify([...hints]), (0, db_1.nowIso)(), sourceId);
+        const generation = db.prepare("SELECT requested_gen FROM sync_triggers WHERE source_id = ?").get(sourceId).requested_gen;
+        return { paused: false, generation, forced };
+    });
+}
+function setPaused(db, paused) {
+    return (0, db_1.tx)(db, () => {
+        ensureRuntime(db);
+        const now = (0, db_1.nowIso)();
+        if (paused) {
+            db.prepare(`UPDATE sync_runtime SET paused = 1, state = 'paused', updated_at = ? WHERE id = 1`).run(now);
+        }
+        else {
+            // Resume clears global pause and force-wakes every source with a trigger row
+            // (or at least the default) so pending Codex work is not left asleep.
+            db.prepare(`UPDATE sync_runtime SET paused = 0, state = CASE WHEN state = 'paused' THEN 'idle' ELSE state END, updated_at = ? WHERE id = 1`).run(now);
+            const rows = db.prepare("SELECT source_id FROM sync_triggers").all();
+            const targets = rows.length > 0 ? rows.map((r) => r.source_id) : [exports.DEFAULT_SOURCE_ID];
+            for (const sourceId of targets) {
+                ensureTrigger(db, sourceId);
+                db.prepare(`UPDATE sync_triggers
+             SET requested_gen = requested_gen + 1, forced = 1, updated_at = ?
+           WHERE source_id = ?`).run(now, sourceId);
+            }
+        }
+        return readRuntime(db, exports.DEFAULT_SOURCE_ID);
+    });
+}
+function isPaused(db) {
+    return globalPaused(db);
+}
+function cadenceDue(runtime, nowMs = Date.now()) {
+    if (!runtime.next_due_at)
+        return true;
+    const due = Date.parse(runtime.next_due_at);
+    return !Number.isFinite(due) || due <= nowMs;
+}
+function observeTrigger(db, sourceId = exports.DEFAULT_SOURCE_ID) {
+    return readTrigger(db, sourceId);
+}
+function completeSyncPass(db, sourceId, observedGen, options) {
+    (0, db_1.tx)(db, () => {
+        ensureRuntime(db);
+        ensureTrigger(db, sourceId);
+        const now = (0, db_1.nowIso)();
+        let setNextDue = false;
+        let nextDue = null;
+        if (options.nextDueAt !== undefined) {
+            setNextDue = true;
+            // null means due immediately (retry ASAP on next wake).
+            nextDue = options.nextDueAt ?? now;
+        }
+        else if (options.advanceCadence) {
+            setNextDue = true;
+            nextDue = new Date(Date.now() + exports.CADENCE_MS).toISOString();
+        }
+        // Only clear hints when no newer generation recorded hints during this pass.
+        db.prepare(`UPDATE sync_triggers
+         SET processed_gen = MAX(processed_gen, ?),
+             forced = CASE WHEN requested_gen > ? THEN forced ELSE 0 END,
+             session_hints = CASE
+               WHEN ? = 1 AND requested_gen <= ? THEN NULL
+               ELSE session_hints
+             END,
+             updated_at = ?
+       WHERE source_id = ?`).run(observedGen, observedGen, options.clearHints ? 1 : 0, observedGen, now, sourceId);
+        if (options.forcePending) {
+            db.prepare(`UPDATE sync_triggers
+           SET requested_gen = CASE WHEN requested_gen <= ? THEN ? + 1 ELSE requested_gen END,
+               forced = 1,
+               updated_at = ?
+         WHERE source_id = ?`).run(observedGen, observedGen, now, sourceId);
+        }
+        if (options.ok) {
+            db.prepare(`UPDATE sync_triggers
+           SET state = 'idle',
+               last_attempt_at = ?,
+               last_success_at = ?,
+               next_due_at = CASE WHEN ? = 1 THEN ? ELSE next_due_at END,
+               updated_at = ?
+         WHERE source_id = ?`).run(now, now, setNextDue ? 1 : 0, nextDue, now, sourceId);
+            db.prepare(`UPDATE sync_runtime
+           SET state = CASE WHEN paused = 1 THEN 'paused' ELSE 'idle' END, updated_at = ?
+         WHERE id = 1`).run(now);
+        }
+        else {
+            db.prepare(`UPDATE sync_triggers
+           SET state = 'degraded',
+               last_attempt_at = ?,
+               last_error_at = ?,
+               last_error_code = ?,
+               last_error_message = ?,
+               next_due_at = CASE WHEN ? = 1 THEN ? ELSE next_due_at END,
+               updated_at = ?
+         WHERE source_id = ?`).run(now, now, options.errorCode ?? "local_error", (options.errorMessage ?? "sync failed").slice(0, 500), setNextDue ? 1 : 0, nextDue, now, sourceId);
+            db.prepare(`UPDATE sync_runtime
+           SET state = CASE WHEN paused = 1 THEN 'paused' ELSE 'idle' END, updated_at = ?
+         WHERE id = 1`).run(now);
+        }
+    });
+}
+/** Update per-source failure diagnostics without advancing trigger processed_gen. */
+function markRuntimeDegraded(db, errorCode, errorMessage, nextDueAt = null, sourceId = exports.DEFAULT_SOURCE_ID) {
+    (0, db_1.tx)(db, () => {
+        ensureRuntime(db);
+        ensureTrigger(db, sourceId);
+        const now = (0, db_1.nowIso)();
+        db.prepare(`UPDATE sync_triggers
+         SET state = 'degraded',
+             last_attempt_at = ?,
+             last_error_at = ?,
+             last_error_code = ?,
+             last_error_message = ?,
+             next_due_at = COALESCE(?, next_due_at),
+             updated_at = ?
+       WHERE source_id = ?`).run(now, now, errorCode ?? "local_error", (errorMessage ?? "sync failed").slice(0, 500), nextDueAt, now, sourceId);
+    });
+}
+/** Earliest pending upload retry timestamp for retry-due scheduling. */
+function earliestUploadRetryAt(db, sourceId = exports.DEFAULT_SOURCE_ID) {
+    const row = db
+        .prepare(`SELECT MIN(next_attempt_at) AS next_at
+         FROM upload_queue
+        WHERE source_id = ? AND state = 'pending' AND next_attempt_at IS NOT NULL`)
+        .get(sourceId);
+    return row?.next_at ?? null;
+}
+function markRuntimeRunning(db) {
+    (0, db_1.tx)(db, () => {
+        ensureRuntime(db);
+        db.prepare(`UPDATE sync_runtime SET state = CASE WHEN paused = 1 THEN 'paused' ELSE 'running' END, last_attempt_at = ?, updated_at = ? WHERE id = 1`).run((0, db_1.nowIso)(), (0, db_1.nowIso)());
+    });
+}
+/** Normalize stale running state when no worker lease is held. */
+function normalizeStaleRunning(db, workerLeaseHeld) {
+    if (workerLeaseHeld)
+        return;
+    (0, db_1.tx)(db, () => {
+        ensureRuntime(db);
+        const row = db.prepare("SELECT state, paused FROM sync_runtime WHERE id = 1").get();
+        if (row.state !== "running")
+            return;
+        db.prepare(`UPDATE sync_runtime
+         SET state = CASE WHEN paused = 1 THEN 'paused' ELSE 'idle' END, updated_at = ?
+       WHERE id = 1`).run((0, db_1.nowIso)());
+    });
+}
+function triggerPending(db, sourceId = exports.DEFAULT_SOURCE_ID) {
+    const t = readTrigger(db, sourceId);
+    return t.requested_gen > t.processed_gen || t.forced;
+}
+function sourceIsRunnable(db, sourceId, nowMs = Date.now()) {
+    const runtime = readRuntime(db, sourceId);
+    if (runtime.paused)
+        return false;
+    const trigger = readTrigger(db, sourceId);
+    const pending = trigger.requested_gen > trigger.processed_gen || trigger.forced;
+    if (!pending)
+        return false;
+    return trigger.forced || cadenceDue(runtime, nowMs) || retryDueFromError(runtime, nowMs);
+}
+/**
+ * Pick the next source with an actionable pending trigger.
+ * Prefers `preferredSourceId` when runnable; otherwise scans registered adapters.
+ */
+function nextRunnableSourceId(db, preferredSourceId = null, nowMs = Date.now()) {
+    if (preferredSourceId && sourceIsRunnable(db, preferredSourceId, nowMs))
+        return preferredSourceId;
+    const rows = db.prepare("SELECT source_id FROM sync_triggers ORDER BY updated_at ASC").all();
+    const known = new Set((0, source_adapters_1.listSourceAdapters)().map((adapter) => adapter.sourceId));
+    for (const row of rows) {
+        if (!known.has(row.source_id))
+            continue;
+        if (preferredSourceId && row.source_id === preferredSourceId)
+            continue;
+        if (sourceIsRunnable(db, row.source_id, nowMs))
+            return row.source_id;
+    }
+    return null;
+}
+/**
+ * Unambiguous status for humans/agents. Precedence:
+ * paused → running (worker lease) → degraded → pending (runnable now) →
+ * not_due (including retained triggers waiting on cadence/backoff) → idle.
+ *
+ * "Runnable" matches the scheduler: forced | cadenceDue | retryDueFromError.
+ */
+function effectiveSyncState(options) {
+    const nowMs = options.nowMs ?? Date.now();
+    if (options.runtime.paused)
+        return "paused";
+    if (options.workerActive)
+        return "running";
+    if (options.runtime.state === "degraded")
+        return "degraded";
+    const runnable = Boolean(options.forced) || cadenceDue(options.runtime, nowMs) || retryDueFromError(options.runtime, nowMs);
+    if (options.pending && runnable)
+        return "pending";
+    if (options.pending && !runnable)
+        return "not_due";
+    if (options.runtime.next_due_at) {
+        const due = Date.parse(options.runtime.next_due_at);
+        if (Number.isFinite(due) && due > nowMs)
+            return "not_due";
+    }
+    return "idle";
+}
+function retryDueFromError(runtime, nowMs = Date.now()) {
+    if (runtime.state !== "degraded" || !runtime.last_error_at)
+        return false;
+    if (runtime.last_error_code !== "network" && runtime.last_error_code !== "needs_auth" && runtime.last_error_code !== "busy") {
+        return false;
+    }
+    // Prefer explicit next_due_at when present (earliest upload retry / backoff).
+    if (runtime.next_due_at) {
+        const due = Date.parse(runtime.next_due_at);
+        return !Number.isFinite(due) || due <= nowMs;
+    }
+    const last = Date.parse(runtime.last_error_at);
+    if (!Number.isFinite(last))
+        return true;
+    // Bounded backoff: 1 minute after retryable failure.
+    return nowMs - last >= exports.RETRY_BACKOFF_MS;
+}
+/** Fallback next_due_at when a failure has no queued upload retry timestamp. */
+function fallbackRetryAt(errorCode, nowMs = Date.now()) {
+    if (errorCode === "network" || errorCode === "needs_auth" || errorCode === "busy") {
+        return new Date(nowMs + exports.RETRY_BACKOFF_MS).toISOString();
+    }
+    if (errorCode === "cloud_rejected") {
+        return new Date(nowMs + exports.CADENCE_MS).toISOString();
+    }
+    return null;
+}

package/dist/local/transcript-bytes.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Harness-neutral transcript byte primitives ([LET-10313]).
+ *
+ * Identity checks, prefix hashing, and verified JSONL line scans used by the
+ * generic scanner. Harness-specific discovery stays in each source adapter.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OversizedLineError = exports.IdentityChangedError = void 0;
+exports.firstChunkFingerprint = firstChunkFingerprint;
+exports.prefixFingerprint = prefixFingerprint;
+exports.scanCompleteLinesVerified = scanCompleteLinesVerified;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const IO_CHUNK_BYTES = 64 * 1024;
+const FIRST_CHUNK_BYTES = 4096;
+/** Thrown when a file's identity changes between discovery and read (TOCTOU / swap). */
+class IdentityChangedError extends Error {
+    constructor(filePath) {
+        super(`file identity changed under read: ${filePath}`);
+        this.name = "IdentityChangedError";
+    }
+}
+exports.IdentityChangedError = IdentityChangedError;
+class OversizedLineError extends Error {
+    filePath;
+    startOffset;
+    byteLength;
+    maxBytes;
+    constructor(filePath, startOffset, byteLength, maxBytes) {
+        super(`JSONL record at byte ${startOffset} in ${filePath} is ${byteLength} bytes; maximum is ${maxBytes}`);
+        this.filePath = filePath;
+        this.startOffset = startOffset;
+        this.byteLength = byteLength;
+        this.maxBytes = maxBytes;
+        this.name = "OversizedLineError";
+    }
+}
+exports.OversizedLineError = OversizedLineError;
+function fingerprint(bytes) {
+    return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+function normalizedMtime(stat) {
+    return Number.isFinite(stat.mtimeMs) ? Math.floor(stat.mtimeMs) : null;
+}
+function inodeOf(stat) {
+    return stat.ino ? String(stat.ino) : null;
+}
+function hashRange(fd, end, digest, onProgress) {
+    let position = 0;
+    while (position < end) {
+        const buf = Buffer.allocUnsafe(Math.min(IO_CHUNK_BYTES, end - position));
+        const read = fs.readSync(fd, buf, 0, buf.length, position);
+        if (read === 0)
+            throw new IdentityChangedError("opened transcript");
+        digest.update(buf.subarray(0, read));
+        position += read;
+        onProgress?.();
+    }
+}
+/**
+ * Fingerprint the transcript's FIRST LINE (which carries the stable sessionId).
+ * This is invariant under appends — new bytes go after the first line — but
+ * changes when the file is replaced by a different session, so it is a reliable
+ * replacement signal. (Hashing a fixed-size prefix would wrongly change on every
+ * append for files shorter than that prefix.)
+ */
+function firstChunkFingerprint(filePath) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const buf = Buffer.alloc(FIRST_CHUNK_BYTES);
+        const read = fs.readSync(fd, buf, 0, FIRST_CHUNK_BYTES, 0);
+        const head = buf.subarray(0, read);
+        const nl = head.indexOf(0x0a);
+        const firstLine = nl === -1 ? head : head.subarray(0, nl + 1);
+        return fingerprint(firstLine);
+    }
+    catch {
+        return "";
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/** SHA-256 of [0, length), read with bounded memory. */
+function prefixFingerprint(filePath, length, onProgress) {
+    if (length <= 0)
+        return "";
+    const fd = fs.openSync(filePath, "r");
+    try {
+        const digest = crypto.createHash("sha256");
+        hashRange(fd, length, digest, onProgress);
+        return digest.digest("hex");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Read complete JSONL records from one opened handle using bounded memory.
+ * The covered-prefix hash is computed from that same handle, and a final fstat
+ * rejects files that changed while being scanned.
+ */
+function scanCompleteLinesVerified(realPath, start, expectedInode, maxLineBytes, onLine, onProgress) {
+    let fd;
+    try {
+        fd = fs.openSync(realPath, "r");
+        const initial = fs.fstatSync(fd);
+        const inode = inodeOf(initial);
+        if (expectedInode !== null && inode !== null && inode !== expectedInode)
+            throw new IdentityChangedError(realPath);
+        if (start > initial.size)
+            throw new IdentityChangedError(realPath);
+        const digest = crypto.createHash("sha256");
+        hashRange(fd, start, digest, onProgress);
+        let readPosition = start;
+        let carry = Buffer.alloc(0);
+        let carryStart = start;
+        let completeThrough = start;
+        while (readPosition < initial.size) {
+            const chunk = Buffer.allocUnsafe(Math.min(IO_CHUNK_BYTES, initial.size - readPosition));
+            const read = fs.readSync(fd, chunk, 0, chunk.length, readPosition);
+            if (read === 0)
+                break;
+            readPosition += read;
+            onProgress?.();
+            const combined = carry.length === 0 ? chunk.subarray(0, read) : Buffer.concat([carry, chunk.subarray(0, read)]);
+            const combinedStart = carryStart;
+            let consumed = 0;
+            while (consumed < combined.length) {
+                const newline = combined.indexOf(0x0a, consumed);
+                if (newline === -1)
+                    break;
+                const end = newline + 1;
+                const byteLength = end - consumed;
+                const lineStart = combinedStart + consumed;
+                if (byteLength > maxLineBytes)
+                    throw new OversizedLineError(realPath, lineStart, byteLength, maxLineBytes);
+                const bytes = combined.subarray(consumed, end);
+                digest.update(bytes);
+                completeThrough = combinedStart + end;
+                onLine({ bytes, start_offset: lineStart, end_offset: completeThrough });
+                consumed = end;
+            }
+            carry = Buffer.from(combined.subarray(consumed));
+            carryStart = combinedStart + consumed;
+            if (carry.length > maxLineBytes) {
+                throw new OversizedLineError(realPath, carryStart, carry.length, maxLineBytes);
+            }
+        }
+        const final = fs.fstatSync(fd);
+        if (inodeOf(final) !== inode ||
+            final.size !== initial.size ||
+            normalizedMtime(final) !== normalizedMtime(initial)) {
+            throw new IdentityChangedError(realPath);
+        }
+        return {
+            size: initial.size,
+            inode,
+            mtime_ms: normalizedMtime(initial),
+            complete_through_offset: completeThrough,
+            prefix_fp: completeThrough > 0 ? digest.digest("hex") : "",
+        };
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}