@claudexor/daemon 3.25.1 → 4.0.1

package/dist/store/legacy-journal/journal-fold.d.ts

@@ -0,0 +1,47 @@
+/** One logical journal record as the fold sees it: an ordinary frame or one
+ * record inside a compacted snapshot. `byteLength` is the record's serialized
+ * logical size in bytes as stored in its source (informational: it feeds the
+ * retired-bytes receipt, never a decision). */
+export interface FoldRecord {
+    seq: number;
+    type: string;
+    time: string;
+    payload: unknown;
+    byteLength: number;
+}
+/** Default (undefined / empty object) = keep. Deterministic. Called once per
+ * logical record in seq order, for ordinary frames and for records inside
+ * compacted snapshots alike. */
+export interface FoldVerdict {
+    /** Do not retain this record (retire/slot/group still apply). */
+    drop?: boolean;
+    /** Single-holder key: a later record with the same slot drops the earlier holder. */
+    slot?: string;
+    /** Multi-holder key: registered, never auto-superseded. */
+    group?: string;
+    /** Drop every retained record currently registered under these slot/group
+     * names (applied BEFORE registering this record). */
+    retire?: readonly string[];
+}
+/** The policy is supplied by the caller (the daemon); the journal stays generic
+ * and never decides WHAT is dead. */
+export interface JournalFold {
+    verdict(record: FoldRecord): FoldVerdict;
+}
+/** Identity fold: every record is retained. */
+export declare const keepEverything: JournalFold;
+export interface FoldResult<T> {
+    retained: T[];
+    retiredCount: number;
+    retiredBytes: number;
+}
+/** Streaming fold engine. Records are pushed in seq order; a record dropped by
+ * a later verdict leaves no reference behind (tombstones are Map deletions), so
+ * memory is proportional to the retained set plus live slot/group names, never
+ * to the number of records seen. */
+export interface FoldStream<T> {
+    push(record: T, view: FoldRecord): void;
+    finish(): FoldResult<T>;
+}
+export declare function foldStream<T>(fold?: JournalFold): FoldStream<T>;
+//# sourceMappingURL=journal-fold.d.ts.map

package/dist/store/legacy-journal/journal-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-fold.d.ts","sourceRoot":"","sources":["../../../src/store/legacy-journal/journal-fold.ts"],"names":[],"mappings":"AAAA;;;+CAG+C;AAC/C,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;gCAEgC;AAChC,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,qFAAqF;IACrF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;yDACqD;IACrD,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED;qCACqC;AACrC,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,CAAC;CAC1C;AAED,+CAA+C;AAC/C,eAAO,MAAM,cAAc,EAAE,WAAoD,CAAC;AAElF,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,QAAQ,EAAE,CAAC,EAAE,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;oCAGoC;AACpC,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxC,MAAM,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;CACzB;AASD,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAE,WAA4B,GAAG,UAAU,CAAC,CAAC,CAAC,CAoE/E"}

package/dist/store/legacy-journal/journal-fold.js

