@supalive/core 0.1.4 → 0.1.5

package/dist/src/server/subscription-manager.test.js

@@ -1,610 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { Buffer } from "buffer";
-import { mapWriteSetToRaw } from "./overlap-checker";
-import { fnv1a32 } from "./hash";
-import { SubscriptionWorker } from "./subscription-manager";
-import { supaliveStringify } from "../helper";
-import { sleep } from "../client";
-// ─── Test doubles ──────────────────────────────────────────────────────────
-class StubCache {
-    meta = new Map();
-    data = new Map();
-    // Backs persistRegistrationRecord / deleteRegistrationRecord so tests can
-    // observe registration persistence via redis.store.
-    redis;
-    constructor(redis) {
-        this.redis = redis;
-    }
-    async getQueryCacheMetaData(key) {
-        return this.meta.get(key) ?? null;
-    }
-    async setQueryCacheMetadata(key, value) {
-        this.meta.set(key, value);
-    }
-    async getQueryCacheFor(key) {
-        const v = this.data.get(key);
-        return v == null ? null : { data: v };
-    }
-    async setQueryCacheFor(key, value) {
-        this.data.set(key, value);
-    }
-    async persistRegistrationRecord(subId, record) {
-        await this.redis.set(`sl:reg:${subId}`, supaliveStringify(record));
-    }
-    async deleteRegistrationRecord(subId) {
-        await this.redis.del(`sl:reg:${subId}`);
-    }
-    async deleteRegistrationsRecord(subIds) {
-        for (const subId of subIds)
-            await this.redis.del(`sl:reg:${subId}`);
-    }
-}
-class StubDb {
-    dbType = "postgres";
-    commitLogs = [];
-    async getCommitLogsBetweenTs(_beginTs, _endTs, _tableIds) {
-        return this.commitLogs;
-    }
-    // The rest of Database is unused by SubscriptionWorker:
-    get sqlBuilder() { throw new Error("not implemented"); }
-    get migrationSql() { throw new Error("not implemented"); }
-    async query() { throw new Error("not implemented"); }
-    async getClient() { throw new Error("not implemented"); }
-    async getTransactionClient() { throw new Error("not implemented"); }
-    async getLatestSnapshotTimestamp() { return 0; }
-    async updateLatestSnapshotTimestamp() { }
-    async getNextTimestamp() { return 0; }
-    async commitWrites() { return { success: true }; }
-    async close() { }
-    async insertCommitLogs() { }
-    async pruneCommitLogsBefore() { return 0; }
-    async attachPrevDataToWriteSet() { }
-}
-/**
- * Minimal stub of the Upstash Redis client. Only `get`, `set`, `del` are
- * touched by SubscriptionWorker; the rest stay undefined and would throw
- * if accidentally used.
- */
-class StubRedis {
-    store = new Map();
-    setCalls = [];
-    delCalls = [];
-    async get(key) {
-        return this.store.get(key) ?? null;
-    }
-    async set(key, value) {
-        this.store.set(key, value);
-        this.setCalls.push([key, value]);
-        return "OK";
-    }
-    async del(key) {
-        const had = this.store.delete(key);
-        this.delCalls.push(key);
-        return had ? 1 : 0;
-    }
-    async mget(...keys) {
-        return keys.map((k) => this.store.get(k) ?? null);
-    }
-}
-const cacheOf = (s) => s;
-const dbOf = (s) => s;
-const redisOf = (s) => s;
-// ─── Fixtures ──────────────────────────────────────────────────────────────
-const ITEMS_TABLE_ID = Buffer.from("items-tableid");
-const USERS_TABLE_ID = Buffer.from("users-tableid");
-function pointRead(table, tableId, id) {
-    return { kind: "point", table, tableId, id };
-}
-function rangeRead(table, tableId, predicateValue) {
-    return {
-        kind: "range",
-        table,
-        tableId,
-        predicate: { kind: "leaf", column: "status", operator: "=", value: predicateValue },
-        columns: ["id", "status"],
-        orderBy: null,
-        limit: null,
-        offset: null,
-    };
-}
-function writeEntry(table, tableId, id, op = "update", data, prevData) {
-    return { table, tableId, id, op, data, prevData };
-}
-function makeRegisterParams(opts = {}) {
-    return {
-        subId: opts.subId ?? "sub_a",
-        cacheKey: opts.cacheKey ?? "ck_a",
-        queryName: opts.queryName ?? "getItems",
-        args: opts.args ?? {},
-        queryIdentity: "anonymous",
-        instanceName: opts.instanceName ?? "app-1",
-        lastSnapshotTs: opts.lastSnapshotTs ?? 0n,
-    };
-}
-function makeUpdateParams(subId, cacheKey, readSet, opts = {}) {
-    return {
-        cacheKey,
-        subId,
-        instanceName: opts.instanceName ?? "app-1",
-        lastSnapshotTs: opts.lastSnapshotTs ?? 1n,
-        readSet,
-    };
-}
-function makeUnregisterParams(subId, opts = {}) {
-    return {
-        subId,
-        instanceName: opts.instanceName ?? "app-1",
-    };
-}
-function makeWorker() {
-    const redis = new StubRedis();
-    const cache = new StubCache(redis);
-    const db = new StubDb();
-    const worker = new SubscriptionWorker(0, cacheOf(cache), dbOf(db));
-    return { worker, cache, db, redis };
-}
-// ─── Worker tests ──────────────────────────────────────────────────────────
-describe("SubscriptionWorker", () => {
-    let cache;
-    let db;
-    let redis;
-    let worker;
-    beforeEach(() => {
-        ({ worker, cache, db, redis } = makeWorker());
-    });
-    it("registers a brand-new subscription with empty readSet and recompute=true", async () => {
-        const res = await worker.register(makeRegisterParams());
-        expect(res.recompute).toBe(true);
-        expect(res.readSet).toEqual([]);
-        expect(res.cacheKey).toBe("ck_a");
-        expect(worker.size()).toBe(1);
-        expect(worker.has("sub_a")).toBe(true);
-    });
-    it("persists a registration record to sl:reg:<subId> on first creation", async () => {
-        await worker.register(makeRegisterParams({ queryName: "getItems", args: { limit: 10 } }));
-        expect(redis.store.has("sl:reg:sub_a")).toBe(true);
-        const parsed = JSON.parse(redis.store.get("sl:reg:sub_a"));
-        expect(parsed.queryName).toBe("getItems");
-        expect(parsed.args).toEqual({ limit: 10 });
-        expect(parsed.queryIdentity).toBe("anonymous");
-        expect(parsed.cacheKey).toBe("ck_a");
-    });
-    it("does not double-write the registration record when a second instance joins", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        expect(redis.setCalls.length).toBe(1);
-        await worker.register(makeRegisterParams({ instanceName: "app-2" }));
-        expect(redis.setCalls.length).toBe(1);
-    });
-    it("returns existing readSet and recompute=false when another instance joins", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        const res = await worker.register(makeRegisterParams({ instanceName: "app-2" }));
-        expect(res.recompute).toBe(false);
-        expect(res.readSet.length).toBe(1);
-    });
-    it("reuses cached metadata when commit log shows no overlap → recompute=false", async () => {
-        const readSet = [rangeRead("items", ITEMS_TABLE_ID, "active")];
-        cache.meta.set("ck_a", { lastSnapshotTs: 5n, readSet });
-        db.commitLogs = [];
-        const res = await worker.register(makeRegisterParams({ lastSnapshotTs: 10n }));
-        expect(res.recompute).toBe(false);
-        expect(res.readSet).toEqual(readSet);
-    });
-    it("forces recompute when commit log between metadata.ts and now affects readSet", async () => {
-        const readSet = [pointRead("items", ITEMS_TABLE_ID, "1")];
-        cache.meta.set("ck_a", { lastSnapshotTs: 5n, readSet });
-        db.commitLogs = [{
-                id: Buffer.from("1"),
-                ts: 7n,
-                tableId: ITEMS_TABLE_ID,
-                // Commit logs serialize the full WriteEntry envelope, not raw row data.
-                data: Buffer.from(supaliveStringify({
-                    table: "items", tableId: ITEMS_TABLE_ID, id: "1", op: "update",
-                    data: { id: "1", name: "X" },
-                })),
-            }];
-        const res = await worker.register(makeRegisterParams({ lastSnapshotTs: 10n }));
-        expect(res.recompute).toBe(true);
-    });
-    // ─── OCC range-read precision (checkRangeReadOverlap via checkLogsAffectReadSet) ──
-    //
-    // Before the fix, checkRangeReadOverlap evaluated the predicate against
-    // the full WriteEntry envelope (which has fields `table`, `op`, `data`,
-    // etc. — none of which match a row's predicate column), so it always
-    // returned "unknown" → every concurrent write was treated as a conflict.
-    // After the fix, it pulls out the row's prev/post state and uses the
-    // same prev-OR-post logic the in-memory invalidator uses.
-    it("recovery: range-read sub recomputes when a gap log moves a row OUT of the set", async () => {
-        const readSet = [rangeRead("items", ITEMS_TABLE_ID, "todo")];
-        cache.meta.set("ck_a", { lastSnapshotTs: 5n, readSet });
-        db.commitLogs = [{
-                id: Buffer.from("1"),
-                ts: 7n,
-                tableId: ITEMS_TABLE_ID,
-                data: Buffer.from(supaliveStringify({
-                    table: "items", tableId: ITEMS_TABLE_ID, id: "1", op: "update",
-                    data: { status: "done" },
-                    prevData: { id: "1", status: "todo" },
-                })),
-            }];
-        const res = await worker.register(makeRegisterParams({ lastSnapshotTs: 10n }));
-        expect(res.recompute).toBe(true);
-    });
-    it("recovery: range-read sub does NOT recompute when gap log is irrelevant (precision)", async () => {
-        const readSet = [rangeRead("items", ITEMS_TABLE_ID, "todo")];
-        cache.meta.set("ck_a", { lastSnapshotTs: 5n, readSet });
-        db.commitLogs = [{
-                id: Buffer.from("1"),
-                ts: 7n,
-                tableId: ITEMS_TABLE_ID,
-                // Row was "done" before and is still "done" — never in the "todo" set.
-                data: Buffer.from(supaliveStringify({
-                    table: "items", tableId: ITEMS_TABLE_ID, id: "1", op: "update",
-                    data: { status: "done" },
-                    prevData: { id: "1", status: "done" },
-                })),
-            }];
-        const res = await worker.register(makeRegisterParams({ lastSnapshotTs: 10n }));
-        expect(res.recompute).toBe(false);
-    });
-    it("recovery: range-read sub recomputes when a gap log inserts a matching row", async () => {
-        const readSet = [rangeRead("items", ITEMS_TABLE_ID, "todo")];
-        cache.meta.set("ck_a", { lastSnapshotTs: 5n, readSet });
-        db.commitLogs = [{
-                id: Buffer.from("2"),
-                ts: 7n,
-                tableId: ITEMS_TABLE_ID,
-                data: Buffer.from(supaliveStringify({
-                    table: "items", tableId: ITEMS_TABLE_ID, id: "2", op: "insert",
-                    data: { id: "2", status: "todo" },
-                })),
-            }];
-        const res = await worker.register(makeRegisterParams({ lastSnapshotTs: 10n }));
-        expect(res.recompute).toBe(true);
-    });
-    it("updateReadSet accepts any instance — exactly one recomputes per mutation in the dispatch model", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.register(makeRegisterParams({ instanceName: "app-2" }));
-        const res = await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "2"),
-        ], { instanceName: "app-2", lastSnapshotTs: 5n }));
-        expect(res.tracked).toBe(true);
-        // Non-primary's readSet is applied now that primary-only filtering is gone.
-        const affected = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "2"),
-        ]));
-        expect(affected.length).toBe(1);
-    });
-    it("single-instance sub: notifyInstances is just that instance", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        const affected = worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "1")]));
-        expect(affected.length).toBe(1);
-        expect(affected[0].subId).toBe("sub_a");
-        expect(affected[0].notifyInstances).toEqual(["app-1"]);
-    });
-    it("multi-instance sub: notifyInstances includes every live holder", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.register(makeRegisterParams({ instanceName: "app-2" }));
-        await worker.register(makeRegisterParams({ instanceName: "app-3" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        const affected = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1"),
-        ]));
-        // Under the race-lock dispatch model every holder must appear in
-        // notifyInstances — the writer broadcasts a race to all of them and
-        // the lock arbitrates which one actually recomputes.
-        expect(affected[0].notifyInstances.slice().sort())
-            .toEqual(["app-1", "app-2", "app-3"]);
-    });
-    // Regression for the original bug: a writer on instance B (not holding
-    // the sub locally) used to forward a single targeted recompute to the
-    // "primary" instance. If that primary was unreachable (e.g. just died,
-    // or the targeted-channel publish silently failed), the update was
-    // lost. Under the race model the writer broadcasts to *every* holder,
-    // so any survivor can pick up the lock and recompute.
-    it("notifyInstances includes every holder so a non-holder writer can broadcast", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-A" }));
-        await worker.register(makeRegisterParams({ instanceName: "app-B" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-A", lastSnapshotTs: 5n }));
-        const affected = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1"),
-        ]));
-        expect(affected.length).toBe(1);
-        expect(affected[0].notifyInstances).toContain("app-A");
-        expect(affected[0].notifyInstances).toContain("app-B");
-    });
-    it("invalidate produces no false positives for unrelated writes", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        // Different table
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("users", USERS_TABLE_ID, "1")])).length).toBe(0);
-        // Same table, different row id (point read)
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "999")])).length).toBe(0);
-    });
-    it("range read with matching predicate is invalidated; non-matching is not", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            rangeRead("items", ITEMS_TABLE_ID, "active"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        // Row entering the result set (prev="inactive", new="active")
-        const matching = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1", "update", { status: "active" }, { id: "1", status: "inactive" }),
-        ]));
-        expect(matching.length).toBe(1);
-        // Row that was inactive and stays inactive (predicate column changed
-        // to another non-matching value) — neither prev nor new matches.
-        const nonMatching = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "2", "update", { status: "archived" }, { id: "2", status: "inactive" }),
-        ]));
-        expect(nonMatching.length).toBe(0);
-    });
-    it("invalidates when an update moves a row OUT of the predicate set (regression: row-leaves-set)", async () => {
-        // The bug: sub on status="todo" missed updates that flipped a row's
-        // status from "todo" to "done" because only the new (non-matching)
-        // data was visible to the invalidator.
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            rangeRead("items", ITEMS_TABLE_ID, "todo"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        const affected = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1", "update", { status: "done" }, { id: "1", status: "todo" }),
-        ]));
-        expect(affected.length).toBe(1);
-    });
-    it("does NOT invalidate when both prev and new states miss the predicate", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            rangeRead("items", ITEMS_TABLE_ID, "todo"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        // done → in_progress, sub is on todo — neither matches.
-        const affected = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1", "update", { status: "in_progress" }, { id: "1", status: "done" }),
-        ]));
-        expect(affected.length).toBe(0);
-    });
-    it("invalidates partial updates (untouched predicate column) using prevData", async () => {
-        // Updating only a non-predicate column on a row that's currently in
-        // the set must still invalidate (the row's visible fields changed).
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            rangeRead("items", ITEMS_TABLE_ID, "todo"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        // status stays "todo", only title changes — predicate column carried
-        // forward from prevData.
-        const inSet = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1", "update", { title: "new" }, { id: "1", status: "todo", title: "old" }),
-        ]));
-        expect(inSet.length).toBe(1);
-        // Same kind of partial update on a row NOT in the set — must NOT invalidate.
-        const outOfSet = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "2", "update", { title: "new" }, { id: "2", status: "done", title: "old" }),
-        ]));
-        expect(outOfSet.length).toBe(0);
-    });
-    it("delete invalidation is precise — only invalidates subs whose predicate matched the deleted row", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            rangeRead("items", ITEMS_TABLE_ID, "todo"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        // Deleting a row that was in the result set → invalidate.
-        const matchedDelete = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1", "delete", undefined, { id: "1", status: "todo" }),
-        ]));
-        expect(matchedDelete.length).toBe(1);
-        // Deleting a row that was NOT in the result set → no invalidation.
-        const unmatchedDelete = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "2", "delete", undefined, { id: "2", status: "done" }),
-        ]));
-        expect(unmatchedDelete.length).toBe(0);
-    });
-    it("insert into the result set invalidates; insert outside does not", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            rangeRead("items", ITEMS_TABLE_ID, "todo"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        const inserted = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1", "insert", { id: "1", status: "todo" }),
-        ]));
-        expect(inserted.length).toBe(1);
-        const outsideInsert = worker.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "2", "insert", { id: "2", status: "done" }),
-        ]));
-        expect(outsideInsert.length).toBe(0);
-    });
-    it("unregister removes only the specified instance; sub stays until last leaves", { timeout: 30_000 }, async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.register(makeRegisterParams({ instanceName: "app-2" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        await worker.unregister(makeUnregisterParams("sub_a", { instanceName: "app-1" }));
-        expect(worker.has("sub_a")).toBe(true);
-        // sl:reg should NOT be deleted yet — another instance still holds the sub
-        expect(redis.store.has("sl:reg:sub_a")).toBe(true);
-        expect(redis.delCalls.length).toBe(0);
-        const affected = worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "1")]));
-        expect(affected.length).toBe(1);
-        expect(affected[0].notifyInstances).toEqual(["app-2"]);
-        await worker.unregister(makeUnregisterParams("sub_a", { instanceName: "app-2" }));
-        await sleep(1000 * 18); // sub not closed immeditly, so wait 15+jitter
-        expect(worker.has("sub_a")).toBe(false);
-        // Now sl:reg is gone because instances.size === 0
-        expect(redis.store.has("sl:reg:sub_a")).toBe(false);
-        expect(redis.delCalls).toContain("sl:reg:sub_a");
-    });
-    it("unregister on absent sub is idempotent", async () => {
-        const res = await worker.unregister(makeUnregisterParams("sub_missing"));
-        expect(res.ok).toBe(true);
-        expect(redis.delCalls.length).toBe(0);
-    });
-    it("updateReadSet on absent sub returns tracked:false (no throw)", async () => {
-        const res = await worker.updateReadSet(makeUpdateParams("sub_ghost", "ck_ghost", [], {
-            instanceName: "app-1",
-            lastSnapshotTs: 1n,
-        }));
-        expect(res.tracked).toBe(false);
-    });
-    it("lastSnapshotTs ordering: older update is noop", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 10n }));
-        // A later, slower call with an older snapshot must NOT clobber the newer state.
-        const older = await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "999"), // different read
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        expect(older.tracked).toBe(true);
-        // Original read for id="1" should still be active; id="999" should NOT
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "1")])).length).toBe(1);
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "999")])).length).toBe(0);
-    });
-    it("lastSnapshotTs ordering: equal ts is treated as noop", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 10n }));
-        // Same ts must not apply (idempotent)
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "2"), // a different read
-        ], { instanceName: "app-1", lastSnapshotTs: 10n }));
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "1")])).length).toBe(0);
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "2")])).length).toBe(1);
-    });
-    it("lastSnapshotTs ordering: newer ts applies", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 10n }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "2"),
-        ], { instanceName: "app-1", lastSnapshotTs: 20n }));
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "1")])).length).toBe(0);
-        expect(worker.invalidate(mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "2")])).length).toBe(1);
-    });
-    it("cache metadata is updated with the new lastSnapshotTs on apply", async () => {
-        await worker.register(makeRegisterParams({ instanceName: "app-1" }));
-        await worker.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 42n }));
-        expect(cache.meta.get("ck_a")?.lastSnapshotTs).toBe(42n);
-    });
-});
-// ─── Routing tests ─────────────────────────────────────────────────────────
-describe("Worker routing by FNV-1a(subId)", () => {
-    it("same subId always lands on same worker (multiple workers)", () => {
-        const ids = ["sub_aa", "sub_bb", "sub_cc", "sub_a_very_long_one_just_to_be_safe"];
-        for (const N of [1, 2, 4, 8, 16]) {
-            for (const id of ids) {
-                const a = fnv1a32(id) % N;
-                const b = fnv1a32(id) % N;
-                expect(a).toBe(b);
-            }
-        }
-    });
-    it("distinct subIds typically land on distinct workers across N>=2", () => {
-        const N = 4;
-        const buckets = new Set();
-        for (let i = 0; i < 32; i++) {
-            buckets.add(fnv1a32(`sub_${i}`) % N);
-        }
-        expect(buckets.size).toBeGreaterThanOrEqual(2);
-    });
-});
-// ─── Worker isolation ──────────────────────────────────────────────────────
-describe("Worker isolation", () => {
-    it("invalidate on worker A scans only worker A's subs; worker B sees nothing", async () => {
-        const redis = new StubRedis();
-        const cache = new StubCache(redis);
-        const db = new StubDb();
-        const workerA = new SubscriptionWorker(0, cacheOf(cache), dbOf(db));
-        const workerB = new SubscriptionWorker(1, cacheOf(cache), dbOf(db));
-        await workerA.register(makeRegisterParams({ instanceName: "app-1" }));
-        await workerA.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 5n }));
-        const ws = mapWriteSetToRaw([writeEntry("items", ITEMS_TABLE_ID, "1")]);
-        expect(workerA.invalidate(ws).length).toBe(1);
-        expect(workerB.invalidate(ws).length).toBe(0);
-    });
-});
-// ─── Recovery simulation ───────────────────────────────────────────────────
-//
-// Simulate the post-restart flow:
-//   1. Worker A holds sub_a with a readSet.
-//   2. A "restart" creates Worker B with empty state but the SAME cache &
-//      redis (since those are external services).
-//   3. App server reads sl:reg:sub_a from Redis and calls register on B.
-//   4. B's register() walks the commit log (if any) to decide if recompute
-//      is needed, then sets up state.
-//   5. After register, an invalidate on B correctly finds the sub.
-describe("Recovery flow simulation", () => {
-    it("a fresh worker with shared Redis can be re-registered from sl:reg + cache", async () => {
-        const redis = new StubRedis();
-        const cache = new StubCache(redis);
-        const db = new StubDb();
-        // Lifetime 1: worker A registers and uploads readSet
-        const workerA = new SubscriptionWorker(0, cacheOf(cache), dbOf(db));
-        await workerA.register(makeRegisterParams({ instanceName: "app-1" }));
-        await workerA.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 10n }));
-        // Lifetime 2: worker B is the "post-restart" worker. Cache + redis survive.
-        const workerB = new SubscriptionWorker(0, cacheOf(cache), dbOf(db));
-        // App server reads sl:reg from Redis to learn how to re-register.
-        const raw = redis.store.get("sl:reg:sub_a");
-        expect(raw).toBeTruthy();
-        const record = JSON.parse(raw);
-        // Re-register on worker B
-        const res = await workerB.register({
-            subId: "sub_a",
-            cacheKey: "ck_a",
-            queryName: record.queryName,
-            args: record.args,
-            queryIdentity: record.queryIdentity,
-            instanceName: "app-1",
-            lastSnapshotTs: 15n,
-        });
-        // Cache metadata gave us the existing readSet; no DB writes happened
-        // between ts 10 and 15 (db.commitLogs is empty) → no recompute needed.
-        expect(res.recompute).toBe(false);
-        expect(res.readSet.length).toBe(1);
-        // Invalidate against B finds the sub
-        expect(workerB.invalidate(mapWriteSetToRaw([
-            writeEntry("items", ITEMS_TABLE_ID, "1"),
-        ])).length).toBe(1);
-    });
-    it("recovery with gap-writes triggers recompute=true via commit-log replay", async () => {
-        const redis = new StubRedis();
-        const cache = new StubCache(redis);
-        const db = new StubDb();
-        // Lifetime 1
-        const workerA = new SubscriptionWorker(0, cacheOf(cache), dbOf(db));
-        await workerA.register(makeRegisterParams({ instanceName: "app-1" }));
-        await workerA.updateReadSet(makeUpdateParams("sub_a", "ck_a", [
-            pointRead("items", ITEMS_TABLE_ID, "1"),
-        ], { instanceName: "app-1", lastSnapshotTs: 10n }));
-        // Simulate a write to row 1 that happened during the disconnect
-        db.commitLogs = [{
-                id: Buffer.from("1"),
-                ts: 12n,
-                tableId: ITEMS_TABLE_ID,
-                data: Buffer.from(supaliveStringify({ id: "1", name: "modified" })),
-            }];
-        // Lifetime 2: fresh worker re-registers
-        const workerB = new SubscriptionWorker(0, cacheOf(cache), dbOf(db));
-        const res = await workerB.register(makeRegisterParams({ instanceName: "app-1", lastSnapshotTs: 15n }));
-        expect(res.recompute).toBe(true);
-    });
-});
-//# sourceMappingURL=subscription-manager.test.js.map