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

package/dist/journal-row-store.test.js

@@ -1,729 +0,0 @@
-/**
- * Contract tests for the packed in-memory journal rows.
- *
- * This deliberately exercises the view rather than its typed-array internals:
- * a later snapshot/WAL layer must be able to replace the storage layout without
- * changing what callers observe.
- */
-import { describe, expect, it, vi } from "vitest";
-import { JOURNAL_ENTRY_STORAGE, JournalRowStore, journalEntryFingerprint, } from "./journal-row-store.js";
-function optionalBoolean(index, offset) {
-    const value = (index + offset) % 3;
-    return value === 0 ? undefined : value === 1;
-}
-function generatedEntry(index) {
-    const entry = {
-        hash: index % 3 === 0
-            ? index.toString(16).padStart(64, "0")
-            : index % 3 === 1 ? "a".repeat(63) : "B".repeat(64),
-        size: index * 17.25,
-        syncedAt: index % 2 === 0
-            ? new Date(1_700_000_000_000 + index).toISOString()
-            : "not-an-iso-synced-at-" + index,
-        direction: index % 2 === 0 ? "up" : "down",
-    };
-    if (index % 3 !== 0)
-        entry.kind = index % 2 === 0 ? "file" : "symlink";
-    if (index % 4 !== 0)
-        entry.createdBySub = "author-" + (index % 11);
-    if (index % 3 === 1)
-        entry.remoteEtag = index.toString(16).padStart(32, "f");
-    if (index % 3 === 2)
-        entry.remoteEtag = "d".repeat(32) + "-" + (1 + (index % 5));
-    if (index % 4 !== 0)
-        entry.mtimeMs = 1_700_000_000_000 + index * 3;
-    if (index % 5 !== 0)
-        entry.ctimeMs = 1_700_000_000_000 + index * 7;
-    if (index % 5 === 0) {
-        entry.removedAt = new Date(1_700_100_000_000 + index).toISOString();
-        entry.removedReason = ["scope_shrink", "narrow_apply", "manual", "local-delete"][index % 4];
-    }
-    if (index % 6 === 0)
-        entry.message = "shared note " + index;
-    if (index % 4 === 0) {
-        entry.localDeleteIntent = {
-            version: 1,
-            remoteEtag: "e".repeat(32),
-            localHash: (index + 7).toString(16).padStart(64, "0"),
-            localKind: index % 8 === 0 ? "symlink" : "file",
-        };
-    }
-    const outOfScopeProtected = optionalBoolean(index, 0);
-    const skillMetadataPending = optionalBoolean(index, 1);
-    const localDiverges = optionalBoolean(index, 2);
-    if (outOfScopeProtected !== undefined)
-        entry.outOfScopeProtected = outOfScopeProtected;
-    if (skillMetadataPending !== undefined)
-        entry.skillMetadataPending = skillMetadataPending;
-    if (localDiverges !== undefined)
-        entry.localDiverges = localDiverges;
-    return entry;
-}
-function sameEntry(a, b) {
-    const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length)
-        return false;
-    return keys.every((key) => {
-        const left = a[key];
-        const right = b[key];
-        if (left === right)
-            return true;
-        return typeof left === "object" && left !== null && typeof right === "object" && right !== null
-            && JSON.stringify(left) === JSON.stringify(right);
-    });
-}
-function referenceDelta(previous, next) {
-    const upserts = {};
-    for (const [key, row] of Object.entries(next)) {
-        const before = previous[key];
-        if (before !== undefined && sameEntry(before, row))
-            continue;
-        upserts[key] = row;
-    }
-    return {
-        upserts,
-        deletes: Object.keys(previous).filter((key) => !Object.hasOwn(next, key)).sort(),
-    };
-}
-function deltaFromDirtyLog(store, changes) {
-    const previous = new Map();
-    for (const change of changes) {
-        if (!previous.has(change.path)) {
-            previous.set(change.path, {
-                hadPrevious: change.hadPrevious,
-                previousFingerprint: change.previousFingerprint,
-            });
-        }
-    }
-    const upserts = {};
-    const deletes = [];
-    for (const [key, before] of previous) {
-        const after = store.get(key);
-        if (after === undefined) {
-            if (before.hadPrevious)
-                deletes.push(key);
-        }
-        else if (!before.hadPrevious || before.previousFingerprint !== journalEntryFingerprint(after)) {
-            upserts[key] = after;
-        }
-    }
-    return { upserts, deletes: deletes.sort() };
-}
-function rng(seed) {
-    let state = seed >>> 0;
-    return () => {
-        state = (state + 0x6d2b79f5) >>> 0;
-        let value = state;
-        value = Math.imul(value ^ (value >>> 15), value | 1);
-        value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
-        return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296;
-    };
-}
-function expectIndexInvariant(store) {
-    const buckets = store.buckets;
-    const indexedRows = [...buckets].filter((row) => row !== 0);
-    expect(indexedRows, "index occupancy must equal the number of live rows").toHaveLength(store.size);
-    expect(new Set(indexedRows).size, "a row id must occupy at most one bucket").toBe(indexedRows.length);
-}
-function dirtyLogForTest(store) {
-    return store.dirtyLog;
-}
-function retainsMaterializedRow(store) {
-    const seen = new Set();
-    const pending = [store];
-    while (pending.length > 0) {
-        const value = pending.pop();
-        if (value === null || typeof value !== "object" || seen.has(value))
-            continue;
-        seen.add(value);
-        const candidate = value;
-        if (Object.isFrozen(candidate) &&
-            "hash" in candidate &&
-            "size" in candidate &&
-            "syncedAt" in candidate &&
-            "direction" in candidate)
-            return true;
-        if (ArrayBuffer.isView(candidate) || candidate instanceof ArrayBuffer)
-            continue;
-        if (candidate instanceof Map || candidate instanceof Set) {
-            for (const nested of candidate.values())
-                pending.push(nested);
-            continue;
-        }
-        for (const key of Reflect.ownKeys(candidate)) {
-            const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
-            if (descriptor && "value" in descriptor)
-                pending.push(descriptor.value);
-        }
-    }
-    return false;
-}
-function churnStore(store, rowCount) {
-    const paths = Array.from({ length: rowCount }, (_value, index) => `churn/row-${index}.md`);
-    for (const [index, path] of paths.entries())
-        store.set(path, generatedEntry(index));
-    for (let round = 0; round < 4; round += 1) {
-        for (const [index, path] of paths.entries())
-            store.set(path, generatedEntry((round + 1) * rowCount + index));
-    }
-    for (const [index, path] of paths.entries()) {
-        expect(store.delete(path)).toBe(true);
-        store.set(path, generatedEntry(5 * rowCount + index));
-    }
-    return paths;
-}
-const fuzzAlphabet = ["a", "é", "漢", "🙂", "ß", "z", "\ud800", "�"];
-const LARGE_STRING_TABLE_ROWS = 400_000;
-const LARGE_ENTRY_VARIANTS = 257;
-function largeTableEntryVariant(variant) {
-    const entry = {
-        hash: variant % 3 === 0 ? variant.toString(16).padStart(64, "0") : `fallback-hash-${variant}`,
-        size: variant * 17.25,
-        syncedAt: variant % 2 === 0
-            ? new Date(1_700_000_000_000 + variant).toISOString()
-            : `fallback-synced-at-${variant}`,
-        direction: variant % 2 === 0 ? "up" : "down",
-    };
-    if (variant % 3 !== 0)
-        entry.kind = variant % 2 === 0 ? "file" : "symlink";
-    if (variant % 3 === 1)
-        entry.remoteEtag = variant.toString(16).padStart(32, "f");
-    if (variant % 3 === 2)
-        entry.remoteEtag = `fallback-etag-${variant}`;
-    if (variant % 4 !== 0)
-        entry.mtimeMs = 1_700_000_000_000 + variant * 3;
-    if (variant % 5 !== 0)
-        entry.ctimeMs = 1_700_000_000_000 + variant * 7;
-    if (variant % 5 === 0) {
-        entry.removedAt = new Date(1_700_100_000_000 + variant).toISOString();
-        entry.removedReason = ["scope_shrink", "narrow_apply", "manual", "local-delete"][variant % 4];
-    }
-    if (variant % 8 === 0) {
-        entry.localDeleteIntent = {
-            version: 1,
-            remoteEtag: `intent-etag-${variant}`,
-            localHash: (variant + 7).toString(16).padStart(64, "0"),
-            localKind: variant % 16 === 0 ? "symlink" : "file",
-        };
-    }
-    const outOfScopeProtected = optionalBoolean(variant, 0);
-    const skillMetadataPending = optionalBoolean(variant, 1);
-    const localDiverges = optionalBoolean(variant, 2);
-    if (outOfScopeProtected !== undefined)
-        entry.outOfScopeProtected = outOfScopeProtected;
-    if (skillMetadataPending !== undefined)
-        entry.skillMetadataPending = skillMetadataPending;
-    if (localDiverges !== undefined)
-        entry.localDiverges = localDiverges;
-    return entry;
-}
-const largeTableEntryVariants = Array.from({ length: LARGE_ENTRY_VARIANTS }, (_value, index) => largeTableEntryVariant(index));
-function largeTableEntry(index, author) {
-    const entry = { ...largeTableEntryVariants[index % LARGE_ENTRY_VARIANTS] };
-    if (index % 5 === 0)
-        delete entry.createdBySub;
-    else
-        entry.createdBySub = author;
-    return entry;
-}
-function storeWithLargeStringTable(table) {
-    const store = new JournalRowStore(LARGE_STRING_TABLE_ROWS);
-    let lastPath = "";
-    for (let index = 0; index < LARGE_STRING_TABLE_ROWS; index += 1) {
-        const directory = table === "directory" ? `directory-${index}` : "directory";
-        const author = table === "author" ? `author-${index}` : "author";
-        const entry = largeTableEntry(index, author);
-        lastPath = `${directory}/entry-${index}.md`;
-        store.set(lastPath, entry);
-    }
-    // Leave a row hole so toSnapshot takes the HQSNAP4 compaction path.
-    expect(store.delete(lastPath)).toBe(true);
-    return store;
-}
-function expectLargeTableEntryValueEqual(actual, expected, index, field) {
-    if (typeof actual === "object" && actual !== null && typeof expected === "object" && expected !== null) {
-        const actualRecord = actual;
-        const expectedRecord = expected;
-        const actualKeys = Object.keys(actualRecord);
-        const expectedKeys = Object.keys(expectedRecord);
-        if (actualKeys.length !== expectedKeys.length) {
-            throw new Error(`HQSNAP4 entry ${field} own-key count differs at index ${index}`);
-        }
-        for (const key of expectedKeys) {
-            if (!Object.hasOwn(actualRecord, key)) {
-                throw new Error(`HQSNAP4 entry ${field} is missing own key ${key} at index ${index}`);
-            }
-            if (actualRecord[key] !== expectedRecord[key]) {
-                throw new Error(`HQSNAP4 entry ${field}.${key} differs at index ${index}`);
-            }
-        }
-        return;
-    }
-    if (actual !== expected) {
-        throw new Error(`HQSNAP4 entry ${field} differs at index ${index}: ${String(actual)} !== ${String(expected)}`);
-    }
-}
-function expectLargeTableEntriesEqual(actual, expected) {
-    let index = 0;
-    while (true) {
-        const actualNext = actual.next();
-        const expectedNext = expected.next();
-        if (actualNext.done || expectedNext.done) {
-            if (actualNext.done !== expectedNext.done) {
-                throw new Error(`HQSNAP4 entry count differs at index ${index}`);
-            }
-            return;
-        }
-        const [actualPath, actualEntry] = actualNext.value;
-        const [expectedPath, expectedEntry] = expectedNext.value;
-        if (actualPath !== expectedPath) {
-            throw new Error(`HQSNAP4 entry path differs at index ${index}: ${actualPath} !== ${expectedPath}`);
-        }
-        const actualKeys = Object.keys(actualEntry);
-        const expectedKeys = Object.keys(expectedEntry);
-        if (actualKeys.length !== expectedKeys.length) {
-            const missingKey = expectedKeys.find((key) => !Object.hasOwn(actualEntry, key));
-            const unexpectedKey = actualKeys.find((key) => !Object.hasOwn(expectedEntry, key));
-            throw new Error(`HQSNAP4 entry own keys differ at index ${index}: missing ${missingKey ?? "none"}, unexpected ${unexpectedKey ?? "none"}`);
-        }
-        const actualRecord = actualEntry;
-        const expectedRecord = expectedEntry;
-        for (const key of expectedKeys) {
-            if (!Object.hasOwn(actualEntry, key)) {
-                throw new Error(`HQSNAP4 entry is missing own key ${key} at index ${index}`);
-            }
-            expectLargeTableEntryValueEqual(actualRecord[key], expectedRecord[key], index, key);
-        }
-        index += 1;
-    }
-}
-function expectLargeTableEqual(name, actual, expected) {
-    if (actual.length !== expected.length) {
-        throw new Error(`HQSNAP4 ${name} length differs: ${actual.length} !== ${expected.length}`);
-    }
-    for (let index = 0; index < actual.length; index += 1) {
-        if (actual[index] !== expected[index]) {
-            throw new Error(`HQSNAP4 ${name} differs at index ${index}: ${actual[index]} !== ${expected[index]}`);
-        }
-    }
-}
-function fuzzPath(random) {
-    const depth = Math.floor(random() * 4);
-    const segment = () => {
-        const length = 1 + Math.floor(random() * 4);
-        return Array.from({ length }, () => fuzzAlphabet[Math.floor(random() * fuzzAlphabet.length)]).join("");
-    };
-    const parts = Array.from({ length: depth + 1 }, segment);
-    return parts.join("/");
-}
-describe("packed journal row store", () => {
-    it("round-trips every JournalEntry field across canonical and side-table values", () => {
-        const store = new JournalRowStore();
-        const expected = new Map();
-        for (let index = 0; index < 420; index++) {
-            const key = "notes/世界/entry-" + index + ".md";
-            const row = generatedEntry(index);
-            store.set(key, row);
-            expected.set(key, row);
-        }
-        for (const [key, row] of expected)
-            expect(store.get(key)).toEqual(row);
-        expect(store.toRecord()).toEqual(Object.fromEntries(expected));
-    });
-    it("declares storage for every JournalEntry key", () => {
-        const schema = JOURNAL_ENTRY_STORAGE;
-        expect(Object.keys(schema)).toHaveLength(16);
-        expect(Object.values(schema).every((storage) => storage === "column" || storage === "side-table")).toBe(true);
-    });
-    it("deliberately drops unknown row keys at the packed schema boundary", () => {
-        const store = new JournalRowStore();
-        const known = generatedEntry(31);
-        const written = { ...known, futureField: "x" };
-        store.set("future.md", written);
-        // A client that writes a field a reader does not know about loses it on
-        // the next checkpoint. The schema-completeness test above guards only
-        // declared JournalEntry fields; an extras table must consciously change this test.
-        expect(store.get("future.md")).toEqual(known);
-        expect(store.get("future.md")).not.toHaveProperty("futureField");
-    });
-    it("exposes the packed store through a lazy JournalRows view", () => {
-        const store = new JournalRowStore();
-        const rows = store.rows;
-        const iterator = rows.keys();
-        rows.set("view/one.md", generatedEntry(1));
-        rows.set("view/two.md", generatedEntry(2));
-        expect(iterator.next().value).toBe("view/one.md");
-        expect([...rows.entries()].map(([key]) => key)).toEqual(["view/one.md", "view/two.md"]);
-        expect([...rows.values()]).toEqual([generatedEntry(1), generatedEntry(2)]);
-        expect(rows.has("view/two.md")).toBe(true);
-        expect(rows.delete("view/two.md")).toBe(true);
-        expect(rows.size).toBe(1);
-    });
-    it("defers recovered prefix candidates until a caller actually scans a prefix", () => {
-        const source = new JournalRowStore();
-        source.set("alpha/one.md", generatedEntry(1));
-        source.set("alpha/nested/two.md", generatedEntry(2));
-        source.set("beta/three.md", generatedEntry(3));
-        const restored = JournalRowStore.fromSnapshot(source.toSnapshot());
-        const inspected = restored;
-        // Whole-journal writers recover this packed object too. They must not pay
-        // to build targeted-pull candidates unless they perform a prefix scan.
-        expect(inspected.prefixRows).toBeUndefined();
-        expect([...restored.entriesForPrefix("alpha")].map(([path]) => path))
-            .toEqual(["alpha/one.md", "alpha/nested/two.md"]);
-        expect(inspected.prefixRows?.prefixIds.has("alpha")).toBe(true);
-        expect(inspected.prefixRows?.rowIds).toBeInstanceOf(Uint32Array);
-    });
-    it("keeps compact prefix candidates current across deletes, reused rows, and new directories", () => {
-        const rows = new JournalRowStore();
-        rows.set("alpha/nested/one.md", generatedEntry(1));
-        rows.set("alpha/root.md", generatedEntry(2));
-        rows.preparePrefixIndex();
-        rows.set("alpha/nested/two.md", generatedEntry(3));
-        expect(rows.delete("alpha/nested/one.md")).toBe(true);
-        rows.set("alpha/nested/one.md", generatedEntry(4));
-        rows.set("alpha/leaf", generatedEntry(5));
-        rows.set("alpha/leaf/child.md", generatedEntry(6));
-        expect([...rows.entriesForPrefix("alpha/nested")].map(([path]) => path))
-            .toEqual(["alpha/nested/two.md", "alpha/nested/one.md"]);
-        expect([...rows.entriesForPrefix("alpha/leaf")].map(([path]) => path))
-            .toEqual(["alpha/leaf", "alpha/leaf/child.md"]);
-        expect([...rows.entriesForPrefix("alpha")].map(([path]) => path))
-            .toEqual([
-            "alpha/root.md",
-            "alpha/nested/two.md",
-            "alpha/nested/one.md",
-            "alpha/leaf",
-            "alpha/leaf/child.md",
-        ]);
-    });
-    it("does not reuse released dynamic prefix ids while sibling directories remain live", () => {
-        const rows = new JournalRowStore();
-        rows.set("alpha/seed.md", generatedEntry(1));
-        rows.preparePrefixIndex();
-        rows.set("alpha/first/one.md", generatedEntry(2));
-        rows.set("alpha/second/two.md", generatedEntry(3));
-        expect(rows.delete("alpha/first/one.md")).toBe(true);
-        rows.set("alpha/third/three.md", generatedEntry(4));
-        expect([...rows.entriesForPrefix("alpha/second")].map(([path]) => path))
-            .toEqual(["alpha/second/two.md"]);
-        expect([...rows.entriesForPrefix("alpha/third")].map(([path]) => path))
-            .toEqual(["alpha/third/three.md"]);
-        const inspected = rows;
-        expect(inspected.prefixRows.prefixIds.get("alpha/second"))
-            .not.toBe(inspected.prefixRows.prefixIds.get("alpha/third"));
-    });
-    it("keeps absent optionals distinct from present false values", () => {
-        const store = new JournalRowStore();
-        const base = generatedEntry(6);
-        delete base.localDiverges;
-        delete base.outOfScopeProtected;
-        delete base.skillMetadataPending;
-        delete base.remoteEtag;
-        delete base.mtimeMs;
-        delete base.ctimeMs;
-        store.set("absent.md", base);
-        store.set("false.md", {
-            ...base,
-            localDiverges: false,
-            outOfScopeProtected: false,
-            skillMetadataPending: false,
-            remoteEtag: "e".repeat(32),
-            mtimeMs: 0,
-            ctimeMs: 0,
-        });
-        const absent = store.get("absent.md");
-        const presentFalse = store.get("false.md");
-        for (const key of ["localDiverges", "outOfScopeProtected", "skillMetadataPending", "remoteEtag", "mtimeMs", "ctimeMs"]) {
-            expect(Object.hasOwn(absent, key)).toBe(false);
-            expect(Object.hasOwn(presentFalse, key)).toBe(true);
-        }
-        expect(presentFalse.localDiverges).toBe(false);
-        expect(presentFalse.outOfScopeProtected).toBe(false);
-        expect(presentFalse.skillMetadataPending).toBe(false);
-    });
-    it("emits the same net delta as a plain-object reference and can drain twice", () => {
-        const store = new JournalRowStore();
-        const initial = {};
-        for (let index = 0; index < 120; index++) {
-            const key = "seed/" + index + ".md";
-            const row = generatedEntry(index);
-            initial[key] = row;
-            store.set(key, row);
-        }
-        expect(store.drainDirtyLog()).toHaveLength(120);
-        for (let seed = 1; seed <= 300; seed++) {
-            const random = rng(seed);
-            const before = structuredClone(store.toRecord());
-            const current = structuredClone(before);
-            for (let step = 0; step < 1 + Math.floor(random() * 12); step++) {
-                const keys = Object.keys(current);
-                const key = keys[Math.floor(random() * keys.length)];
-                if (random() < 0.34) {
-                    delete current[key];
-                    store.delete(key);
-                }
-                else {
-                    const next = generatedEntry(Math.floor(random() * 10_000));
-                    current[key] = next;
-                    store.set(key, next);
-                }
-            }
-            const changes = store.drainDirtyLog();
-            expect(deltaFromDirtyLog(store, changes)).toEqual(referenceDelta(before, current));
-            expect(store.drainDirtyLog()).toEqual([]);
-            const extraKey = "extra/" + seed + ".md";
-            const extra = generatedEntry(20_000 + seed);
-            current[extraKey] = extra;
-            store.set(extraKey, extra);
-            expect(deltaFromDirtyLog(store, store.drainDirtyLog())).toEqual({ upserts: { [extraKey]: extra }, deletes: [] });
-        }
-    });
-    it("does not retain dirty changes or materialized previous rows when change tracking is disabled", () => {
-        const rowCount = 72;
-        const nonTracking = new JournalRowStore(64, { trackChanges: false });
-        churnStore(nonTracking, rowCount);
-        expect(nonTracking.size).toBe(rowCount);
-        expect(dirtyLogForTest(nonTracking)).toEqual([]);
-        expect(retainsMaterializedRow(nonTracking)).toBe(false);
-        expect(() => nonTracking.drainDirtyLog()).toThrow("Change tracking is disabled");
-        expect(() => nonTracking.drainChanges()).toThrow("Change tracking is disabled");
-        const tracking = new JournalRowStore();
-        churnStore(tracking, rowCount);
-        expect(tracking.size).toBe(rowCount);
-        expect(dirtyLogForTest(tracking)).toHaveLength(rowCount);
-        expect(retainsMaterializedRow(tracking)).toBe(false);
-    });
-    it("does not materialize existing rows while updating with change tracking disabled", () => {
-        const store = new JournalRowStore(64, { trackChanges: false });
-        const paths = Array.from({ length: 36 }, (_value, index) => `updates/row-${index}.md`);
-        for (const [index, path] of paths.entries())
-            store.set(path, generatedEntry(index));
-        const materialize = vi.spyOn(store, "materialize");
-        for (let round = 0; round < 5; round += 1) {
-            for (const [index, path] of paths.entries())
-                store.set(path, generatedEntry((round + 1) * paths.length + index));
-        }
-        expect(materialize).not.toHaveBeenCalled();
-        materialize.mockRestore();
-    });
-    it("iterates keys without materializing rows", () => {
-        const store = new JournalRowStore(64, { trackChanges: false });
-        const paths = ["docs/guide.md", "docs/nested/plan.md", "docsx/guide.md", "root.md"];
-        for (const [index, path] of paths.entries())
-            store.set(path, generatedEntry(index));
-        const materialize = vi.spyOn(store, "materialize");
-        expect([...store.keys()]).toEqual(paths);
-        expect(materialize).not.toHaveBeenCalled();
-        materialize.mockRestore();
-    });
-    it("compacts a non-tracking store after heavy churn without losing live rows", () => {
-        const store = new JournalRowStore(64, { trackChanges: false });
-        const paths = churnStore(store, 96);
-        const before = store.toRecord();
-        const sizeBeforeCompaction = store.size;
-        store.compact();
-        expect(store.size).toBe(sizeBeforeCompaction);
-        for (const path of paths)
-            expect(store.get(path)).toEqual(before[path]);
-    });
-    it("returns frozen rows", () => {
-        const store = new JournalRowStore();
-        store.set("frozen.md", generatedEntry(10));
-        const row = store.get("frozen.md");
-        expect(Object.isFrozen(row)).toBe(true);
-        expect(() => { row.size = 9; }).toThrow(TypeError);
-    });
-    it("clears columns, index state, free rows, and pending dirty changes", () => {
-        const store = new JournalRowStore();
-        const paths = ["clear/one.md", "clear/two.md", "clear/three.md"];
-        for (const [index, rowPath] of paths.entries())
-            store.set(rowPath, generatedEntry(index));
-        store.clear();
-        expect(store.size).toBe(0);
-        for (const rowPath of paths)
-            expect(store.get(rowPath)).toBeUndefined();
-        expect(store.drainDirtyLog()).toEqual([]);
-        const replacement = generatedEntry(99);
-        store.set("clear/reused.md", replacement);
-        expect(store.get("clear/reused.md")).toEqual(replacement);
-    });
-    it("keeps UTF-8 leaves and same-named paths in their correct directories", () => {
-        const store = new JournalRowStore();
-        store.set("same/世界.md", generatedEntry(1));
-        store.set("same/é.md", generatedEntry(2));
-        store.set("other/世界.md", generatedEntry(3));
-        expect(store.directoryCount).toBe(3);
-        store.delete("same/世界.md");
-        expect(store.get("other/世界.md")).toEqual(generatedEntry(3));
-        expect(store.get("same/é.md")).toEqual(generatedEntry(2));
-    });
-    it("reuses a deleted row id without resurrecting its side tables", () => {
-        const store = new JournalRowStore();
-        const withIntent = generatedEntry(4);
-        expect(withIntent.localDeleteIntent).toBeDefined();
-        store.set("intent.md", withIntent);
-        const firstId = store.drainDirtyLog()[0].rowId;
-        store.delete("intent.md");
-        store.drainDirtyLog();
-        const plain = generatedEntry(5);
-        delete plain.localDeleteIntent;
-        store.set("plain.md", plain);
-        const replacementId = store.drainDirtyLog()[0].rowId;
-        expect(replacementId).toBe(firstId);
-        expect(store.get("plain.md")).toEqual(plain);
-        expect(Object.hasOwn(store.get("plain.md"), "localDeleteIntent")).toBe(false);
-    });
-    it("keeps Map iteration order when a deleted row id is reused", () => {
-        const store = new JournalRowStore();
-        store.set("first.md", generatedEntry(1));
-        store.set("middle.md", generatedEntry(2));
-        store.set("last.md", generatedEntry(3));
-        store.delete("middle.md");
-        store.set("reinserted.md", generatedEntry(4));
-        expect([...store.keys()]).toEqual(["first.md", "last.md", "reinserted.md"]);
-    });
-    it("compacts active rows after their checkpoint", () => {
-        const store = new JournalRowStore();
-        store.set("compact/one.md", generatedEntry(1));
-        store.set("compact/two.md", generatedEntry(2));
-        store.set("compact/three.md", generatedEntry(3));
-        store.drainDirtyLog();
-        store.delete("compact/two.md");
-        store.drainDirtyLog();
-        store.compact();
-        expect(store.toRecord()).toEqual({
-            "compact/one.md": generatedEntry(1),
-            "compact/three.md": generatedEntry(3),
-        });
-        store.set("compact/four.md", generatedEntry(4));
-        expect(store.drainDirtyLog()[0].rowId).toBe(2);
-    });
-    it("keeps one index bucket per row through growth, deletion, and row-id reuse", () => {
-        const store = new JournalRowStore();
-        const activePaths = [];
-        for (let cycle = 0; cycle < 7; cycle++) {
-            for (let index = 0; index < 90; index++) {
-                const path = cycle % 2 === 0
-                    ? `entry-${cycle}-${index}.md`
-                    : `nested/${cycle % 3}/entry-${cycle}-${index}.md`;
-                store.set(path, generatedEntry(cycle * 100 + index));
-                activePaths.push(path);
-                expectIndexInvariant(store);
-            }
-            for (let index = activePaths.length - 1; index >= 0; index -= 2) {
-                const [path] = activePaths.splice(index, 1);
-                expect(store.delete(path)).toBe(true);
-                expectIndexInvariant(store);
-            }
-        }
-    });
-    it("matches Map across deterministic UTF-8 path churn", () => {
-        for (let seed = 1; seed <= 300; seed++) {
-            const random = rng(seed);
-            const store = new JournalRowStore();
-            const expected = new Map();
-            const paths = new Set();
-            while (paths.size < 96)
-                paths.add(fuzzPath(random));
-            const candidates = [...paths];
-            for (let step = 0; step < 240; step++) {
-                const path = candidates[Math.floor(random() * candidates.length)];
-                const action = random();
-                if (action < 0.56) {
-                    const entry = generatedEntry(seed * 1_000 + step);
-                    store.set(path, entry);
-                    expected.set(path, entry);
-                }
-                else if (action < 0.78) {
-                    expect(store.delete(path), `seed ${seed}, delete ${JSON.stringify(path)}`).toBe(expected.delete(path));
-                }
-                else {
-                    expect(store.has(path), `seed ${seed}, has ${JSON.stringify(path)}`).toBe(expected.has(path));
-                }
-            }
-            expect(store.size, `seed ${seed}, size`).toBe(expected.size);
-            expect([...store.keys()].sort(), `seed ${seed}, iterated keys`).toEqual([...expected.keys()].sort());
-            for (const [path, entry] of expected) {
-                expect(store.get(path), `seed ${seed}, get ${JSON.stringify(path)}`).toEqual(entry);
-            }
-        }
-    });
-    it("round-trips leaves with unpaired and paired surrogates exactly", () => {
-        const paths = ["notes/a\ud800", "notes/a\udc00b", "notes/a😀"];
-        const store = new JournalRowStore();
-        for (const [index, path] of paths.entries())
-            store.set(path, generatedEntry(index));
-        const keys = [...store.keys()];
-        for (const [index, path] of paths.entries()) {
-            expect(store.has(path)).toBe(true);
-            expect(keys[index]).toBe(path);
-        }
-    });
-    it("keeps byte-equal surrogate and replacement-character paths distinct", () => {
-        const surrogatePath = "notes/x\ud800";
-        const replacementPath = "notes/x�";
-        const surrogateEntry = generatedEntry(1);
-        const replacementEntry = generatedEntry(2);
-        const store = new JournalRowStore();
-        store.set(surrogatePath, surrogateEntry);
-        store.set(replacementPath, replacementEntry);
-        const keys = [...store.keys()];
-        expect(store.size).toBe(2);
-        expect(keys.some((path) => path === surrogatePath)).toBe(true);
-        expect(keys.some((path) => path === replacementPath)).toBe(true);
-        expect(store.get(surrogatePath)).toEqual(surrogateEntry);
-        expect(store.get(replacementPath)).toEqual(replacementEntry);
-    });
-    it("deletes only the intended byte-equal surrogate path", () => {
-        const surrogatePath = "notes/x\ud800";
-        const replacementPath = "notes/x�";
-        const surrogateEntry = generatedEntry(1);
-        const replacementEntry = generatedEntry(2);
-        const store = new JournalRowStore();
-        store.set(surrogatePath, surrogateEntry);
-        store.set(replacementPath, replacementEntry);
-        expect(store.delete(surrogatePath)).toBe(true);
-        expect(store.size).toBe(1);
-        expect(store.get(surrogatePath)).toBeUndefined();
-        expect(store.get(replacementPath)).toEqual(replacementEntry);
-        expect([...store.keys()]).toEqual([replacementPath]);
-    });
-    it("reports resident growth for 100,000 packed rows without making hardware a gate", () => {
-        const collector = globalThis.gc;
-        collector?.();
-        const before = process.memoryUsage().rss;
-        const store = new JournalRowStore(100_000);
-        for (let index = 0; index < 100_000; index++) {
-            store.set("sample/" + (index % 250) + "/file-" + index + ".md", {
-                hash: index.toString(16).padStart(64, "0"),
-                size: index * 12,
-                syncedAt: new Date(1_700_000_000_000 + index).toISOString(),
-                direction: index % 2 === 0 ? "up" : "down",
-                remoteEtag: index.toString(16).padStart(32, "0"),
-                mtimeMs: 1_700_000_000_000 + index,
-                ctimeMs: 1_700_000_100_000 + index,
-            });
-        }
-        store.drainDirtyLog();
-        globalThis.__packedJournalRowStoreBench = store;
-        collector?.();
-        const bytesPerRow = (process.memoryUsage().rss - before) / store.size;
-        process.stdout.write("packed journal resident bytes/row (" + (collector ? "gc" : "no gc") + "): " + bytesPerRow.toFixed(2) + "\\n");
-        expect(store.size).toBe(100_000);
-    });
-    it.each(["directory", "author"])("compacts and reloads a large %s table for HQSNAP4", (table) => {
-        const store = storeWithLargeStringTable(table);
-        const snapshot = store.toSnapshot();
-        const expectedDirIds = snapshot.dirIds.slice();
-        const expectedCreatedBySubs = snapshot.createdBySubs.slice();
-        const reloaded = JournalRowStore.fromSnapshot(snapshot);
-        const reloadedSnapshot = reloaded.toSnapshot();
-        expectLargeTableEntriesEqual(reloaded.entries(), store.entries());
-        expectLargeTableEqual("directories", reloadedSnapshot.directories, snapshot.directories);
-        expectLargeTableEqual("authors", reloadedSnapshot.authors, snapshot.authors);
-        expectLargeTableEqual("dirIds", reloadedSnapshot.dirIds, expectedDirIds);
-        expectLargeTableEqual("createdBySubs", reloadedSnapshot.createdBySubs, expectedCreatedBySubs);
-    });
-});
-//# sourceMappingURL=journal-row-store.test.js.map