@@ -0,0 +1,81 @@
+/** Identity fold: every record is retained. */
+export const keepEverything = Object.freeze({ verdict: () => ({}) });
+export function foldStream(fold = keepEverything) {
+    // Insertion order is seq order; deletions never reorder the survivors.
+    const held = new Map();
+    const slots = new Map();
+    const groups = new Map();
+    let nextId = 0;
+    let retiredCount = 0;
+    let retiredBytes = 0;
+    let finished = false;
+    const drop = (id) => {
+        const entry = held.get(id);
+        if (!entry)
+            return;
+        held.delete(id);
+        retiredCount += 1;
+        retiredBytes += entry.bytes;
+        if (entry.slot !== undefined && slots.get(entry.slot) === id)
+            slots.delete(entry.slot);
+        if (entry.group !== undefined) {
+            const members = groups.get(entry.group);
+            members?.delete(id);
+            if (members && members.size === 0)
+                groups.delete(entry.group);
+        }
+    };
+    const retire = (name) => {
+        const holder = slots.get(name);
+        if (holder !== undefined)
+            drop(holder);
+        const members = groups.get(name);
+        if (members)
+            for (const id of [...members])
+                drop(id);
+    };
+    return {
+        push(record, view) {
+            if (finished)
+                throw new Error("journal fold stream is finished");
+            const verdict = fold.verdict(view) ?? {};
+            if (verdict.retire)
+                for (const name of verdict.retire)
+                    retire(name);
+            if (verdict.slot !== undefined) {
+                const holder = slots.get(verdict.slot);
+                if (holder !== undefined)
+                    drop(holder);
+            }
+            if (verdict.drop) {
+                retiredCount += 1;
+                retiredBytes += view.byteLength;
+                return;
+            }
+            const id = nextId;
+            nextId += 1;
+            held.set(id, { record, bytes: view.byteLength, slot: verdict.slot, group: verdict.group });
+            if (verdict.slot !== undefined)
+                slots.set(verdict.slot, id);
+            if (verdict.group !== undefined) {
+                let members = groups.get(verdict.group);
+                if (!members) {
+                    members = new Set();
+                    groups.set(verdict.group, members);
+                }
+                members.add(id);
+            }
+        },
+        finish() {
+            finished = true;
+            const retained = [];
+            for (const entry of held.values())
+                retained.push(entry.record);
+            held.clear();
+            slots.clear();
+            groups.clear();
+            return { retained, retiredCount, retiredBytes };
+        },
+    };
+}
+//# sourceMappingURL=journal-fold.js.map

package/dist/store/legacy-journal/journal-fold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-fold.js","sourceRoot":"","sources":["../../../src/store/legacy-journal/journal-fold.ts"],"names":[],"mappings":"AAiCA,+CAA+C;AAC/C,MAAM,CAAC,MAAM,cAAc,GAAgB,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAwBlF,MAAM,UAAU,UAAU,CAAI,IAAI,GAAgB,cAAc;IAC9D,uEAAuE;IACvE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAmB,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAC;IAC9C,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,MAAM,IAAI,GAAG,CAAC,EAAU,EAAQ,EAAE;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAChB,YAAY,IAAI,CAAC,CAAC;QAClB,YAAY,IAAI,KAAK,CAAC,KAAK,CAAC;QAC5B,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE;YAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACvF,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACxC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;YACpB,IAAI,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC;gBAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAChE,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,CAAC,IAAY,EAAQ,EAAE;QACpC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,OAAO;YAAE,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC;gBAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC,CAAC;IAEF,OAAO;QACL,IAAI,CAAC,MAAM,EAAE,IAAI;YACf,IAAI,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;YACjE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACzC,IAAI,OAAO,CAAC,MAAM;gBAAE,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,MAAM;oBAAE,MAAM,CAAC,IAAI,CAAC,CAAC;YACpE,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACvC,IAAI,MAAM,KAAK,SAAS;oBAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YACzC,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;gBACjB,YAAY,IAAI,CAAC,CAAC;gBAClB,YAAY,IAAI,IAAI,CAAC,UAAU,CAAC;gBAChC,OAAO;YACT,CAAC;YACD,MAAM,EAAE,GAAG,MAAM,CAAC;YAClB,MAAM,IAAI,CAAC,CAAC;YACZ,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;YAC3F,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;gBAAE,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC5D,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAChC,IAAI,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACxC,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;oBACpB,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;gBACrC,CAAC;gBACD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAClB,CAAC;QACH,CAAC;QACD,MAAM;YACJ,QAAQ,GAAG,IAAI,CAAC;YAChB,MAAM,QAAQ,GAAQ,EAAE,CAAC;YACzB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE;gBAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC/D,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,MAAM,CAAC,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;QAClD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/store/legacy-journal/journal-partition.d.ts

@@ -0,0 +1,2 @@
+export declare function journalPartitionDirectory(rootDir: string, partition: string): string;
+//# sourceMappingURL=journal-partition.d.ts.map

