orbit-agent-runtime 0.8.0

package/dist/test/journal_wal.test.js

@@ -0,0 +1,622 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const index_1 = require("../src/index");
+async function tempDir(prefix) {
+    return node_fs_1.promises.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+/** Structural guard used by the generic-substrate tests. */
+function isPair(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    return typeof v.k === "string" && typeof v.n === "number";
+}
+function seedRecordJournal(journal) {
+    journal.append({
+        channelKind: index_1.ChannelKind.LLM_ACCESS,
+        funcName: "chatRound",
+        inputDigest: (0, index_1.digestInputs)("hello"),
+        outputSnapshot: "hello-back",
+        durationMs: 12
+    });
+    journal.append({
+        channelKind: index_1.ChannelKind.MEM_KV_STORE,
+        funcName: "readEntry",
+        inputDigest: (0, index_1.digestInputs)("k"),
+        outputSnapshot: "v",
+        durationMs: 1
+    });
+}
+// --------------------------------------------------------------- WAL substrate
+(0, node_test_1.test)("wal: append then recover roundtrips every line in order", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await (0, index_1.walAppend)(file, { k: "b", n: 2 });
+    await (0, index_1.walAppend)(file, { k: "c", n: 3 });
+    const recovered = await (0, index_1.walRecover)(file, isPair);
+    strict_1.default.deepEqual(recovered, [
+        { k: "a", n: 1 },
+        { k: "b", n: 2 },
+        { k: "c", n: 3 }
+    ]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: a missing file recovers as empty (first boot is not an error)", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const missing = path.join(dir, "never-written.jsonl");
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(missing, isPair), []);
+    strict_1.default.deepEqual((0, index_1.walRecoverSync)(missing, isPair), []);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: append creates parent directories", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "nested", "deep", "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    strict_1.default.deepEqual(await node_fs_1.promises.readdir(path.dirname(file)), ["log.jsonl"]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: a truncated trailing line is dropped, not fatal (crash safety)", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await (0, index_1.walAppend)(file, { k: "b", n: 2 });
+    // Simulate a crash mid-append: a partial final line with no newline.
+    await node_fs_1.promises.appendFile(file, '{"k":"c","n":', "utf8");
+    const recovered = await (0, index_1.walRecover)(file, isPair);
+    strict_1.default.deepEqual(recovered, [
+        { k: "a", n: 1 },
+        { k: "b", n: 2 }
+    ]);
+    strict_1.default.deepEqual((0, index_1.walRecoverSync)(file, isPair), recovered);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: a structurally incomplete trailing line is also dropped", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    // Parses as JSON, but fails the structural guard — a half-written entry.
+    await node_fs_1.promises.appendFile(file, '{"k":"b"}\n', "utf8");
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), [{ k: "a", n: 1 }]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: a corrupt interior line is a genuine fault, rejected with its line number", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await node_fs_1.promises.appendFile(file, "not-json\n", "utf8");
+    await (0, index_1.walAppend)(file, { k: "c", n: 3 });
+    await strict_1.default.rejects((0, index_1.walRecover)(file, isPair), (err) => {
+        strict_1.default.ok(err instanceof index_1.WalFileInvalidError);
+        strict_1.default.equal(err.lineNo, 2);
+        strict_1.default.match(err.message, /not valid JSON/);
+        return true;
+    });
+    strict_1.default.throws(() => (0, index_1.walRecoverSync)(file, isPair), index_1.WalFileInvalidError);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: an invalid interior entry is rejected by structural validation", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await node_fs_1.promises.appendFile(file, '{"k":"b"}\n', "utf8"); // missing n
+    await (0, index_1.walAppend)(file, { k: "c", n: 3 });
+    await strict_1.default.rejects((0, index_1.walRecover)(file, isPair), (err) => {
+        strict_1.default.ok(err instanceof index_1.WalFileInvalidError);
+        strict_1.default.equal(err.lineNo, 2);
+        strict_1.default.match(err.message, /structural validation/);
+        return true;
+    });
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal: reset truncates the log so a new window starts clean", async () => {
+    const dir = await tempDir("orbit-wal-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await (0, index_1.walReset)(file);
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), []);
+    await (0, index_1.walAppend)(file, { k: "z", n: 9 });
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), [{ k: "z", n: 9 }]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+// ------------------------------------------------ PersistedRecordJournal
+(0, node_test_1.test)("persisted record journal: appends are mirrored to the WAL and replay verbatim", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    await journal.flush();
+    const recovered = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.equal(recovered.size(), 2);
+    // Byte-identical recovery: entryUid / orderIndex / payloads all preserved.
+    strict_1.default.deepEqual(recovered.snapshot(), journal.snapshot());
+    const engine = new index_1.ReplayEngine(recovered);
+    strict_1.default.equal(engine.replayCall(index_1.ChannelKind.LLM_ACCESS, "chatRound", (0, index_1.digestInputs)("hello"), 0), "hello-back");
+    strict_1.default.equal(engine.replayCall(index_1.ChannelKind.MEM_KV_STORE, "readEntry", (0, index_1.digestInputs)("k"), 1), "v");
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: writes are serialised so lines never interleave", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    for (let i = 0; i < 40; i += 1) {
+        journal.append({
+            channelKind: index_1.ChannelKind.MEM_KV_STORE,
+            funcName: "readEntry",
+            inputDigest: (0, index_1.digestInputs)(`k${i}`),
+            outputSnapshot: `v${i}`,
+            durationMs: i
+        });
+    }
+    await journal.flush();
+    const lines = (await node_fs_1.promises.readFile(file, "utf8")).split("\n").filter((l) => l.trim() !== "");
+    strict_1.default.equal(lines.length, 40);
+    const recovered = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.equal(recovered.size(), 40);
+    recovered.snapshot().forEach((rec, i) => {
+        strict_1.default.equal(rec.orderIndex, i);
+        strict_1.default.equal(rec.outputSnapshot, `v${i}`);
+    });
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: recovered window continues orderIndex without a gap", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const first = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(first);
+    await first.flush();
+    const resumed = await index_1.PersistedRecordJournal.recover(file);
+    const next = resumed.append({
+        channelKind: index_1.ChannelKind.LLM_ACCESS,
+        funcName: "chatRound",
+        inputDigest: (0, index_1.digestInputs)("again"),
+        outputSnapshot: "again-back",
+        durationMs: 5
+    });
+    strict_1.default.equal(next.orderIndex, 2); // continues, does not restart at 0
+    await resumed.flush();
+    const reloaded = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.equal(reloaded.size(), 3);
+    strict_1.default.deepEqual(reloaded.snapshot().map((r) => r.orderIndex), [0, 1, 2]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: truncate opens a fresh window over the same path", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const first = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(first);
+    await first.flush();
+    const fresh = new index_1.PersistedRecordJournal(file, { truncate: true });
+    fresh.append({
+        channelKind: index_1.ChannelKind.MEM_KV_STORE,
+        funcName: "writeEntry",
+        inputDigest: (0, index_1.digestInputs)("k2"),
+        outputSnapshot: true,
+        durationMs: 1
+    });
+    await fresh.flush();
+    const reloaded = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.equal(reloaded.size(), 1);
+    strict_1.default.equal(reloaded.get(0).funcName, "writeEntry");
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: no path degrades to pure in-memory (flush is a no-op)", async () => {
+    const journal = new index_1.PersistedRecordJournal();
+    seedRecordJournal(journal);
+    await journal.flush();
+    strict_1.default.equal(journal.size(), 2);
+});
+(0, node_test_1.test)("persisted record journal: sync recovery matches async recovery", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    await journal.flush();
+    const sync = index_1.PersistedRecordJournal.recoverSync(file);
+    const async_ = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.deepEqual(sync.snapshot(), async_.snapshot());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+// ------------------------------------------------- PersistedTraceJournal
+(0, node_test_1.test)("persisted trace journal: audit entries survive a reload byte-identically", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: { stage: "channels" } });
+    journal.append({ entryClass: "guard.trip", traceMarkId: "t2", pluginUnitId: "p1", factPayload: { reason: "quota" } });
+    await journal.flush();
+    const recovered = await index_1.PersistedTraceJournal.recover(file);
+    strict_1.default.deepEqual(recovered.snapshot(), journal.snapshot());
+    strict_1.default.equal(recovered.byPluginUnit("p1").length, 1);
+    strict_1.default.equal(recovered.byEntryClass("boot").length, 1);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: load() replays the WAL into an existing instance", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const writer = new index_1.PersistedTraceJournal(file);
+    writer.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await writer.flush();
+    const reader = new index_1.PersistedTraceJournal(file);
+    strict_1.default.equal(reader.entries().length, 0);
+    await reader.load();
+    strict_1.default.equal(reader.entries().length, 1);
+    strict_1.default.equal(reader.entries()[0].entryClass, "boot");
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: a truncated tail is dropped on recovery", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await journal.flush();
+    await node_fs_1.promises.appendFile(file, '{"entryClass":"half', "utf8");
+    const recovered = await index_1.PersistedTraceJournal.recover(file);
+    strict_1.default.equal(recovered.entries().length, 1);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: no path behaves exactly like the base journal", async () => {
+    const journal = new index_1.PersistedTraceJournal();
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await journal.load();
+    await journal.flush();
+    strict_1.default.equal(journal.entries().length, 1);
+});
+(0, node_test_1.test)("base journals expose no-op durability hooks (uniform call sites)", async () => {
+    const trace = new index_1.TraceJournal();
+    const record = new index_1.RecordJournal();
+    await trace.load();
+    await trace.flush();
+    await record.flush();
+    strict_1.default.equal(trace.entries().length, 0);
+    strict_1.default.equal(record.size(), 0);
+});
+// ------------------------------------------------------- compaction / retention
+(0, node_test_1.test)("wal compact: rewrites the log to exactly the given entries, in order", async () => {
+    const dir = await tempDir("orbit-walc-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await (0, index_1.walAppend)(file, { k: "b", n: 2 });
+    await (0, index_1.walAppend)(file, { k: "c", n: 3 });
+    const written = await (0, index_1.walCompact)(file, [
+        { k: "b", n: 2 },
+        { k: "c", n: 3 }
+    ]);
+    strict_1.default.equal(written, 2);
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), [
+        { k: "b", n: 2 },
+        { k: "c", n: 3 }
+    ]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal compact: an empty entry list yields an empty (not deleted) log", async () => {
+    const dir = await tempDir("orbit-walc-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    strict_1.default.equal(await (0, index_1.walCompact)(file, []), 0);
+    strict_1.default.equal(await node_fs_1.promises.readFile(file, "utf8"), "");
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), []);
+    // The log stays usable: a later append starts a clean generation.
+    await (0, index_1.walAppend)(file, { k: "z", n: 9 });
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), [{ k: "z", n: 9 }]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal compact: physically heals a crash-truncated tail", async () => {
+    const dir = await tempDir("orbit-walc-");
+    const file = path.join(dir, "log.jsonl");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await (0, index_1.walAppend)(file, { k: "b", n: 2 });
+    await node_fs_1.promises.appendFile(file, '{"k":"c","n":', "utf8");
+    // Recovery tolerates the partial line, but it is still on disk...
+    const surviving = await (0, index_1.walRecover)(file, isPair);
+    strict_1.default.ok((await node_fs_1.promises.readFile(file, "utf8")).includes('{"k":"c","n":'));
+    // ...until a compaction rewrites the file from the surviving prefix.
+    await (0, index_1.walCompact)(file, surviving);
+    const healed = await node_fs_1.promises.readFile(file, "utf8");
+    strict_1.default.ok(!healed.includes('{"k":"c","n":'));
+    strict_1.default.equal(healed.split("\n").filter((l) => l.trim() !== "").length, 2);
+    strict_1.default.deepEqual(await (0, index_1.walRecover)(file, isPair), surviving);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal compact: leaves no temporary file behind and creates parent directories", async () => {
+    const dir = await tempDir("orbit-walc-");
+    const file = path.join(dir, "nested", "log.jsonl");
+    await (0, index_1.walCompact)(file, [{ k: "a", n: 1 }]);
+    strict_1.default.deepEqual(await node_fs_1.promises.readdir(path.dirname(file)), ["log.jsonl"]);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("wal line count: a mismatch against recovery is what flags a log for healing", async () => {
+    const dir = await tempDir("orbit-walc-");
+    const file = path.join(dir, "log.jsonl");
+    strict_1.default.equal(await (0, index_1.walLineCount)(file), 0, "a missing log counts as empty");
+    await (0, index_1.walAppend)(file, { k: "a", n: 1 });
+    await (0, index_1.walAppend)(file, { k: "b", n: 2 });
+    strict_1.default.equal(await (0, index_1.walLineCount)(file), 2);
+    strict_1.default.equal((await (0, index_1.walRecover)(file, isPair)).length, 2, "healthy: counts agree");
+    await node_fs_1.promises.appendFile(file, '{"k":"c","n":', "utf8");
+    strict_1.default.equal(await (0, index_1.walLineCount)(file), 3);
+    strict_1.default.equal((await (0, index_1.walRecover)(file, isPair)).length, 2, "damaged: counts disagree");
+    await (0, index_1.walCompact)(file, await (0, index_1.walRecover)(file, isPair));
+    strict_1.default.equal(await (0, index_1.walLineCount)(file), 2, "healed: counts agree again");
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted journals: healIfNeeded rewrites only a damaged log", async () => {
+    const dir = await tempDir("orbit-heal-");
+    const recordFile = path.join(dir, "record.wal.jsonl");
+    const traceFile = path.join(dir, "trace.wal.jsonl");
+    const writer = new index_1.PersistedRecordJournal(recordFile);
+    seedRecordJournal(writer);
+    await writer.flush();
+    // Healthy log: no rewrite, and the bytes are left exactly as they were.
+    const healthy = await index_1.PersistedRecordJournal.recover(recordFile);
+    const before = await node_fs_1.promises.readFile(recordFile, "utf8");
+    strict_1.default.equal(await healthy.healIfNeeded(), false);
+    strict_1.default.equal(await node_fs_1.promises.readFile(recordFile, "utf8"), before);
+    // Damaged log: rewritten from the surviving prefix.
+    await node_fs_1.promises.appendFile(recordFile, '{"entryUid":"half', "utf8");
+    const damaged = await index_1.PersistedRecordJournal.recover(recordFile);
+    strict_1.default.equal(await damaged.healIfNeeded(), true);
+    strict_1.default.equal(await node_fs_1.promises.readFile(recordFile, "utf8"), before);
+    // Same contract on the trace side, driven through load().
+    const trace = new index_1.PersistedTraceJournal(traceFile);
+    trace.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await trace.flush();
+    const traceBefore = await node_fs_1.promises.readFile(traceFile, "utf8");
+    await node_fs_1.promises.appendFile(traceFile, '{"entryUid":"half', "utf8");
+    const reader = new index_1.PersistedTraceJournal(traceFile);
+    await reader.load(); // load() heals as part of recovery
+    strict_1.default.equal(await node_fs_1.promises.readFile(traceFile, "utf8"), traceBefore);
+    strict_1.default.equal(await reader.healIfNeeded(reader.entries().length), false);
+    // No path: healing is a no-op rather than an error.
+    strict_1.default.equal(await new index_1.PersistedRecordJournal().healIfNeeded(), false);
+    strict_1.default.equal(await new index_1.PersistedTraceJournal().healIfNeeded(0), false);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: compact heals a truncated tail without losing calls", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    await journal.flush();
+    await node_fs_1.promises.appendFile(file, '{"entryUid":"half', "utf8");
+    const resumed = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.equal(resumed.size(), 2);
+    strict_1.default.equal(await resumed.compact(), 2);
+    const raw = await node_fs_1.promises.readFile(file, "utf8");
+    strict_1.default.ok(!raw.includes('{"entryUid":"half'));
+    const reloaded = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.deepEqual(reloaded.snapshot(), resumed.snapshot());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: compact is ordered after pending appends", async () => {
+    const dir = await tempDir("orbit-precj-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    // Deliberately do not flush: compaction must queue behind the pending writes.
+    strict_1.default.equal(await journal.compact(), 2);
+    await journal.flush();
+    const reloaded = await index_1.PersistedRecordJournal.recover(file);
+    strict_1.default.deepEqual(reloaded.snapshot(), journal.snapshot());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: compact is a no-op without a path", async () => {
+    const journal = new index_1.PersistedRecordJournal();
+    seedRecordJournal(journal);
+    strict_1.default.equal(await journal.compact(), 0);
+    strict_1.default.equal(journal.size(), 2);
+});
+(0, node_test_1.test)("persisted trace journal: retainLast bounds the durable audit log", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const journal = new index_1.PersistedTraceJournal(file);
+    for (let i = 0; i < 10; i += 1) {
+        journal.append({ entryClass: "tick", traceMarkId: `t${i}`, factPayload: { i } });
+    }
+    await journal.flush();
+    strict_1.default.equal((await index_1.PersistedTraceJournal.recover(file)).entries().length, 10);
+    strict_1.default.equal(await journal.retainLast(3), 3);
+    strict_1.default.deepEqual(journal.entries().map((e) => e.traceMarkId), ["t7", "t8", "t9"]);
+    const reloaded = await index_1.PersistedTraceJournal.recover(file);
+    strict_1.default.deepEqual(reloaded.snapshot(), journal.snapshot());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: retainLast(0) clears memory and disk together", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await journal.flush();
+    strict_1.default.equal(await journal.retainLast(0), 0);
+    strict_1.default.equal(journal.entries().length, 0);
+    strict_1.default.equal(await node_fs_1.promises.readFile(file, "utf8"), "");
+    // Still writable afterwards — retention does not retire the journal.
+    journal.append({ entryClass: "boot", traceMarkId: "t2", factPayload: {} });
+    await journal.flush();
+    strict_1.default.equal((await index_1.PersistedTraceJournal.recover(file)).entries().length, 1);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: retainLast above the current size keeps everything", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    journal.append({ entryClass: "boot", traceMarkId: "t2", factPayload: {} });
+    await journal.flush();
+    strict_1.default.equal(await journal.retainLast(50), 2);
+    strict_1.default.deepEqual((await index_1.PersistedTraceJournal.recover(file)).snapshot(), journal.snapshot());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: retainLast rejects a non-integer or negative bound", async () => {
+    const journal = new index_1.PersistedTraceJournal();
+    await strict_1.default.rejects(() => journal.retainLast(-1), RangeError);
+    await strict_1.default.rejects(() => journal.retainLast(1.5), RangeError);
+    await strict_1.default.rejects(() => journal.retainLast(Number.NaN), RangeError);
+});
+(0, node_test_1.test)("persisted trace journal: compact heals a truncated tail and no-ops without a path", async () => {
+    const dir = await tempDir("orbit-ptj-");
+    const file = path.join(dir, "trace.wal.jsonl");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await journal.flush();
+    await node_fs_1.promises.appendFile(file, '{"entryUid":"half', "utf8");
+    const resumed = await index_1.PersistedTraceJournal.recover(file);
+    strict_1.default.equal(await resumed.compact(), 1);
+    strict_1.default.ok(!(await node_fs_1.promises.readFile(file, "utf8")).includes('{"entryUid":"half'));
+    strict_1.default.equal(await new index_1.PersistedTraceJournal().compact(), 0);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+// --------------------------------------------------- failed writes must surface
+/**
+ * A WAL path that cannot be written: its parent is a regular file, so the
+ * `mkdir` inside every WAL write fails (EEXIST here, ENOTDIR on POSIX). Either
+ * way the write is refused — the exact errno is the platform's business.
+ */
+async function unwritableWalPath(prefix) {
+    const dir = await tempDir(prefix);
+    const blocker = path.join(dir, "blocker");
+    await node_fs_1.promises.writeFile(blocker, "not a directory", "utf8");
+    return { dir, file: path.join(blocker, "log.jsonl") };
+}
+(0, node_test_1.test)("persisted record journal: a lost append makes flush() reject", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    const journal = new index_1.PersistedRecordJournal(file);
+    // The append itself must not throw: a failed disk write cannot abort a call
+    // that is already in flight.
+    seedRecordJournal(journal);
+    strict_1.default.equal(journal.size(), 2, "the in-memory journal is still the source of truth");
+    await strict_1.default.rejects(journal.flush(), (err) => {
+        strict_1.default.ok(err instanceof Error);
+        return true;
+    });
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: a lost append makes flush() reject", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await strict_1.default.rejects(journal.flush(), (err) => {
+        strict_1.default.ok(err instanceof Error);
+        return true;
+    });
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted journals: flush() stays rejected so a retry cannot report a false success", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    await strict_1.default.rejects(journal.flush());
+    // Sticky on purpose: once a write has been lost, no later flush may claim the
+    // record is durable. Otherwise `shutdownHost` could report a clean shutdown
+    // for a window it silently dropped.
+    await strict_1.default.rejects(journal.flush());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: a failed truncate surfaces through flush(), not the constructor", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    // Constructing must not throw — a bad path is a durability problem to report
+    // at flush time, not a reason the host cannot boot.
+    const journal = new index_1.PersistedRecordJournal(file, { truncate: true });
+    await strict_1.default.rejects(journal.flush());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: a failed compaction is not swallowed before flush()", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    // compact() rejects for its own caller...
+    await strict_1.default.rejects(journal.compact());
+    // ...and the failure is still parked for flush(), which is what a shutdown
+    // path actually awaits.
+    await strict_1.default.rejects(journal.flush());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted trace journal: a failed compaction is not swallowed before flush()", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    const journal = new index_1.PersistedTraceJournal(file);
+    journal.append({ entryClass: "boot", traceMarkId: "t1", factPayload: {} });
+    await strict_1.default.rejects(journal.compact());
+    await strict_1.default.rejects(journal.flush());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted record journal: healIfNeeded propagates a failed compaction", async () => {
+    const { dir, file } = await unwritableWalPath("orbit-walfail-");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    // The line count (0) disagrees with size() (2), so healing is attempted and
+    // the failed rewrite must not be quietly ignored.
+    await strict_1.default.rejects(journal.healIfNeeded());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted journals: a writable path still flushes cleanly (no false positives)", async () => {
+    const dir = await tempDir("orbit-walok-");
+    const file = path.join(dir, "record.wal.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    await strict_1.default.doesNotReject(journal.flush());
+    strict_1.default.equal((await index_1.PersistedRecordJournal.recover(file)).size(), 2);
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+(0, node_test_1.test)("persisted journals: appends after a failure still queue (the chain never breaks)", async () => {
+    const dir = await tempDir("orbit-walfail-");
+    const blocker = path.join(dir, "blocker");
+    await node_fs_1.promises.writeFile(blocker, "not a directory", "utf8");
+    const file = path.join(blocker, "log.jsonl");
+    const journal = new index_1.PersistedRecordJournal(file);
+    seedRecordJournal(journal);
+    await strict_1.default.rejects(journal.flush());
+    // A journal that stopped accepting work after one bad write would break the
+    // live run as well as the durable one.
+    journal.append({
+        channelKind: index_1.ChannelKind.MEM_KV_STORE,
+        funcName: "writeEntry",
+        inputDigest: (0, index_1.digestInputs)("k3"),
+        outputSnapshot: true,
+        durationMs: 1
+    });
+    strict_1.default.equal(journal.size(), 3);
+    await strict_1.default.rejects(journal.flush());
+    await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+});
+//# sourceMappingURL=journal_wal.test.js.map