@indigoai-us/hq-cloud 6.18.44-alpha.8 → 6.18.44

package/dist/sync/state-store.test.js

@@ -1,1556 +0,0 @@
-import * as fs from "node:fs";
-import * as crypto from "node:crypto";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { StateStore, StateStoreCorruptionError, StateStoreLockError, StateStoreUnsupportedFormatError, SNAPSHOT_V4_MAGIC, getStateStoreSnapshotEncodeCountForTest, getStateStoreSnapshotMaterializationCountForTest, getStateStoreSnapshotRecoveryCountForTest, resetStateStoreSnapshotEncodeCountForTest, resetStateStoreSnapshotMaterializationCountForTest, resetStateStoreSnapshotRecoveryCountForTest, setStateStoreAfterGenerationStageHookForTest, setStateStoreAfterOptimisticRecoveryHookForTest, setStateStoreAsyncLockTimeoutForTest, setStateStorePositionalWriteForTest, setStateStoreReflinkCopyHookForTest, setStateStoreRotationClaimReleaseHookForTest, setStateStoreRotationClaimWriteHookForTest, setStateStoreScopeLockAcquiredHookForTest, setStateStoreScopeLockOpenedHookForTest, setStateStoreScopeLockContendedHookForTest, setStateStoreScopeLockWriteHookForTest, setStateStoreSyncLockTimeoutForTest, setStateStoreSnapshotReadHookForTest, setStateStoreSnapshotWriteHookForTest, setStateStoreWalReadHookForTest, setStateStoreNowMsForTest, setStateStoreSleepForTest, setStateStoreRandomForTest, encodeSnapshotBytesForTest, encodeSnapshotChunksForTest, } from "./state-store.js";
-const RECORD = 7;
-const roots = [];
-afterEach(() => {
-    setStateStoreSnapshotWriteHookForTest(undefined);
-    setStateStoreSnapshotReadHookForTest(undefined);
-    setStateStoreWalReadHookForTest(undefined);
-    setStateStoreAfterGenerationStageHookForTest(undefined);
-    setStateStoreAfterOptimisticRecoveryHookForTest(undefined);
-    setStateStoreReflinkCopyHookForTest(undefined);
-    setStateStorePositionalWriteForTest(undefined);
-    setStateStoreRotationClaimReleaseHookForTest(undefined);
-    setStateStoreRotationClaimWriteHookForTest(undefined);
-    setStateStoreScopeLockAcquiredHookForTest(undefined);
-    setStateStoreScopeLockOpenedHookForTest(undefined);
-    setStateStoreScopeLockContendedHookForTest(undefined);
-    setStateStoreScopeLockWriteHookForTest(undefined);
-    setStateStoreAsyncLockTimeoutForTest(undefined);
-    setStateStoreSyncLockTimeoutForTest(undefined);
-    setStateStoreNowMsForTest(undefined);
-    setStateStoreSleepForTest(undefined);
-    setStateStoreRandomForTest(undefined);
-    for (const root of roots.splice(0))
-        fs.rmSync(root, { recursive: true, force: true });
-});
-function openStore(root = makeRoot(), threshold = 256) {
-    return StateStore.open({
-        rootDir: root,
-        scopeId: "prs_test_scope",
-        initialState: { values: [] },
-        maxRecordsBeforeCompaction: threshold,
-        reduce: (state, record) => {
-            if (record.type !== RECORD || typeof record.payload !== "string") {
-                throw new Error("test reducer received an invalid record");
-            }
-            return { values: [...state.values, record.payload] };
-        },
-    });
-}
-function snapshotDecoder(chunks) {
-    return JSON.parse(Buffer.concat([...chunks]).toString("utf8"));
-}
-function snapshotPathFor(store) {
-    return path.join(store.stateDir, `snapshot-${store.getGeneration()}.bin`);
-}
-function rewriteSnapshotPayload(store, payload) {
-    const snapshotPath = snapshotPathFor(store);
-    const existing = fs.readFileSync(snapshotPath);
-    const header = Buffer.from(existing.subarray(0, 52));
-    header.writeUInt32BE(payload.length, 16);
-    const checksum = crypto.createHash("sha256").update(header).update(payload).digest();
-    fs.writeFileSync(snapshotPath, Buffer.concat([header, payload, checksum]));
-}
-function rewriteSnapshotMagic(store, magic, generation = store.getGeneration()) {
-    const snapshotPath = path.join(store.stateDir, `snapshot-${generation}.bin`);
-    const body = Buffer.from(fs.readFileSync(snapshotPath));
-    magic.copy(body, 0);
-    crypto.createHash("sha256").update(body.subarray(0, body.length - 32)).digest()
-        .copy(body, body.length - 32);
-    fs.writeFileSync(snapshotPath, body);
-}
-function expectUnsupportedSnapshotFormat(open, found, accepted) {
-    let thrown;
-    try {
-        open();
-    }
-    catch (error) {
-        thrown = error;
-    }
-    expect(thrown).toBeInstanceOf(StateStoreUnsupportedFormatError);
-    expect(thrown).not.toBeInstanceOf(StateStoreCorruptionError);
-    const error = thrown;
-    expect(error.foundMagic).toBe(found);
-    expect([...error.acceptedMagics]).toEqual(accepted);
-    expect(error.message).toContain(`is ${found}`);
-    expect(error.message).toContain(`this reader accepts ${accepted.join(", ")}`);
-    expect(error.message).toMatch(/Upgrade @indigoai-us\/hq-cloud/);
-    expect(error.message).toMatch(/Do not delete ~\/\.hq\/sync-state-v3/);
-    expect(error.message).not.toMatch(/corruption/i);
-    return error;
-}
-function openReplacingStore(root, options = {}) {
-    return StateStore.open({
-        rootDir: root,
-        scopeId: "replacing_test_scope",
-        initialState: { value: "" },
-        ...options,
-        reduce: (_state, record) => ({ value: String(record.payload) }),
-    });
-}
-function makeRoot() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-state-store-test-"));
-    roots.push(root);
-    return root;
-}
-/** Deterministic fold-retry clock. `freeze` keeps elapsed at 0 so budget never expires. */
-function installDeterministicCompactionClock(options = {}) {
-    const clock = { now: 0 };
-    setStateStoreNowMsForTest(() => clock.now);
-    setStateStoreSleepForTest((ms) => {
-        if (!options.freeze)
-            clock.now += ms;
-    });
-    setStateStoreRandomForTest(() => 1);
-}
-function openReplacingStoreWithoutCompacting(root, options) {
-    const skip = vi.spyOn(StateStore.prototype, "compactIfNeeded").mockReturnValue(false);
-    try {
-        return openReplacingStore(root, options);
-    }
-    finally {
-        skip.mockRestore();
-    }
-}
-function seedReplacingWal(root, payloadSize) {
-    const writer = openReplacingStore(root, { maxWalBytesBeforeCompaction: 16 * 1024 * 1024 });
-    writer.append(RECORD, "x".repeat(payloadSize));
-    return writer.getRecoveryStats().walBytes;
-}
-function countFailedReplacementAttempts(overBudgetRatio) {
-    installDeterministicCompactionClock();
-    const root = makeRoot();
-    const walBytes = seedReplacingWal(root, 2_000);
-    const maxWalBytesBeforeCompaction = Math.max(81, Math.floor(walBytes / overBudgetRatio));
-    const replacing = openReplacingStoreWithoutCompacting(root, {
-        maxWalBytesBeforeCompaction,
-        maxRecordsBeforeCompaction: 1_000_000,
-    });
-    const racing = openReplacingStore(root, {
-        maxWalBytesBeforeCompaction: 16 * 1024 * 1024,
-        maxRecordsBeforeCompaction: 1_000_000,
-    });
-    let attempts = 0;
-    setStateStoreSnapshotWriteHookForTest(() => {
-        attempts += 1;
-        racing.append(RECORD, `race-${attempts}`);
-    });
-    expect(() => replacing.replaceState({ value: "never" })).toThrow(StateStoreLockError);
-    return attempts;
-}
-describe("StateStore frame ceiling", () => {
-    // A journal delta carries one upsert per changed file. On a 455k-entry
-    // personal vault a mass restamp encodes to roughly 87 MB, which the previous
-    // 64 MiB ceiling rejected outright — `writeJournal` threw, the pass recorded
-    // nothing, and the next pass produced the identical oversized record. That is
-    // a permanent stall for a large scope, not a transient error, so the ceiling
-    // has to clear a realistic worst case rather than merely a typical one.
-    //
-    // Sized just past the OLD limit on purpose: this fails on a 64 MiB ceiling
-    // and passes on a larger one, which is exactly the regression being pinned.
-    const JUST_OVER_OLD_LIMIT = 68 * 1024 * 1024;
-    /**
-     * A store that will NOT compact the oversized frame away.
-     *
-     * Load-bearing. With the default 16 MiB byte threshold, appending a 68 MiB
-     * record trips compaction immediately: the state lands in a fresh snapshot
-     * and the generation's WAL is left header-only. A reopen then recovers from
-     * the snapshot and never replays the big frame — so the test would pass even
-     * if the writer accepted 256 MiB while the reader kept its old 64 MiB cap,
-     * which is the half of the change most likely to be missed. Raising both
-     * thresholds past the payload keeps the frame in the WAL, so the reopen
-     * exercises the reader's frame-length validation for real.
-     */
-    function openNonCompactingStore(root) {
-        return StateStore.open({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            maxRecordsBeforeCompaction: 1024,
-            maxWalBytesBeforeCompaction: JUST_OVER_OLD_LIMIT * 4,
-            reduce: (state, record) => {
-                if (record.type !== RECORD || typeof record.payload !== "string") {
-                    throw new Error("test reducer received an invalid record");
-                }
-                return { values: [...state.values, record.payload] };
-            },
-        });
-    }
-    it("round-trips a record larger than the previous 64 MiB ceiling", () => {
-        const root = makeRoot();
-        const store = openNonCompactingStore(root);
-        const payload = "x".repeat(JUST_OVER_OLD_LIMIT);
-        store.append(RECORD, payload);
-        // The frame must still be in the WAL — if it compacted away, the reopen
-        // below proves nothing about the reader.
-        const walBytes = fs
-            .readdirSync(store.stateDir)
-            .filter((name) => name.startsWith("wal-"))
-            .reduce((total, name) => total + fs.statSync(path.join(store.stateDir, name)).size, 0);
-        expect(walBytes).toBeGreaterThan(JUST_OVER_OLD_LIMIT);
-        // Durable, not just in memory: reopening REPLAYS that frame off disk, so a
-        // ceiling raised only on the writer surfaces here as a rejected frame.
-        const reopened = openNonCompactingStore(root);
-        expect(reopened.getState().values).toHaveLength(1);
-        expect(reopened.getState().values[0].length).toBe(JUST_OVER_OLD_LIMIT);
-    }, 60_000); // Encoding and replaying 68 MiB can exceed the suite default under coverage.
-    // NOT covered by a test, deliberately: that a payload past the NEW ceiling is
-    // still refused. Proving it requires materializing a >256 MiB JSON string,
-    // since `canonicalJson` has to encode the payload before the guard can
-    // measure it — no amount of structural sharing in the input avoids the
-    // output allocation. That is a poor trade to make on every CI run to assert a
-    // `throw` that is three lines from the constant. The guard is at
-    // `encodeFrame`; if you move the ceiling, move it there.
-});
-describe("StateStore asynchronous lock acquisition", () => {
-    it("fails fast when a synchronous contender meets an in-process async holder", async () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        let releaseHolder;
-        let held = false;
-        const holderEntered = new Promise((resolve) => {
-            setStateStoreScopeLockAcquiredHookForTest(() => {
-                if (held)
-                    return;
-                held = true;
-                resolve();
-                return new Promise((release) => {
-                    releaseHolder = release;
-                });
-            });
-        });
-        const holder = store.appendAsync(RECORD, "holder");
-        await holderEntered;
-        const started = Date.now();
-        let error;
-        try {
-            store.append(RECORD, "sync-contender");
-        }
-        catch (caught) {
-            error = caught;
-        }
-        expect(Date.now() - started).toBeLessThan(250);
-        expect(error).toMatchObject({
-            name: "StateStoreLockError",
-            reason: "in-process-async-holder",
-        });
-        expect(error).toBeInstanceOf(StateStoreLockError);
-        expect(fs.existsSync(lockPath)).toBe(true);
-        releaseHolder();
-        await expect(holder).resolves.toMatchObject({ payload: "holder" });
-        expect(fs.existsSync(lockPath)).toBe(false);
-    });
-    it("does not break an append.lock held by this process when stale probing reports ESRCH", () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-        setStateStoreSyncLockTimeoutForTest(25);
-        const kill = vi.spyOn(process, "kill").mockImplementation(() => {
-            const error = new Error("simulated stale probe");
-            error.code = "ESRCH";
-            throw error;
-        });
-        try {
-            expect(() => store.append(RECORD, "contender")).toThrow(StateStoreLockError);
-            expect(kill).not.toHaveBeenCalled();
-            expect(fs.existsSync(lockPath)).toBe(true);
-        }
-        finally {
-            kill.mockRestore();
-        }
-    });
-    it("keeps a newly created empty append.lock for its synchronous owner", () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        fs.writeFileSync(lockPath, "", { flag: "wx" });
-        setStateStoreSyncLockTimeoutForTest(25);
-        expect(() => store.append(RECORD, "contender")).toThrow(StateStoreLockError);
-        expect(fs.existsSync(lockPath)).toBe(true);
-        // The creator can still publish its PID and release the lock safely.
-        fs.writeFileSync(lockPath, String(process.pid));
-        fs.unlinkSync(lockPath);
-        expect(store.append(RECORD, "after-owner-release")).toMatchObject({ payload: "after-owner-release" });
-    });
-    it("writes its PID before an async lock acquisition yields", async () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        let releaseOpenWindow;
-        let signalOpenWindow;
-        const openWindow = new Promise((resolve) => {
-            signalOpenWindow = resolve;
-        });
-        setStateStoreScopeLockOpenedHookForTest(async () => {
-            signalOpenWindow();
-            await new Promise((resolve) => {
-                releaseOpenWindow = resolve;
-            });
-        });
-        const asyncAppend = store.appendAsync(RECORD, "async-owner").then((value) => ({ value }), (error) => ({ error }));
-        await openWindow;
-        const started = Date.now();
-        let syncError;
-        try {
-            store.append(RECORD, "sync-contender");
-        }
-        catch (error) {
-            syncError = error;
-        }
-        const syncElapsedMs = Date.now() - started;
-        const lockStillExists = fs.existsSync(lockPath);
-        const lockContents = lockStillExists ? fs.readFileSync(lockPath, "utf8") : undefined;
-        releaseOpenWindow();
-        const asyncResult = await asyncAppend;
-        expect(syncError).toBeInstanceOf(StateStoreLockError);
-        expect(syncError).toMatchObject({
-            name: "StateStoreLockError",
-            reason: "in-process-async-holder",
-        });
-        expect(lockStillExists).toBe(true);
-        expect(lockContents).toBe(String(process.pid));
-        expect(syncElapsedMs).toBeLessThan(1_000);
-        expect(asyncResult).toMatchObject({ value: { payload: "async-owner" } });
-        expect(store.getState().values).toEqual(["async-owner"]);
-        expect(fs.existsSync(lockPath)).toBe(false);
-    });
-    it("retries a newly created empty append.lock until its async owner releases it", async () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        fs.writeFileSync(lockPath, "", { flag: "wx" });
-        setStateStoreAsyncLockTimeoutForTest(2_000);
-        let retainedUntilOwnerWrites = false;
-        let releaseRetry;
-        let signalRetry;
-        const retryObserved = new Promise((resolve) => {
-            signalRetry = resolve;
-        });
-        setStateStoreScopeLockContendedHookForTest(async () => {
-            retainedUntilOwnerWrites = fs.existsSync(lockPath);
-            signalRetry();
-            await new Promise((resolve) => {
-                releaseRetry = resolve;
-            });
-        });
-        const append = store.appendAsync(RECORD, "contender");
-        await retryObserved;
-        expect(retainedUntilOwnerWrites).toBe(true);
-        fs.writeFileSync(lockPath, String(process.pid));
-        fs.unlinkSync(lockPath);
-        releaseRetry();
-        await expect(append).resolves.toMatchObject({ payload: "contender" });
-    });
-    it("queues same-process async contenders without parking the event loop", async () => {
-        const store = openStore();
-        let releaseHolder;
-        let held = false;
-        const holderEntered = new Promise((resolve) => {
-            setStateStoreScopeLockAcquiredHookForTest(() => {
-                if (held)
-                    return;
-                held = true;
-                resolve();
-                return new Promise((release) => {
-                    releaseHolder = release;
-                });
-            });
-        });
-        const holder = store.appendAsync(RECORD, "holder");
-        await holderEntered;
-        let timerFired = false;
-        const contender = store.appendAsync(RECORD, "contender");
-        await new Promise((resolve) => setTimeout(() => {
-            timerFired = true;
-            resolve();
-        }, 25));
-        expect(timerFired).toBe(true);
-        releaseHolder();
-        await expect(Promise.all([holder, contender])).resolves.toHaveLength(2);
-        expect(store.getState().values).toEqual(["holder", "contender"]);
-    });
-    it("compacts queued async appends without rejecting their durable records", async () => {
-        const root = makeRoot();
-        const store = openStore(root, 2);
-        const payloads = Array.from({ length: 12 }, (_value, index) => `record-${index}`);
-        const appended = await Promise.allSettled(payloads.map((payload) => store.appendAsync(RECORD, payload)));
-        expect(appended).not.toContainEqual(expect.objectContaining({
-            status: "rejected",
-            reason: expect.objectContaining({
-                name: "StateStoreLockError",
-                reason: "in-process-async-holder",
-            }),
-        }));
-        expect(appended.map((result) => result.status)).toEqual(payloads.map(() => "fulfilled"));
-        expect(store.getGeneration()).toBeGreaterThan(1);
-        expect(fs.statSync(path.join(store.stateDir, `wal-${store.getGeneration()}.bin`)).size).toBe(80);
-        expect(openStore(root, 2).getState().values).toEqual(payloads);
-    });
-    it("publishes staged async compaction ahead of sustained queued appenders", async () => {
-        const root = makeRoot();
-        const store = openStore(root, 2);
-        const initialPayloads = Array.from({ length: 12 }, (_value, index) => `record-${index}`);
-        const injected = [];
-        let stageAttempts = 0;
-        setStateStoreAfterGenerationStageHookForTest(() => {
-            stageAttempts++;
-            injected.push(store.appendAsync(RECORD, `during-stage-${stageAttempts}`));
-            // The old FIFO queue lets this newly queued append invalidate each plan.
-            // Stop that deterministic reproduction after several turns so a broken
-            // implementation fails the generation assertion instead of hanging.
-            if (stageAttempts === 4)
-                throw new Error("compaction publish starved");
-        });
-        const initial = await Promise.allSettled(initialPayloads.map((payload) => store.appendAsync(RECORD, payload)));
-        const duringStaging = await Promise.allSettled(injected);
-        expect(initial).toEqual(initialPayloads.map(() => expect.objectContaining({ status: "fulfilled" })));
-        expect(duringStaging).toEqual(injected.map(() => expect.objectContaining({ status: "fulfilled" })));
-        expect(stageAttempts).toBe(1);
-        expect(store.getGeneration()).toBeGreaterThan(1);
-        expect(openStore(root, 2).getState().values).toEqual([
-            ...initialPayloads,
-            "during-stage-1",
-        ]);
-    });
-    it("keeps an async append durable when compaction fails", async () => {
-        const store = openStore(makeRoot(), 1);
-        setStateStoreSnapshotWriteHookForTest(() => {
-            throw new Error("simulated compaction failure");
-        });
-        await expect(store.appendAsync(RECORD, "durable")).resolves.toMatchObject({ payload: "durable" });
-        expect(store.getState().values).toEqual(["durable"]);
-        expect(store.getGeneration()).toBe(1);
-    });
-    it("recovers this process's leaked rotation claim without rejecting async appends", async () => {
-        const root = makeRoot();
-        const store = openStore(root, 1);
-        const claimPath = path.join(store.stateDir, "rotation.lock");
-        let failRelease = true;
-        setStateStoreRotationClaimReleaseHookForTest(() => {
-            if (!failRelease)
-                return;
-            failRelease = false;
-            throw new Error("simulated rotation-claim unlink failure");
-        });
-        await expect(store.appendAsync(RECORD, "first")).resolves.toMatchObject({ payload: "first" });
-        expect(fs.readFileSync(claimPath, "utf8").trim()).toBe(String(process.pid));
-        await expect(store.appendAsync(RECORD, "second")).resolves.toMatchObject({ payload: "second" });
-        expect(fs.existsSync(claimPath)).toBe(false);
-        expect(store.getGeneration()).toBeGreaterThan(2);
-        expect(openStore(root, 1).getState().values).toEqual(["first", "second"]);
-    });
-    it("yields timers while another writer holds append.lock", async () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-        let timerFired = false;
-        const append = store.appendAsync(RECORD, "queued");
-        const timer = new Promise((resolve) => setTimeout(() => {
-            timerFired = true;
-            resolve();
-        }, 25));
-        await timer;
-        expect(timerFired).toBe(true);
-        fs.unlinkSync(lockPath);
-        await expect(append).resolves.toMatchObject({ payload: "queued" });
-    });
-    it("shares an enqueue-time deadline behind a cross-process lock holder", async () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        setStateStoreAsyncLockTimeoutForTest(100);
-        const holder = spawn(process.execPath, ["-e", [
-                "const fs = require('node:fs');",
-                "fs.writeFileSync(process.argv[1], String(process.pid), { flag: 'wx' });",
-                "process.stdout.write('ready\\n');",
-                "setInterval(() => {}, 1_000);",
-            ].join(""), lockPath], { stdio: ["ignore", "pipe", "ignore"] });
-        try {
-            await once(holder.stdout, "data");
-            const first = store.appendAsync(RECORD, "first");
-            const second = store.appendAsync(RECORD, "second");
-            const settled = await Promise.race([
-                Promise.allSettled([first, second]),
-                new Promise((resolve) => setTimeout(() => resolve(undefined), 150)),
-            ]);
-            expect(settled).toEqual([
-                expect.objectContaining({ status: "rejected", reason: expect.any(StateStoreLockError) }),
-                expect.objectContaining({ status: "rejected", reason: expect.any(StateStoreLockError) }),
-            ]);
-        }
-        finally {
-            holder.kill();
-            await once(holder, "exit");
-            fs.rmSync(lockPath, { force: true });
-        }
-    });
-    it("does not append when a queued observation is superseded while waiting", async () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-        let current = true;
-        const append = store.appendIfAsync(RECORD, "stale", () => current);
-        current = false;
-        fs.unlinkSync(lockPath);
-        await expect(append).resolves.toBeUndefined();
-        expect(store.getLastRecordSequence()).toBe(0);
-    });
-});
-describe("StateStore ordered batch append", () => {
-    it("acquires independent scopes as one lexical all-or-none publication", () => {
-        const root = makeRoot();
-        const make = (scopeId) => StateStore.open({
-            rootDir: root,
-            scopeId,
-            initialState: { values: [] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        });
-        const alpha = make("batch-alpha");
-        const beta = make("batch-beta");
-        // Deliberately reverse caller order. StateStore orders by areaId, but
-        // returns results in caller order so a transaction owner can correlate
-        // records without exposing lock paths or sort details to its callers.
-        const appended = StateStore.appendBatch([
-            { areaId: "root:beta", store: beta, type: RECORD, payload: "beta" },
-            { areaId: "root:alpha", store: alpha, type: RECORD, payload: "alpha" },
-        ]);
-        expect(appended.map((record) => record.payload)).toEqual(["beta", "alpha"]);
-        expect(alpha.getState().values).toEqual(["alpha"]);
-        expect(beta.getState().values).toEqual(["beta"]);
-        expect(fs.existsSync(path.join(alpha.stateDir, "append.lock"))).toBe(false);
-        expect(fs.existsSync(path.join(beta.stateDir, "append.lock"))).toBe(false);
-    });
-    it("cleans up a newly created batch lock when writing its PID fails", () => {
-        const store = openStore();
-        const lockPath = path.join(store.stateDir, "append.lock");
-        setStateStoreScopeLockWriteHookForTest(() => { throw new Error("simulated PID write failure"); });
-        expect(() => StateStore.appendBatch([
-            { areaId: "root:alpha", store, type: RECORD, payload: "blocked" },
-        ])).toThrow(StateStoreLockError);
-        expect(fs.existsSync(lockPath)).toBe(false);
-        setStateStoreScopeLockWriteHookForTest(undefined);
-        store.append(RECORD, "works-after-cleanup");
-        expect(store.getState().values).toEqual(["works-after-cleanup"]);
-    });
-});
-describe("StateStore WAL v3", () => {
-    it("writes protocol byte headers and appends frames without rewriting the snapshot hot path", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        const snapshot = path.join(store.stateDir, "snapshot-1.bin");
-        const wal = path.join(store.stateDir, "wal-1.bin");
-        const before = fs.statSync(snapshot);
-        const beforeWalSize = fs.statSync(wal).size;
-        store.append(RECORD, "first", 3);
-        const after = fs.statSync(snapshot);
-        const walBytes = fs.readFileSync(wal);
-        expect(after.ino).toBe(before.ino);
-        expect(fs.statSync(wal).size).toBeGreaterThan(beforeWalSize);
-        expect(walBytes.subarray(0, 8).toString("ascii")).toBe("HQWAL3\0\0");
-        expect(walBytes.readUInt32BE(80)).toBe(0x48515733);
-        expect(walBytes.readBigUInt64BE(88)).toBe(1n);
-        expect(walBytes.readUInt16BE(96)).toBe(RECORD);
-        expect(walBytes.readUInt16BE(98)).toBe(3);
-    });
-    it("truncates every incomplete tail at the last good frame boundary", () => {
-        const root = makeRoot();
-        const first = openStore(root);
-        first.append(RECORD, "durable");
-        const wal = path.join(first.stateDir, "wal-1.bin");
-        const validLength = fs.statSync(wal).size;
-        fs.appendFileSync(wal, Buffer.from([0x48, 0x51, 0x57]));
-        const recovered = openStore(root);
-        expect(recovered.getState()).toEqual({ values: ["durable"] });
-        expect(fs.statSync(wal).size).toBe(validLength);
-    });
-    it("never skips a complete frame with a bad checksum", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "bad");
-        const wal = path.join(store.stateDir, "wal-1.bin");
-        const bytes = fs.readFileSync(wal);
-        bytes[bytes.length - 1] ^= 0xff;
-        fs.writeFileSync(wal, bytes);
-        expect(() => openStore(root)).toThrow(StateStoreCorruptionError);
-    });
-    it("falls back to the retained last-good generation after a later complete frame corrupts", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "last-good");
-        store.compact();
-        store.append(RECORD, "corrupt-later");
-        const wal = path.join(store.stateDir, "wal-2.bin");
-        const bytes = fs.readFileSync(wal);
-        bytes[bytes.length - 1] ^= 0xff;
-        fs.writeFileSync(wal, bytes);
-        const recovered = openStore(root);
-        expect(recovered.getGeneration()).toBe(1);
-        expect(recovered.getState()).toEqual({ values: ["last-good"] });
-    });
-    it("allocates above a rejected generation when compaction resumes from last-good", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "last-good");
-        store.compact();
-        store.append(RECORD, "corrupt-later");
-        const wal = path.join(store.stateDir, "wal-2.bin");
-        const bytes = fs.readFileSync(wal);
-        bytes[bytes.length - 1] ^= 0xff;
-        fs.writeFileSync(wal, bytes);
-        const recovered = openStore(root);
-        recovered.compact();
-        expect(recovered.getGeneration()).toBe(3);
-        expect(openStore(root).getState()).toEqual({ values: ["last-good"] });
-    });
-    it("falls back when a crash leaves a newest snapshot without its WAL", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "last-good");
-        store.compact();
-        fs.unlinkSync(path.join(store.stateDir, "wal-2.bin"));
-        const recovered = openStore(root);
-        expect(recovered.getGeneration()).toBe(1);
-        expect(recovered.getState()).toEqual({ values: ["last-good"] });
-    });
-    it("refuses to initialize over a damaged published store with no complete generation", async () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        const snapshot = path.join(store.stateDir, "snapshot-1.bin");
-        fs.unlinkSync(path.join(store.stateDir, "wal-1.bin"));
-        expect(() => openStore(root)).toThrow(StateStoreCorruptionError);
-        await expect(StateStore.openAsync({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        })).rejects.toThrow(StateStoreCorruptionError);
-        expect(fs.existsSync(snapshot)).toBe(true);
-    });
-    it("does not silently fall back to stale state on an operational read failure", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "last-good");
-        store.compact();
-        const newestSnapshot = path.join(store.stateDir, "snapshot-2.bin");
-        fs.unlinkSync(newestSnapshot);
-        fs.mkdirSync(newestSnapshot);
-        expect(() => openStore(root)).toThrow(/cannot read snapshot generation 2/);
-    });
-    it("rejects a corrupted final frame length instead of truncating it as torn", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "durable");
-        const wal = path.join(store.stateDir, "wal-1.bin");
-        const bytes = fs.readFileSync(wal);
-        bytes.writeUInt32BE(bytes.readUInt32BE(84) + 1, 84);
-        fs.writeFileSync(wal, bytes);
-        expect(() => openStore(root)).toThrow(StateStoreCorruptionError);
-        expect(fs.statSync(wal).size).toBe(bytes.length);
-    });
-    it("chooses the highest fully valid generation even when an interrupted rename left a stale pointer", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "one");
-        store.compact();
-        fs.writeFileSync(path.join(store.stateDir, "current"), "1\n");
-        const recovered = openStore(root);
-        expect(recovered.getGeneration()).toBe(2);
-        expect(recovered.getState()).toEqual({ values: ["one"] });
-    });
-    it("compacts bounded WAL generations and preserves record sequence", () => {
-        const root = makeRoot();
-        const store = openStore(root, 2);
-        store.append(RECORD, "one");
-        store.append(RECORD, "two");
-        expect(store.getGeneration()).toBe(2);
-        store.append(RECORD, "three");
-        const recovered = openStore(root, 2);
-        expect(recovered.getGeneration()).toBe(2);
-        expect(recovered.getLastRecordSequence()).toBe(3);
-        expect(recovered.getState()).toEqual({ values: ["one", "two", "three"] });
-    });
-    it("compacts by encoded WAL bytes before the record-count limit", () => {
-        const root = makeRoot();
-        const store = openReplacingStore(root, {
-            maxRecordsBeforeCompaction: 256,
-            maxWalBytesBeforeCompaction: 800,
-        });
-        store.append(RECORD, "x".repeat(700));
-        expect(store.getGeneration()).toBe(2);
-        expect(openReplacingStore(root).getState().value).toBe("x".repeat(700));
-    });
-    it("lets a concurrent locker through during a large snapshot write", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        const competing = openStore(root);
-        let lockWaitMs = Number.NaN;
-        let competed = false;
-        setStateStoreSnapshotWriteHookForTest(() => {
-            if (competed)
-                return;
-            competed = true;
-            const started = Date.now();
-            competing.append(RECORD, "concurrent-locker");
-            lockWaitMs = Date.now() - started;
-        });
-        // Large enough to make a real materialisation meaningful without turning
-        // this unit test into a 120 MB fixture. On origin/main the same synchronous
-        // append waits for LOCK_TIMEOUT_MS because writeGeneration owns append.lock.
-        store.replaceState({ values: ["x".repeat(8 * 1024 * 1024)] });
-        expect(lockWaitMs).toBeLessThan(250);
-        expect(competing.getState().values).toContain("concurrent-locker");
-    }, 15_000);
-    it("does not hold append.lock while a large cold open parses its snapshot", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.replaceState({ values: ["x".repeat(4 * 1024 * 1024)] });
-        const competing = openStore(root);
-        let lockWaitMs = Number.NaN;
-        let competed = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (competed)
-                return;
-            competed = true;
-            const started = Date.now();
-            competing.append(RECORD, "scoped-push-locker");
-            lockWaitMs = Date.now() - started;
-        });
-        const opened = openStore(root);
-        expect(opened.getState().values).toContain("scoped-push-locker");
-        // Before this change the hook runs under open's append.lock and the
-        // competing append waits for the 5,000 ms lock budget before failing.
-        expect(lockWaitMs).toBeLessThan(250);
-    }, 20_000);
-    it("keeps the asynchronous cold open lock-light too", async () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.replaceState({ values: ["x".repeat(2 * 1024 * 1024)] });
-        const competing = openStore(root);
-        let lockWaitMs = Number.NaN;
-        let competed = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (competed)
-                return;
-            competed = true;
-            const started = Date.now();
-            competing.append(RECORD, "async-scoped-push-locker");
-            lockWaitMs = Date.now() - started;
-        });
-        const opened = await StateStore.openAsync({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        });
-        expect(opened.getState().values).toContain("async-scoped-push-locker");
-        expect(lockWaitMs).toBeLessThan(250);
-    }, 20_000);
-    it("retries a cold open when a rotation publishes during its snapshot read", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "old");
-        writer.compact();
-        const rotating = openStore(root);
-        let rotated = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (rotated)
-                return;
-            rotated = true;
-            rotating.replaceState({ values: ["newer"] });
-        });
-        const opened = openStore(root);
-        expect(rotated).toBe(true);
-        expect(opened.getGeneration()).toBe(rotating.getGeneration());
-        expect(opened.getState()).toEqual({ values: ["newer"] });
-    });
-    it("retries a cold open when rotation prunes every sampled generation", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "old");
-        writer.compact();
-        const rotating = openStore(root);
-        let rotated = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (rotated)
-                return;
-            rotated = true;
-            rotating.replaceState({ values: ["first-newer"] });
-            rotating.replaceState({ values: ["latest"] });
-        });
-        const opened = openStore(root);
-        expect(rotated).toBe(true);
-        expect(opened.getGeneration()).toBe(rotating.getGeneration());
-        expect(opened.getState()).toEqual({ values: ["latest"] });
-    });
-    it("tails concurrent WAL appends after one off-lock snapshot replay", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.replaceState({ values: ["x".repeat(512 * 1024)] });
-        resetStateStoreSnapshotRecoveryCountForTest();
-        let writesDuringRecovery = 0;
-        setStateStoreWalReadHookForTest(() => {
-            writesDuringRecovery++;
-            if (writesDuringRecovery > 1) {
-                throw new Error("cold recovery replayed the snapshot instead of tailing the WAL");
-            }
-            writer.append(RECORD, "appended-during-recovery");
-        });
-        const opened = openStore(root);
-        expect(writesDuringRecovery).toBe(1);
-        expect(getStateStoreSnapshotRecoveryCountForTest()).toBe(1);
-        expect(opened.getState().values).toContain("appended-during-recovery");
-    });
-    it("falls back when tail validation encounters a newly appended corrupt frame", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "last-good");
-        writer.compact();
-        const wal = path.join(writer.stateDir, `wal-${writer.getGeneration()}.bin`);
-        let corrupted = false;
-        setStateStoreWalReadHookForTest(() => {
-            if (corrupted)
-                return;
-            corrupted = true;
-            fs.appendFileSync(wal, Buffer.alloc(8));
-        });
-        const opened = openStore(root);
-        expect(corrupted).toBe(true);
-        expect(opened.getGeneration()).toBe(1);
-        expect(opened.getState()).toEqual({ values: ["last-good"] });
-    });
-    it("repairs a torn concurrent WAL suffix before installing an optimistic read", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.replaceState({ values: ["durable"] });
-        const wal = path.join(writer.stateDir, `wal-${writer.getGeneration()}.bin`);
-        const completeBytes = fs.statSync(wal).size;
-        let appendedTornSuffix = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (appendedTornSuffix)
-                return;
-            appendedTornSuffix = true;
-            fs.appendFileSync(wal, Buffer.from([0x48, 0x51, 0x57]));
-        });
-        const opened = openStore(root);
-        expect(appendedTornSuffix).toBe(true);
-        expect(opened.getState()).toEqual({ values: ["durable"] });
-        expect(fs.statSync(wal).size).toBe(completeBytes);
-    });
-    it("lets a scoped-push-shaped append through repeated heavy cold opens", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.replaceState({ values: ["x".repeat(2 * 1024 * 1024)] });
-        const scopedPush = openStore(root);
-        let lockWaitMs = Number.NaN;
-        let attempted = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (attempted)
-                return;
-            attempted = true;
-            const started = Date.now();
-            scopedPush.append(RECORD, "small-event-driven-push");
-            lockWaitMs = Date.now() - started;
-        });
-        for (let i = 0; i < 4; i++)
-            openStore(root);
-        expect(attempted).toBe(true);
-        expect(lockWaitMs).toBeLessThan(250);
-        expect(openStore(root).getState().values).toContain("small-event-driven-push");
-    }, 30_000);
-    it("does not hold append.lock while maintenance recovers a large snapshot", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.replaceState({ values: ["x".repeat(2 * 1024 * 1024)] });
-        const competing = openStore(root);
-        let lockWaitMs = Number.NaN;
-        let competed = false;
-        setStateStoreSnapshotReadHookForTest(() => {
-            if (competed)
-                return;
-            competed = true;
-            const started = Date.now();
-            competing.append(RECORD, "maintenance-race");
-            lockWaitMs = Date.now() - started;
-        });
-        const repair = StateStore.repairIfNeeded({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        }, { force: true });
-        expect(repair).toMatchObject({ status: "repaired" });
-        expect(lockWaitMs).toBeLessThan(250);
-        expect(openStore(root).getState().values).toContain("maintenance-race");
-    }, 30_000);
-    it("keeps the prior generation recoverable when staging is interrupted before swap", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "old-generation");
-        const before = store.getGeneration();
-        setStateStoreAfterGenerationStageHookForTest(() => {
-            throw new Error("injected crash after durable staging");
-        });
-        expect(() => store.compact()).toThrow("injected crash after durable staging");
-        expect(openStore(root).getGeneration()).toBe(before);
-        expect(openStore(root).getState()).toEqual({ values: ["old-generation"] });
-    });
-    it("retries compaction after a racing append skips the rotation claim", () => {
-        const root = makeRoot();
-        const compacting = openStore(root);
-        const racing = openStore(root);
-        compacting.append(RECORD, "before-race");
-        let raced = false;
-        setStateStoreSnapshotWriteHookForTest(() => {
-            if (raced)
-                return;
-            raced = true;
-            racing.append(RECORD, "during-race");
-        });
-        compacting.compact();
-        expect(raced).toBe(true);
-        expect(compacting.getGeneration()).toBe(2);
-        expect(openStore(root).getState()).toEqual({ values: ["before-race", "during-race"] });
-        expect(fs.statSync(path.join(compacting.stateDir, "wal-2.bin")).size).toBe(80);
-    });
-    it("compacts an over-budget WAL while opening a recovered store", () => {
-        const root = makeRoot();
-        const writer = openStore(root, 10_000);
-        writer.append(RECORD, "first");
-        writer.append(RECORD, "second");
-        writer.append(RECORD, "third");
-        expect(fs.statSync(path.join(writer.stateDir, "wal-1.bin")).size).toBeGreaterThan(80);
-        const reopened = openStore(root, 2);
-        expect(reopened.getState()).toEqual({ values: ["first", "second", "third"] });
-        expect(reopened.getGeneration()).toBeGreaterThan(1);
-        expect(fs.statSync(path.join(reopened.stateDir, `wal-${reopened.getGeneration()}.bin`)).size).toBe(80);
-    });
-    it("cooperatively compacts a recovered over-budget WAL during async open", async () => {
-        const root = makeRoot();
-        const writer = openStore(root, 10_000);
-        writer.append(RECORD, "first");
-        writer.append(RECORD, "second");
-        writer.append(RECORD, "third");
-        let releaseHolder;
-        let held = false;
-        const holderEntered = new Promise((resolve) => {
-            setStateStoreScopeLockAcquiredHookForTest(() => {
-                if (held)
-                    return;
-                held = true;
-                resolve();
-                return new Promise((release) => {
-                    releaseHolder = release;
-                });
-            });
-        });
-        let holder;
-        setStateStoreAfterOptimisticRecoveryHookForTest(async () => {
-            holder = writer.appendAsync(RECORD, "holder");
-            await holderEntered;
-        });
-        const opened = StateStore.openAsync({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            maxRecordsBeforeCompaction: 2,
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        });
-        await holderEntered;
-        setTimeout(() => releaseHolder(), 25);
-        await expect(opened).resolves.toMatchObject({ state: { values: ["first", "second", "third", "holder"] } });
-        await expect(holder).resolves.toMatchObject({ payload: "holder" });
-        const reopened = await opened;
-        expect(reopened.getGeneration()).toBeGreaterThan(1);
-        expect(fs.statSync(path.join(reopened.stateDir, `wal-${reopened.getGeneration()}.bin`)).size).toBe(80);
-    });
-    it("replaces state with rollback-readable header-only generations", () => {
-        const root = makeRoot();
-        const store = openReplacingStore(root);
-        store.append(RECORD, "legacy-record");
-        store.replaceState({ value: "replacement" });
-        expect(store.getState()).toEqual({ value: "replacement" });
-        expect(store.getLastRecordSequence()).toBe(1);
-        const walSizes = fs.readdirSync(store.stateDir)
-            .filter((name) => /^wal-\d+\.bin$/.test(name))
-            .map((name) => fs.statSync(path.join(store.stateDir, name)).size);
-        expect(walSizes).toEqual([80, 80]);
-        expect(openReplacingStore(root).getState()).toEqual({ value: "replacement" });
-    });
-    it("retries a replacement when an append advances its staged source", () => {
-        const root = makeRoot();
-        const replacing = openReplacingStore(root);
-        const racing = openReplacingStore(root);
-        let raced = false;
-        setStateStoreSnapshotWriteHookForTest(() => {
-            if (raced)
-                return;
-            raced = true;
-            racing.append(RECORD, "during-replacement");
-        });
-        replacing.replaceState({ value: "replacement" });
-        expect(raced).toBe(true);
-        expect(replacing.getState()).toEqual({ value: "replacement" });
-        expect(openReplacingStore(root).getState()).toEqual({ value: "replacement" });
-    });
-    it("compacts a replacement under sustained concurrent writes that beat three immediate retries", () => {
-        installDeterministicCompactionClock({ freeze: true });
-        const root = makeRoot();
-        const replacing = openReplacingStore(root);
-        const racing = openReplacingStore(root);
-        const racesBeforeQuiet = 8;
-        let attempts = 0;
-        setStateStoreSnapshotWriteHookForTest(() => {
-            attempts += 1;
-            if (attempts <= racesBeforeQuiet)
-                racing.append(RECORD, `during-replacement-${attempts}`);
-        });
-        replacing.replaceState({ value: "replacement" });
-        expect(attempts).toBe(racesBeforeQuiet + 1);
-        expect(replacing.getState()).toEqual({ value: "replacement" });
-        expect(openReplacingStore(root).getState()).toEqual({ value: "replacement" });
-        expect(fs.statSync(path.join(replacing.stateDir, `wal-${replacing.getGeneration()}.bin`)).size).toBe(80);
-    });
-    it("retries a far-over-budget replacement harder than a barely-over-budget one", () => {
-        const barelyAttempts = countFailedReplacementAttempts(1);
-        const farAttempts = countFailedReplacementAttempts(12);
-        expect(farAttempts).toBeGreaterThan(barelyAttempts);
-        expect(barelyAttempts).toBeGreaterThan(3);
-        installDeterministicCompactionClock({ freeze: true });
-        const root = makeRoot();
-        seedReplacingWal(root, 2_000);
-        const quiet = openReplacingStore(root);
-        quiet.replaceState({ value: "recovered" });
-        expect(quiet.getState()).toEqual({ value: "recovered" });
-    });
-    it("recovers only the newest valid generation instead of replaying every retained WAL", () => {
-        const root = makeRoot();
-        const writer = openReplacingStore(root);
-        writer.append(RECORD, "first");
-        writer.compact();
-        writer.append(RECORD, "second");
-        let replayed = 0;
-        const recovered = StateStore.open({
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            reduce: (_state, record) => {
-                replayed++;
-                return { value: String(record.payload) };
-            },
-        });
-        expect(recovered.getState()).toEqual({ value: "second" });
-        expect(replayed).toBe(1);
-    });
-    it("bounds recovery reads to one WAL frame instead of the whole WAL", () => {
-        const root = makeRoot();
-        const writer = openReplacingStore(root, { maxWalBytesBeforeCompaction: 1024 * 1024 });
-        for (let i = 0; i < 8; i++)
-            writer.append(RECORD, `${i}:${"x".repeat(8_192)}`);
-        const recovered = openReplacingStore(root);
-        const stats = recovered.getRecoveryStats();
-        expect(stats.walBytes).toBeGreaterThan(64 * 1024);
-        expect(stats.maxReadBytes).toBeLessThan(16 * 1024);
-    });
-    it("repairs an oversized generation with one full snapshot materialisation", () => {
-        const root = makeRoot();
-        const writer = openReplacingStore(root, { maxWalBytesBeforeCompaction: 1024 * 1024 });
-        for (let i = 0; i < 8; i++)
-            writer.append(RECORD, `${i}:${"x".repeat(8_192)}`);
-        const oversizedWal = path.join(writer.stateDir, "wal-1.bin");
-        expect(fs.statSync(oversizedWal).size).toBeGreaterThan(64 * 1024);
-        let replayed = 0;
-        const progress = [];
-        setStateStoreReflinkCopyHookForTest(() => {
-            throw new Error("reflink unavailable for test");
-        });
-        resetStateStoreSnapshotMaterializationCountForTest();
-        resetStateStoreSnapshotEncodeCountForTest();
-        const repair = StateStore.repairIfNeeded({
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            maxWalBytesBeforeCompaction: 64 * 1024,
-            reduce: (_state, record) => {
-                replayed++;
-                return { value: String(record.payload) };
-            },
-        }, { onProgress: (event) => progress.push(event) });
-        expect(repair).toMatchObject({
-            status: "repaired",
-            recoveredGeneration: 1,
-            firstCompactGeneration: 2,
-            currentGeneration: 3,
-        });
-        expect(getStateStoreSnapshotMaterializationCountForTest()).toBe(1);
-        expect(getStateStoreSnapshotEncodeCountForTest()).toBe(1);
-        expect(replayed).toBe(8);
-        expect(progress.length).toBeGreaterThan(0);
-        expect(progress.at(-1)?.bytesRead).toBe(progress.at(-1)?.totalBytes);
-        expect(fs.existsSync(oversizedWal)).toBe(false);
-        // The fallback generation remains rollback-readable, while the second
-        // snapshot is a copy-on-write clone of the first rather than another full
-        // materialisation of the same 120 MB state.
-        expect(fs.readdirSync(writer.stateDir).filter((name) => name.startsWith("snapshot-"))).toHaveLength(2);
-        expect(fs.readdirSync(writer.stateDir).filter((name) => name.startsWith("wal-"))).toHaveLength(2);
-        expect(fs.readFileSync(path.join(writer.stateDir, "current"), "utf8")).toBe("3\n");
-        expect(openReplacingStore(root).getGeneration()).toBe(3);
-        expect(openReplacingStore(root).getState()).toEqual({ value: `7:${"x".repeat(8_192)}` });
-        replayed = 0;
-        expect(StateStore.repairIfNeeded({
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            maxWalBytesBeforeCompaction: 64 * 1024,
-            reduce: (_state, record) => {
-                replayed++;
-                return { value: String(record.payload) };
-            },
-        })).toMatchObject({ status: "not-needed" });
-        expect(replayed).toBe(0);
-        // A large, healthy snapshot plus an ordinary small WAL append is normal
-        // between passes. It must not force another two-generation repair.
-        openReplacingStore(root, { maxWalBytesBeforeCompaction: 1024 * 1024 })
-            .append(RECORD, "one-small-follow-up-record");
-        expect(fs.statSync(path.join(writer.stateDir, "wal-2.bin")).size).toBe(80);
-        expect(fs.statSync(path.join(writer.stateDir, "wal-3.bin")).size).toBeLessThan(64 * 1024);
-        const generationsBeforeSmallAppend = fs.readdirSync(writer.stateDir)
-            .filter((name) => name.startsWith("snapshot-"))
-            .sort();
-        expect(StateStore.repairIfNeeded({
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            maxWalBytesBeforeCompaction: 64 * 1024,
-            reduce: (_state, record) => ({ value: String(record.payload) }),
-        })).toMatchObject({ status: "not-needed" });
-        expect(fs.readdirSync(writer.stateDir)
-            .filter((name) => name.startsWith("snapshot-"))
-            .sort()).toEqual(generationsBeforeSmallAppend);
-        const files = fs.readdirSync(writer.stateDir);
-        const newest = Math.max(...files
-            .map((name) => /^snapshot-(\d+)\.bin$/.exec(name)?.[1])
-            .filter((value) => value !== undefined)
-            .map(Number));
-        const newestSnapshot = path.join(writer.stateDir, `snapshot-${newest}.bin`);
-        const bytes = fs.readFileSync(newestSnapshot);
-        bytes[bytes.length - 1] ^= 0xff;
-        fs.writeFileSync(newestSnapshot, bytes);
-        expect(openReplacingStore(root).getState()).toEqual({ value: `7:${"x".repeat(8_192)}` });
-    });
-    it("completes short positional clone-header writes before publishing", () => {
-        const root = makeRoot();
-        const writer = openReplacingStore(root, { maxWalBytesBeforeCompaction: 1024 * 1024 });
-        for (let i = 0; i < 8; i++)
-            writer.append(RECORD, `${i}:${"x".repeat(8_192)}`);
-        let shortenedHeader = false;
-        setStateStorePositionalWriteForTest((fd, buffer, offset, length, position) => {
-            if (!shortenedHeader && position === 0 && Buffer.isBuffer(buffer) && length === 52) {
-                shortenedHeader = true;
-                return fs.writeSync(fd, buffer, offset, Math.floor(length / 2), position);
-            }
-            return fs.writeSync(fd, buffer, offset, length, position);
-        });
-        expect(StateStore.repairIfNeeded({
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            maxWalBytesBeforeCompaction: 64 * 1024,
-            reduce: (_state, record) => ({ value: String(record.payload) }),
-        })).toMatchObject({ status: "repaired", currentGeneration: 3 });
-        expect(shortenedHeader).toBe(true);
-        expect(openReplacingStore(root).getGeneration()).toBe(3);
-    });
-    it("cleans a partial rotation claim and removes a malformed claim on retry", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        store.append(RECORD, "ready-to-compact");
-        const claimPath = path.join(store.stateDir, "rotation.lock");
-        setStateStoreRotationClaimWriteHookForTest(() => {
-            throw new Error("injected claim write failure");
-        });
-        store.compact();
-        expect(fs.existsSync(claimPath)).toBe(false);
-        setStateStoreRotationClaimWriteHookForTest(undefined);
-        fs.writeFileSync(claimPath, "", { flag: "wx" });
-        fs.utimesSync(claimPath, new Date(Date.now() - 1_000), new Date(Date.now() - 1_000));
-        store.compact();
-        expect(store.getGeneration()).toBe(2);
-        expect(fs.existsSync(claimPath)).toBe(false);
-    });
-    it("finishes an interrupted repair when the current pointer is stale", () => {
-        const root = makeRoot();
-        const writer = openReplacingStore(root, { maxWalBytesBeforeCompaction: 1024 * 1024 });
-        for (let i = 0; i < 8; i++)
-            writer.append(RECORD, `${i}:${"x".repeat(8_192)}`);
-        const options = {
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            maxWalBytesBeforeCompaction: 64 * 1024,
-            reduce: (_state, record) => ({
-                value: String(record.payload),
-            }),
-        };
-        const firstRepair = StateStore.repairIfNeeded(options);
-        expect(firstRepair.status).toBe("repaired");
-        fs.writeFileSync(path.join(writer.stateDir, "current"), "1\n");
-        expect(StateStore.repairIfNeeded(options)).toMatchObject({ status: "repaired" });
-        const generations = fs.readdirSync(writer.stateDir)
-            .map((name) => /^snapshot-(\d+)\.bin$/.exec(name)?.[1])
-            .filter((value) => value !== undefined)
-            .map(Number);
-        expect(generations).toHaveLength(2);
-        expect(fs.readFileSync(path.join(writer.stateDir, "current"), "utf8"))
-            .toBe(`${Math.max(...generations)}\n`);
-    });
-    it("prunes obsolete WAL history left after current pointer publication", () => {
-        const root = makeRoot();
-        const writer = openReplacingStore(root, { maxWalBytesBeforeCompaction: 1024 * 1024 });
-        for (let i = 0; i < 8; i++)
-            writer.append(RECORD, `${i}:${"x".repeat(8_192)}`);
-        writer.compact();
-        expect(fs.readFileSync(path.join(writer.stateDir, "current"), "utf8")).toBe("2\n");
-        expect(fs.statSync(path.join(writer.stateDir, "wal-1.bin")).size).toBeGreaterThan(64 * 1024);
-        const options = {
-            rootDir: root,
-            scopeId: "replacing_test_scope",
-            initialState: { value: "" },
-            maxWalBytesBeforeCompaction: 1024 * 1024,
-            reduce: (_state, record) => ({
-                value: String(record.payload),
-            }),
-        };
-        expect(StateStore.repairIfNeeded(options)).toMatchObject({ status: "repaired" });
-        const walSizes = fs.readdirSync(writer.stateDir)
-            .filter((name) => /^wal-\d+\.bin$/.test(name))
-            .map((name) => fs.statSync(path.join(writer.stateDir, name)).size);
-        expect(walSizes).toEqual([80, 80]);
-        const rollbackReader = StateStore.open({
-            ...options,
-            reduce: () => {
-                throw new Error("rollback reader must not replay a WAL record");
-            },
-        });
-        expect(rollbackReader.getState()).toEqual({ value: `7:${"x".repeat(8_192)}` });
-    });
-    it("serializes stale handles so records keep contiguous sequence numbers", () => {
-        const root = makeRoot();
-        const first = openStore(root);
-        const second = openStore(root);
-        first.append(RECORD, "one");
-        second.append(RECORD, "two");
-        expect(openStore(root).getState()).toEqual({ values: ["one", "two"] });
-    });
-    it("tails every externally appended frame without falling back to full recovery", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "already-known");
-        let readerReducerCalls = 0;
-        const reader = StateStore.open({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            reduce: (state, record) => {
-                readerReducerCalls++;
-                if (record.type !== RECORD || typeof record.payload !== "string") {
-                    throw new Error("test reducer received an invalid record");
-                }
-                return { values: [...state.values, record.payload] };
-            },
-        });
-        const wal = path.join(reader.stateDir, "wal-1.bin");
-        readerReducerCalls = 0;
-        writer.append(RECORD, "first-tail-frame");
-        writer.append(RECORD, "second-tail-frame");
-        writer.append(RECORD, "third-tail-frame");
-        const refresh = reader.refresh();
-        expect(refresh).toEqual({
-            recovered: false,
-            records: [
-                expect.objectContaining({ sequence: 2, payload: "first-tail-frame" }),
-                expect.objectContaining({ sequence: 3, payload: "second-tail-frame" }),
-                expect.objectContaining({ sequence: 4, payload: "third-tail-frame" }),
-            ],
-        });
-        expect(reader.getState()).toEqual({
-            values: ["already-known", "first-tail-frame", "second-tail-frame", "third-tail-frame"],
-        });
-        expect(reader.getLastRecordSequence()).toBe(4);
-        expect(reader.getRecoveryStats().walBytes).toBe(fs.statSync(wal).size);
-        // A fallback replays the first tail frame once before detecting corruption,
-        // then replays the entire WAL during full recovery.
-        expect(readerReducerCalls).toBe(3);
-    });
-    it("repairs a torn externally appended tail while refreshing under the append lock", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "already-known");
-        const reader = openStore(root);
-        const wal = path.join(reader.stateDir, "wal-1.bin");
-        writer.append(RECORD, "complete-tail-frame");
-        const completeBoundary = fs.statSync(wal).size;
-        fs.appendFileSync(wal, Buffer.from([0x48, 0x51, 0x57]));
-        expect(reader.refresh()).toMatchObject({ recovered: false });
-        expect(reader.getState()).toEqual({ values: ["already-known", "complete-tail-frame"] });
-        expect(fs.statSync(wal).size).toBe(completeBoundary);
-    });
-    it("falls back to the newest valid generation when an externally appended tail frame is corrupt", () => {
-        const root = makeRoot();
-        const initialWriter = openStore(root);
-        initialWriter.append(RECORD, "last-good");
-        initialWriter.compact();
-        const reader = openStore(root);
-        const writer = openStore(root);
-        const wal = path.join(reader.stateDir, "wal-2.bin");
-        writer.append(RECORD, "corrupt-tail");
-        const bytes = fs.readFileSync(wal);
-        bytes[bytes.length - 1] ^= 0xff;
-        fs.writeFileSync(wal, bytes);
-        expect(reader.refresh()).toEqual({ records: [], recovered: true });
-        expect(reader.getGeneration()).toBe(1);
-        expect(reader.getState()).toEqual({ values: ["last-good"] });
-    });
-    it("does not durably append a record rejected by the reducer", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        expect(() => store.append(99, "unsupported")).toThrow(/invalid record/);
-        expect(openStore(root).getState()).toEqual({ values: [] });
-    });
-    it("surfaces incompatible reducer records instead of falling back to stale state", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "newer-record");
-        expect(() => StateStore.open({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            reduce: () => { throw new Error("unsupported record type"); },
-        })).toThrow(/reducer rejected generation/);
-    });
-});
-describe("StateStore snapshot encoding — chunked, so one big state is never five copies", () => {
-    /**
-     * The reference is the whole-buffer encoder the chunked writer replaced. The
-     * on-disk format is unchanged, so every payload must serialize to the exact
-     * same bytes; a difference here is a format break that older readers would
-     * reject as a checksum failure.
-     */
-    const digest = Buffer.alloc(32, 7);
-    function chunked(payload) {
-        const { chunks, byteLength } = encodeSnapshotChunksForTest(1, digest, payload);
-        const joined = Buffer.concat(chunks);
-        expect(joined.length).toBe(byteLength);
-        return joined;
-    }
-    const PAYLOADS = [
-        ["empty object", { lastRecordSequence: 0, state: {} }],
-        ["nested + arrays", { lastRecordSequence: 3, state: { a: [1, 2, { b: "c" }], d: { e: null } } }],
-        ["unsorted keys", { lastRecordSequence: 1, state: { zulu: 1, alpha: 2, Mike: 3, "": 4 } }],
-        ["multi-byte text", { lastRecordSequence: 1, state: { k: "café — 日本語 🙂", "ключ": "значение" } }],
-        ["number edges", { lastRecordSequence: 1, state: { z: -0, a: 1e21, b: 0.1, c: -5, d: 1234567890123 } }],
-        ["escapes", { lastRecordSequence: 1, state: { 'q"uote': 'back\\slash\\n"', tab: "a\tb" } }],
-        ["deep", { lastRecordSequence: 1, state: { a: { b: { c: { d: { e: [[[1]]] } } } } } }],
-    ];
-    for (const [name, payload] of PAYLOADS) {
-        it(`serializes ${name} byte-for-byte like the whole-buffer encoder`, () => {
-            expect(chunked(payload).equals(encodeSnapshotBytesForTest(1, digest, payload))).toBe(true);
-        });
-    }
-    it("splits a payload larger than one chunk and keeps every chunk bounded", () => {
-        const files = {};
-        for (let index = 0; index < 20_000; index += 1) {
-            files[`alpha/file-${index}.md`] = { hash: `${index}`.padStart(64, "0"), size: index, direction: "up" };
-        }
-        const payload = { lastRecordSequence: 9, state: { journal: { files } } };
-        const { chunks, byteLength } = encodeSnapshotChunksForTest(4, digest, payload);
-        expect(byteLength).toBeGreaterThan(1_048_576);
-        // The point of the change: the bytes arrive in bounded pieces, so the
-        // encoder never holds the whole snapshot as one string AND one buffer.
-        expect(chunks.length).toBeGreaterThan(1);
-        for (const chunk of chunks)
-            expect(chunk.length).toBeLessThanOrEqual(1_048_576 + 64);
-        expect(Buffer.concat(chunks).equals(encodeSnapshotBytesForTest(4, digest, payload))).toBe(true);
-    });
-    it("keeps a surrogate pair intact across a chunk boundary", () => {
-        // An unbroken run of emoji means every chunk boundary inside the token
-        // falls between two halves of a surrogate pair unless the encoder steps
-        // back. Splitting there would encode each half as U+FFFD, and the checksum
-        // would happily cover the corrupted bytes — so the only way to catch it is
-        // byte equality against the whole-buffer encoder.
-        //
-        // The single-character pad shifts the run's start by one UTF-16 unit, which
-        // flips the parity of every boundary. One of these four lands mid-pair for
-        // any chunk budget the encoder might pick, so the test does not depend on
-        // knowing that budget.
-        for (const pad of ["", "a", "ab", "abc"]) {
-            const payload = { lastRecordSequence: 1, state: { k: `${pad}${"🙂".repeat(400_000)}` } };
-            expect(chunked(payload).equals(encodeSnapshotBytesForTest(1, digest, payload))).toBe(true);
-        }
-    });
-    it("rejects the same payloads the whole-buffer encoder rejected, before any chunk is emitted", () => {
-        const bad = [
-            ["undefined property", { lastRecordSequence: 1, state: { a: undefined } }],
-            ["undefined array item", { lastRecordSequence: 1, state: { a: [1, undefined] } }],
-            ["non-finite number", { lastRecordSequence: 1, state: { a: Number.POSITIVE_INFINITY } }],
-            ["NaN", { lastRecordSequence: 1, state: { a: Number.NaN } }],
-            ["class instance", { lastRecordSequence: 1, state: { a: new (class {
-                            x = 1;
-                        })() } }],
-            ["null-prototype object", { lastRecordSequence: 1, state: { a: Object.create(null) } }],
-        ];
-        for (const [name, payload] of bad) {
-            expect(() => encodeSnapshotChunksForTest(1, digest, payload), name).toThrow(/state-store/);
-            expect(() => encodeSnapshotBytesForTest(1, digest, payload), name).toThrow(/state-store/);
-        }
-    });
-    it("rejects an array hole the whole-buffer encoder silently turned into invalid JSON", () => {
-        // Deliberate behaviour change, pinned here so it is not mistaken for drift.
-        // `Array.prototype.map` skips holes, so the old encoder emitted the literal
-        // text `[1,,3]` — a snapshot that would fail its own next read. The chunked
-        // encoder walks indices explicitly and refuses before anything is written.
-        // Built by assignment rather than `[1, , 3]` so the fixture itself is not a
-        // lint error; index 1 is a genuine hole either way.
-        const holed = [];
-        holed[0] = 1;
-        holed[2] = 3;
-        const payload = { lastRecordSequence: 1, state: { a: holed } };
-        expect(encodeSnapshotBytesForTest(1, digest, payload).toString("utf8")).toContain("[1,,3]");
-        expect(() => encodeSnapshotChunksForTest(1, digest, payload))
-            .toThrow(/state-store: JSON arrays cannot be sparse or undefined/);
-    });
-    it("round-trips a state larger than one chunk through a real store", () => {
-        const root = makeRoot();
-        const store = openStore(root);
-        const values = [];
-        for (let index = 0; index < 20_000; index += 1) {
-            // Multi-byte on purpose: the padding pushes emoji across chunk boundaries
-            // at offsets nothing in the fixture chose by hand.
-            values.push(`value-${index}-🙂${"x".repeat(240)}`);
-        }
-        // One snapshot write rather than 20,000 fsynced appends — the encoder is
-        // what is under test here, not the WAL append path.
-        store.replaceState({ values });
-        const snapshotBytes = fs.readdirSync(store.stateDir)
-            .filter((name) => name.startsWith("snapshot-"))
-            .map((name) => fs.statSync(path.join(store.stateDir, name)).size);
-        // Without this the test could pass on a state that never needed chunking.
-        expect(Math.max(...snapshotBytes)).toBeGreaterThan(1_048_576);
-        expect(openStore(root).getState().values).toEqual(values);
-    });
-});
-describe("StateStore snapshot decoding", () => {
-    it("hands an authenticated payload to an optional decoder in bounded chunks", () => {
-        const root = makeRoot();
-        const values = Array.from({ length: 24_000 }, (_, index) => `row-${index}-${"x".repeat(64)}`);
-        const writer = StateStore.open({
-            rootDir: root,
-            scopeId: "streamed-snapshot",
-            initialState: { values },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        });
-        const chunks = [];
-        const recovered = StateStore.open({
-            rootDir: root,
-            scopeId: "streamed-snapshot",
-            initialState: { values: [] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-            snapshotDecoder: (payloadChunks) => {
-                const payload = [...payloadChunks];
-                chunks.push(...payload.map((chunk) => chunk.length));
-                return JSON.parse(Buffer.concat(payload).toString("utf8"));
-            },
-        });
-        expect(recovered.getState()).toEqual(writer.getState());
-        expect(chunks.length).toBeGreaterThan(1);
-        expect(Math.max(...chunks)).toBeLessThanOrEqual(1024 * 1024);
-    });
-    it("names HQSNAP4 as an unsupported format instead of state-store corruption", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "kept");
-        rewriteSnapshotMagic(writer, SNAPSHOT_V4_MAGIC);
-        expectUnsupportedSnapshotFormat(() => openStore(root), "HQSNAP4", ["HQSNAP3"]);
-        expect(fs.existsSync(snapshotPathFor(writer))).toBe(true);
-    });
-    it("does not fall back to an older generation when the newest magic is unrecognised", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "last-good");
-        writer.compact();
-        writer.append(RECORD, "newer");
-        expect(writer.getGeneration()).toBe(2);
-        expect(fs.existsSync(path.join(writer.stateDir, "snapshot-1.bin"))).toBe(true);
-        rewriteSnapshotMagic(writer, SNAPSHOT_V4_MAGIC, 2);
-        expectUnsupportedSnapshotFormat(() => openStore(root), "HQSNAP4", ["HQSNAP3"]);
-    });
-    it("still opens a snapshot whose owner opted into the written magic", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        writer.append(RECORD, "kept");
-        rewriteSnapshotMagic(writer, SNAPSHOT_V4_MAGIC);
-        const recovered = StateStore.open({
-            rootDir: root,
-            scopeId: "prs_test_scope",
-            initialState: { values: [] },
-            snapshotMagics: [SNAPSHOT_V4_MAGIC],
-            reduce: (state, record) => {
-                if (record.type !== RECORD || typeof record.payload !== "string") {
-                    throw new Error("test reducer received an invalid record");
-                }
-                return { values: [...state.values, record.payload] };
-            },
-        });
-        expect(recovered.getState()).toEqual({ values: ["kept"] });
-    });
-    it("hex-encodes a non-ASCII unrecognised magic and still refuses to call it corruption", () => {
-        const root = makeRoot();
-        const writer = openStore(root);
-        const magic = Buffer.from([0x00, 0x01, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00]);
-        rewriteSnapshotMagic(writer, magic);
-        expectUnsupportedSnapshotFormat(() => openStore(root), magic.toString("hex"), ["HQSNAP3"]);
-    });
-    it.each([
-        ["invalid JSON", (store) => {
-                rewriteSnapshotPayload(store, Buffer.from('{"lastRecordSequence":0,"state":', "utf8"));
-            }],
-        ["invalid state payload", (store) => {
-                rewriteSnapshotPayload(store, Buffer.from('{"state":{}}', "utf8"));
-            }],
-        ["torn payload", (store) => {
-                const snapshotPath = snapshotPathFor(store);
-                fs.truncateSync(snapshotPath, 53);
-            }],
-        ["bad checksum", (store) => {
-                const snapshotPath = snapshotPathFor(store);
-                const bytes = fs.readFileSync(snapshotPath);
-                bytes[bytes.length - 1] ^= 0xff;
-                fs.writeFileSync(snapshotPath, bytes);
-            }],
-        ["scope digest mismatch", (store) => {
-                const snapshotPath = snapshotPathFor(store);
-                const bytes = fs.readFileSync(snapshotPath);
-                bytes[20] ^= 0xff;
-                fs.writeFileSync(snapshotPath, bytes);
-            }],
-    ])("keeps %s classified as StateStoreCorruptionError with a streaming decoder", (_name, corrupt) => {
-        const root = makeRoot();
-        const writer = StateStore.open({
-            rootDir: root,
-            scopeId: "streamed-corruption",
-            initialState: { values: ["durable"] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-        });
-        corrupt(writer);
-        expect(() => StateStore.open({
-            rootDir: root,
-            scopeId: "streamed-corruption",
-            initialState: { values: [] },
-            reduce: (state, record) => ({ values: [...state.values, String(record.payload)] }),
-            snapshotDecoder,
-        })).toThrow(StateStoreCorruptionError);
-    });
-});
-//# sourceMappingURL=state-store.test.js.map