@indigoai-us/hq-cloud 6.15.87 → 6.15.88

package/dist/bin/sync-runner.test.js

@@ -4859,6 +4859,10 @@ describe("runRunnerWithLoop — event-push wiring", () => {
                         "/tmp/hq/companies/indigo/warmup-superseded.md",
                         "companies/indigo/warmup-superseded.md",
                     ]]),
+                changes: new Map([[
+                        "/tmp/hq/companies/indigo/warmup-superseded.md",
+                        { kind: "unlinkDir" },
+                    ]]),
             },
             scannedPaths: 1,
         }));
@@ -5503,6 +5507,243 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             fs.rmSync(hqRoot, { recursive: true, force: true });
         }
     });
+    it("parallel coordinator partitions receiver events into fast and slow realtime lanes", async () => {
+        const previous = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-parallel-receiver-lanes-"));
+        const watcher = makeBatchWatcherStub();
+        let receiverSync;
+        let triggerShutdown = () => { };
+        let releaseSlow = () => { };
+        const slowGate = new Promise((resolve) => { releaseSlow = resolve; });
+        const order = [];
+        const journal = readJournal("indigo");
+        journal.files["small.md"] = {
+            hash: "sha256:small",
+            size: 16,
+            syncedAt: "2026-08-28T00:00:00.000Z",
+            direction: "down",
+        };
+        writeJournal("indigo", journal);
+        const runPass = vi.fn(async (argv) => {
+            if (argv.includes("held-unknown.md")) {
+                order.push("slow-held");
+                await slowGate;
+            }
+            else if (argv.includes("small.md")) {
+                order.push("fast-small");
+            }
+            else if (argv.includes("unknown.md")) {
+                order.push("slow-unknown");
+            }
+            return completedPassOutcome();
+        });
+        const event = (relativePath) => ({
+            kind: "upsert",
+            relativePath,
+            contentHash: "sha256:remote",
+            mtime: "2026-08-28T00:00:00.000Z",
+            originDeviceId: "peer-device",
+            originTenantId: "tenant-indigo",
+            sequenceNumber: 1,
+            eventTimestamp: "2026-08-28T00:00:00.000Z",
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--direction", "pull", "--hq-root", hqRoot], {
+            runPass,
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            runPass.mockClear();
+            const held = receiverSync({
+                events: [event("companies/indigo/held-unknown.md")],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks(20);
+            expect(order).toEqual(["slow-held"]);
+            const partitioned = receiverSync({
+                events: [
+                    event("companies/indigo/small.md"),
+                    event("companies/indigo/unknown.md"),
+                ],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks(20);
+            expect(order).toEqual(["slow-held", "fast-small"]);
+            releaseSlow();
+            await held;
+            await partitioned;
+            expect(order).toEqual(["slow-held", "fast-small", "slow-unknown"]);
+        }
+        finally {
+            releaseSlow();
+            triggerShutdown();
+            await loop;
+            if (previous === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previous;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
+        }
+    });
+    it("parallel coordinator submits a later route's fast receiver work before an earlier route's slow pull completes", async () => {
+        const previous = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-parallel-receiver-route-order-"));
+        const watcher = makeBatchWatcherStub();
+        let receiverSync;
+        let triggerShutdown = () => { };
+        let releaseSlow = () => { };
+        const slowGate = new Promise((resolve) => { releaseSlow = resolve; });
+        const order = [];
+        const journal = readJournal("indigo");
+        journal.files["fast.md"] = {
+            hash: "sha256:fast",
+            size: 16,
+            syncedAt: "2026-08-28T00:00:00.000Z",
+            direction: "down",
+        };
+        writeJournal("indigo", journal);
+        const runPass = vi.fn(async (argv) => {
+            if (argv.includes("slow.md")) {
+                order.push("slow-acme");
+                await slowGate;
+            }
+            else if (argv.includes("fast.md")) {
+                order.push("fast-indigo");
+            }
+            return completedPassOutcome();
+        });
+        const event = (relativePath) => ({
+            kind: "upsert",
+            relativePath,
+            contentHash: "sha256:remote",
+            mtime: "2026-08-28T00:00:00.000Z",
+            originDeviceId: "peer-device",
+            originTenantId: "tenant-indigo",
+            sequenceNumber: 1,
+            eventTimestamp: "2026-08-28T00:00:00.000Z",
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--direction", "pull", "--hq-root", hqRoot], {
+            runPass,
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            runPass.mockClear();
+            const delivery = receiverSync({
+                events: [
+                    event("companies/acme/slow.md"),
+                    event("companies/indigo/fast.md"),
+                ],
+                signal: new AbortController().signal,
+            });
+            await flushLoopMicrotasks(20);
+            // Regression: the old per-route loop started slow-acme and awaited it
+            // before it even submitted fast-indigo.
+            expect(order).toEqual(["fast-indigo", "slow-acme"]);
+            releaseSlow();
+            await delivery;
+        }
+        finally {
+            releaseSlow();
+            triggerShutdown();
+            await loop;
+            if (previous === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previous;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
+        }
+    });
+    it("parallel coordinator exposes delivery-wide fast and slow receiver batches", async () => {
+        const previousCoordinator = process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+        const previousFastFiles = process.env[FAST_LANE_MAX_FILES_ENV];
+        process.env.HQ_SYNC_PARALLEL_COORDINATOR = "1";
+        process.env[FAST_LANE_MAX_FILES_ENV] = "1";
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-parallel-receiver-delivery-cap-"));
+        const watcher = makeBatchWatcherStub();
+        let receiverSync;
+        let triggerShutdown = () => { };
+        const event = (relativePath) => ({
+            kind: "upsert",
+            relativePath,
+            contentHash: "sha256:remote",
+            mtime: "2026-08-28T00:00:00.000Z",
+            originDeviceId: "peer-device",
+            originTenantId: "tenant-indigo",
+            sequenceNumber: 1,
+            eventTimestamp: "2026-08-28T00:00:00.000Z",
+        });
+        for (const [slug, key] of [["acme", "small.md"], ["indigo", "small.md"]]) {
+            const journal = readJournal(slug);
+            journal.files[key] = {
+                hash: `sha256:${slug}`,
+                size: 16,
+                syncedAt: "2026-08-28T00:00:00.000Z",
+                direction: "down",
+            };
+            writeJournal(slug, journal);
+        }
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--direction", "pull", "--hq-root", hqRoot], {
+            runPass: vi.fn(async () => completedPassOutcome()),
+            createWatcher: () => watcher,
+            createReceiver: ({ syncBatchFn }) => {
+                receiverSync = syncBatchFn;
+                return { connected: true, start: async () => { }, dispose: async () => { } };
+            },
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        try {
+            await flushLoopMicrotasks(30);
+            const batches = receiverSync.partition([
+                event("companies/acme/small.md"),
+                event("companies/indigo/small.md"),
+            ]);
+            // The cap applies once to the whole delivery, not once per route. The
+            // returned batches are receiver-visible, so its existing per-batch
+            // acknowledgement contract retains only a failed slow receipt.
+            expect(batches.map((batch) => batch.map((event) => event.relativePath))).toEqual([
+                ["companies/acme/small.md"],
+                ["companies/indigo/small.md"],
+            ]);
+        }
+        finally {
+            triggerShutdown();
+            await loop;
+            if (previousCoordinator === undefined)
+                delete process.env.HQ_SYNC_PARALLEL_COORDINATOR;
+            else
+                process.env.HQ_SYNC_PARALLEL_COORDINATOR = previousCoordinator;
+            if (previousFastFiles === undefined)
+                delete process.env[FAST_LANE_MAX_FILES_ENV];
+            else
+                process.env[FAST_LANE_MAX_FILES_ENV] = previousFastFiles;
+            fs.rmSync(hqRoot, { recursive: true, force: true });
+        }
+    });
     it("fast lane: peels a tiny watcher path from mixed multi-megabyte residue", async () => {
         const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fast-lane-mixed-watch-"));
         const tinyRel = "companies/indigo/realtime.md";