package/dist/store/legacy-journal/journal-partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-partition.d.ts","sourceRoot":"","sources":["../../../src/store/legacy-journal/journal-partition.ts"],"names":[],"mappings":"AAGA,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKpF"}

package/dist/store/legacy-journal/journal-partition.js

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+export function journalPartitionDirectory(rootDir, partition) {
+    if (!partition.trim())
+        throw new Error("journal partition must not be empty");
+    const slug = partition.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 48) || "partition";
+    const digest = createHash("sha256").update(Buffer.from(partition)).digest("hex");
+    return join(rootDir, `${slug}-${digest.slice(0, 12)}`);
+}
+//# sourceMappingURL=journal-partition.js.map

package/dist/store/legacy-journal/journal-partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-partition.js","sourceRoot":"","sources":["../../../src/store/legacy-journal/journal-partition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,UAAU,yBAAyB,CAAC,OAAe,EAAE,SAAiB;IAC1E,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAC9E,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,WAAW,CAAC;IACrF,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACjF,OAAO,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AACzD,CAAC"}

package/dist/store/legacy-journal/read-only-preparation.d.ts

@@ -0,0 +1,48 @@
+import { type JournalRecord } from "./frame-codec.js";
+import type { JournalFold } from "./journal-fold.js";
+export interface JournalPreparationReceipt {
+    fingerprint: string;
+    preparationIdentity: string;
+    virtual: boolean;
+    deferredRepair: null | {
+        kind: "discard_unacknowledged_append";
+        discardedBytes: number;
+    };
+}
+export type PreparedJournalRecovery = {
+    status: "ready";
+    discardedTailBytes: number;
+} | {
+    status: "recovery_required";
+    location: {
+        kind: "byte";
+        byteOffset: number;
+    };
+    reason: string;
+    discardedTailBytes: number;
+};
+/** Chain state (`epoch`/`nextSeq`/`previousFrameHash`) is the disk state after
+ * the last frame; `records` is the retained set after the optional fold, and
+ * `retiredCount`/`retiredBytes` say what that fold dropped while replaying. */
+export interface PreparedJournalInspection {
+    receipt: JournalPreparationReceipt;
+    recovery: PreparedJournalRecovery;
+    records: JournalRecord[];
+    epoch: string;
+    nextSeq: number;
+    previousFrameHash: string;
+    knownFileBytes: number;
+    retiredCount: number;
+    retiredBytes: number;
+}
+export declare function inspectPreparedJournal(input: {
+    rootDir: string;
+    partitionDir: string;
+    journalPath: string;
+    intentPath: string;
+    partition: string;
+    initialEpoch: string;
+    fold?: JournalFold;
+}): PreparedJournalInspection;
+export declare function fingerprintPreparedJournal(rootDir: string, partitionDir: string): Pick<JournalPreparationReceipt, "fingerprint" | "preparationIdentity">;
+//# sourceMappingURL=read-only-preparation.d.ts.map

package/dist/store/legacy-journal/read-only-preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-only-preparation.d.ts","sourceRoot":"","sources":["../../../src/store/legacy-journal/read-only-preparation.ts"],"names":[],"mappings":"AAcA,OAAO,EAAa,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,IAAI,GAAG;QACrB,IAAI,EAAE,+BAA+B,CAAC;QACtC,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAED,MAAM,MAAM,uBAAuB,GAC/B;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAA;CAAE,GAC/C;IACE,MAAM,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEN;;+EAE+E;AAC/E,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,yBAAyB,CAAC;IACnC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AA6BD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,GAAG,yBAAyB,CAuF5B;AAyBD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB,IAAI,CAAC,yBAAyB,EAAE,aAAa,GAAG,qBAAqB,CAAC,CAMxE"}

package/dist/store/legacy-journal/read-only-preparation.js

