@indigoai-us/hq-cloud 6.18.44-alpha.48 → 6.18.44-alpha.49

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

@@ -0,0 +1,729 @@
+/**
+ * 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