@@ -0,0 +1,430 @@
+import { createHash } from "node:crypto";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, readdirSync, readlinkSync, realpathSync, } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { ZERO_HASH } from "./frame-codec.js";
+import { readFrames } from "./frame-reader.js";
+/** Bytes are retained only for files small enough to be an append intent; the
+ * journal itself is hashed in chunks and later decoded positionally. */
+const RETAINED_FILE_BYTES = 1024;
+const HASH_CHUNK_BYTES = 1024 * 1024;
+export function inspectPreparedJournal(input) {
+    const tree = snapshotTree(input.rootDir, input.partitionDir);
+    const journal = tree.files.get(input.journalPath);
+    const intent = tree.files.get(input.intentPath);
+    const unexpected = [...tree.entries].filter((path) => path !== input.journalPath && path !== input.intentPath);
+    let problem = tree.problems[0] ?? null;
+    let byteOffset = 0;
+    let deferredRepair = null;
+    if (!problem && journal === undefined && (intent !== undefined || tree.partitionExists)) {
+        if (intent !== undefined || unexpected.length > 0) {
+            problem = "journal file is missing while partition state exists";
+        }
+    }
+    const size = journal?.size ?? 0;
+    let prefix = null;
+    if (!problem && intent !== undefined) {
+        try {
+            prefix = parseIntent(intent);
+            if (prefix.offset > size || size > prefix.offset + prefix.length) {
+                problem = "append intent does not match the journal prefix";
+                byteOffset = prefix.offset;
+            }
+        }
+        catch (error) {
+            problem = `append intent is malformed: ${safeMessage(error)}`;
+        }
+    }
+    let decoded = null;
+    if (!problem && journal !== undefined) {
+        try {
+            decoded = readObservedJournal(input.journalPath, journal, input.partition, {
+                limit: prefix?.offset,
+                fold: input.fold,
+            });
+        }
+        catch (error) {
+            problem = `journal cannot be read safely: ${safeMessage(error)}`;
+        }
+    }
+    if (!problem && prefix && decoded) {
+        if (decoded.error || decoded.incompleteOffset !== null) {
+            problem = "append intent does not match the journal prefix";
+            byteOffset = prefix.offset;
+        }
+        else {
+            deferredRepair = {
+                kind: "discard_unacknowledged_append",
+                discardedBytes: size - prefix.offset,
+            };
+        }
+    }
+    if (!problem && decoded?.incompleteOffset != null) {
+        problem = "unexplained suffix without append intent";
+        byteOffset = decoded.incompleteOffset;
+    }
+    if (!problem && decoded?.error) {
+        problem = decoded.error.reason;
+        byteOffset = decoded.error.offset;
+    }
+    const ready = !problem && decoded ? decoded : null;
+    const virtual = !tree.rootExists || !tree.partitionExists || journal === undefined;
+    return {
+        receipt: {
+            fingerprint: tree.fingerprint,
+            preparationIdentity: tree.preparationIdentity,
+            virtual,
+            deferredRepair,
+        },
+        recovery: problem
+            ? {
+                status: "recovery_required",
+                location: { kind: "byte", byteOffset },
+                reason: problem,
+                discardedTailBytes: 0,
+            }
+            : { status: "ready", discardedTailBytes: 0 },
+        records: ready?.retained ?? [],
+        epoch: ready?.epoch ?? input.initialEpoch,
+        nextSeq: ready?.nextSeq ?? 1,
+        previousFrameHash: ready?.previousFrameHash ?? ZERO_HASH,
+        knownFileBytes: deferredRepair ? prefix.offset : size,
+        retiredCount: ready?.retiredCount ?? 0,
+        retiredBytes: ready?.retiredBytes ?? 0,
+    };
+}
+/** Decode the journal that the tree walk already observed: the descriptor must
+ * still be the same file before and after the positional read. */
+function readObservedJournal(path, observed, partition, options) {
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        if (observationMetadata(fstatSync(fd, { bigint: true })) !== observed.observation) {
+            throw new Error("journal changed since it was inspected");
+        }
+        const decoded = readFrames(fd, partition, options);
+        if (observationMetadata(fstatSync(fd, { bigint: true })) !== observed.observation) {
+            throw new Error("journal changed while being decoded");
+        }
+        return decoded;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function fingerprintPreparedJournal(rootDir, partitionDir) {
+    const observed = snapshotTree(rootDir, partitionDir);
+    return {
+        fingerprint: observed.fingerprint,
+        preparationIdentity: observed.preparationIdentity,
+    };
+}
+function snapshotTree(rootDir, partitionDir) {
+    const contentHash = createHash("sha256");
+    const identityHash = createHash("sha256");
+    const files = new Map();
+    const entries = new Set();
+    const problems = [];
+    if (!inspectTrustedParent(dirname(resolve(rootDir)), identityHash, problems)) {
+        contentHash.update("root\0unreachable\0");
+        return finishSnapshot({
+            contentHash,
+            identityHash,
+            rootExists: false,
+            partitionExists: false,
+            entries,
+            files,
+            problems,
+        });
+    }
+    const root = inspectEntry(rootDir, "root", contentHash, identityHash, files, problems, false);
+    if (root.kind !== "directory") {
+        contentHash.update("partition\0unreachable\0");
+        identityHash.update("partition\0unreachable\0");
+        return finishSnapshot({
+            contentHash,
+            identityHash,
+            rootExists: root.kind !== "missing",
+            partitionExists: false,
+            entries,
+            files,
+            problems,
+        });
+    }
+    const partition = inspectEntry(partitionDir, "partition", contentHash, identityHash, files, problems, false);
+    if (partition.kind === "directory") {
+        walkPartition(partitionDir, partitionDir, partition.stat, contentHash, identityHash, files, entries, problems);
+    }
+    assertDirectoryUnchanged(rootDir, root.stat, problems, "root");
+    return finishSnapshot({
+        contentHash,
+        identityHash,
+        rootExists: true,
+        partitionExists: partition.kind !== "missing",
+        entries,
+        files,
+        problems,
+    });
+}
+function walkPartition(path, partitionDir, before, contentHash, identityHash, files, entries, problems) {
+    let names;
+    try {
+        names = readdirSync(path).sort();
+    }
+    catch (error) {
+        problems.push(`journal partition cannot be listed: ${safeMessage(error)}`);
+        contentHash.update(`list-error\0${safeMessage(error)}\0`);
+        identityHash.update(`list-error\0${safeMessage(error)}\0`);
+        return;
+    }
+    for (const name of names) {
+        const child = join(path, name);
+        // `join` so the map keys match what callers look up (a `/`-built key never
+        // matched on Windows). The hashed LABEL is separator-normalized with
+        // `sep`, not a blanket backslash strip: on POSIX a backslash is an
+        // ordinary filename character and must stay distinct.
+        const relative = child
+            .slice(partitionDir.length + 1)
+            .split(sep)
+            .join("/");
+        entries.add(child);
+        const inspected = inspectEntry(child, relative, contentHash, identityHash, files, problems, true);
+        if (inspected.kind === "directory") {
+            walkPartition(child, partitionDir, inspected.stat, contentHash, identityHash, files, entries, problems);
+        }
+    }
+    try {
+        if (readdirSync(path).sort().join("\0") !== names.join("\0")) {
+            problems.push(`journal directory entries changed while being read: ${path}`);
+        }
+    }
+    catch (error) {
+        problems.push(`journal partition cannot be relisted: ${safeMessage(error)}`);
+    }
+    assertDirectoryUnchanged(path, before, problems, path);
+}
+function inspectEntry(path, label, contentHash, identityHash, files, problems, allowFile) {
+    let stat;
+    try {
+        stat = lstatSync(path, { bigint: true });
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT") {
+            contentHash.update(`${label}\0missing\0`);
+            identityHash.update(`${label}\0missing\0`);
+            assertStillMissing(path, problems, label);
+            return { kind: "missing" };
+        }
+        problems.push(`${label} cannot be inspected: ${safeMessage(error)}`);
+        contentHash.update(`${label}\0error\0${safeMessage(error)}\0`);
+        identityHash.update(`${label}\0error\0${safeMessage(error)}\0`);
+        return { kind: "other" };
+    }
+    contentHash.update(`${label}\0${semanticMetadata(stat)}\0`);
+    identityHash.update(`${label}\0${identityMetadata(stat)}\0`);
+    if (stat.isSymbolicLink()) {
+        try {
+            const target = readlinkSync(path);
+            contentHash.update(`symlink\0${target}\0`);
+            identityHash.update(`symlink\0${target}\0`);
+        }
+        catch (error) {
+            problems.push(`${label} symbolic-link target cannot be read: ${safeMessage(error)}`);
+        }
+        problems.push(`${label} is a symbolic link`);
+        return { kind: "other" };
+    }
+    if (typeof process.getuid === "function" && stat.uid !== BigInt(process.getuid())) {
+        problems.push(`${label} is not owned by the current user`);
+    }
+    if (stat.isDirectory()) {
+        let safe = true;
+        try {
+            if (realpathSync.native(path) !== resolve(path)) {
+                problems.push(`${label} is not canonical`);
+                safe = false;
+            }
+        }
+        catch (error) {
+            problems.push(`${label} cannot be resolved canonically: ${safeMessage(error)}`);
+            safe = false;
+        }
+        if (process.platform !== "win32" && Number(stat.mode & 511n) !== 0o700) {
+            problems.push(`${label} is not private`);
+            safe = false;
+        }
+        if (typeof process.getuid === "function" && stat.uid !== BigInt(process.getuid()))
+            safe = false;
+        return safe ? { kind: "directory", stat } : { kind: "other" };
+    }
+    if (!allowFile || !stat.isFile() || stat.nlink !== 1n) {
+        problems.push(`${label} is not a private regular file`);
+        return { kind: "other" };
+    }
+    if (process.platform !== "win32" && Number(stat.mode & 511n) !== 0o600) {
+        problems.push(`${label} is not private`);
+    }
+    try {
+        const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const opened = fstatSync(fd, { bigint: true });
+            if (opened.dev !== stat.dev ||
+                opened.ino !== stat.ino ||
+                !opened.isFile() ||
+                observationMetadata(opened) !== observationMetadata(stat)) {
+                throw new Error("pathname identity changed while being read");
+            }
+            const retain = opened.size <= BigInt(RETAINED_FILE_BYTES);
+            const bytes = hashDescriptor(fd, contentHash, retain);
+            const after = fstatSync(fd, { bigint: true });
+            if (BigInt(bytes.length) !== opened.size ||
+                observationMetadata(opened) !== observationMetadata(after)) {
+                throw new Error("file changed while being read");
+            }
+            const namedAfter = lstatSync(path, { bigint: true });
+            if (observationMetadata(stat) !== observationMetadata(namedAfter)) {
+                throw new Error("pathname identity changed after being read");
+            }
+            files.set(path, {
+                size: Number(opened.size),
+                observation: observationMetadata(opened),
+                ...(retain ? { bytes: bytes.retained } : {}),
+            });
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch (error) {
+        problems.push(`${label} cannot be read safely: ${safeMessage(error)}`);
+        contentHash.update(`read-error\0${safeMessage(error)}\0`);
+        identityHash.update(`read-error\0${safeMessage(error)}\0`);
+    }
+    return { kind: "file", stat };
+}
+/** Stream the descriptor through the content hash in bounded chunks. The
+ * fingerprint is the digest of the same byte sequence a whole-file read would
+ * hash, without retaining the file. */
+function hashDescriptor(fd, contentHash, retain) {
+    const chunk = Buffer.allocUnsafe(HASH_CHUNK_BYTES);
+    const kept = [];
+    let length = 0;
+    for (;;) {
+        const read = readSync(fd, chunk, 0, chunk.length, length);
+        if (read === 0)
+            break;
+        contentHash.update(chunk.subarray(0, read));
+        if (retain)
+            kept.push(Buffer.from(chunk.subarray(0, read)));
+        length += read;
+    }
+    return { length, retained: retain ? Buffer.concat(kept) : Buffer.alloc(0) };
+}
+function finishSnapshot(input) {
+    const fingerprint = input.contentHash.digest("hex");
+    input.identityHash.update(`content\0${fingerprint}\0`);
+    return {
+        fingerprint,
+        preparationIdentity: input.identityHash.digest("hex"),
+        rootExists: input.rootExists,
+        partitionExists: input.partitionExists,
+        entries: input.entries,
+        files: input.files,
+        problems: input.problems,
+    };
+}
+function inspectTrustedParent(path, identityHash, problems) {
+    try {
+        const before = lstatSync(path, { bigint: true });
+        identityHash.update(`trusted-parent\0${identityMetadata(before)}\0`);
+        if (before.isSymbolicLink() ||
+            !before.isDirectory() ||
+            realpathSync.native(path) !== path ||
+            (typeof process.getuid === "function" && before.uid !== BigInt(process.getuid())) ||
+            (process.platform !== "win32" && Number(before.mode & 511n) !== 0o700)) {
+            problems.push("journal root parent is not canonical and private");
+            return false;
+        }
+        const after = lstatSync(path, { bigint: true });
+        if (observationMetadata(before) !== observationMetadata(after)) {
+            problems.push("journal root parent changed while being inspected");
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        problems.push(`journal root parent cannot be inspected: ${safeMessage(error)}`);
+        identityHash.update(`trusted-parent-error\0${safeMessage(error)}\0`);
+        return false;
+    }
+}
+function assertDirectoryUnchanged(path, before, problems, label) {
+    try {
+        const after = lstatSync(path, { bigint: true });
+        if (observationMetadata(before) !== observationMetadata(after)) {
+            problems.push(`${label} changed while being inspected`);
+        }
+    }
+    catch (error) {
+        problems.push(`${label} became unavailable while being inspected: ${safeMessage(error)}`);
+    }
+}
+function assertStillMissing(path, problems, label) {
+    try {
+        lstatSync(path);
+        problems.push(`${label} appeared while being inspected`);
+    }
+    catch (error) {
+        if (errorCode(error) !== "ENOENT") {
+            problems.push(`${label} missing state is ambiguous: ${safeMessage(error)}`);
+        }
+    }
+}
+function semanticMetadata(stat) {
+    const base = [entryType(stat), stat.mode & 511n, stat.uid, stat.gid];
+    if (!stat.isDirectory())
+        base.push(stat.nlink, stat.size);
+    return base.join(":");
+}
+function identityMetadata(stat) {
+    const base = [stat.dev, stat.ino, entryType(stat), stat.mode & 511n, stat.uid, stat.gid];
+    if (!stat.isDirectory())
+        base.push(stat.nlink);
+    return base.join(":");
+}
+function observationMetadata(stat) {
+    return [identityMetadata(stat), stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+}
+function entryType(stat) {
+    if (stat.isDirectory())
+        return "directory";
+    if (stat.isFile())
+        return "file";
+    if (stat.isSymbolicLink())
+        return "symlink";
+    return "other";
+}
+function parseIntent(intent) {
+    if (!intent.bytes || intent.size > RETAINED_FILE_BYTES)
+        throw new Error("unsafe file");
+    const value = JSON.parse(intent.bytes.toString("utf8"));
+    if (!isRecord(value) ||
+        value.v !== 1 ||
+        !Number.isSafeInteger(value.offset) ||
+        Number(value.offset) < 0 ||
+        !Number.isSafeInteger(value.length) ||
+        Number(value.length) <= 0) {
+        throw new Error("invalid shape");
+    }
+    return value;
+}
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error
+        ? String(error.code)
+        : undefined;
+}
+function safeMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=read-only-preparation.js.map