@indigoai-us/hq-cloud 6.15.65 → 6.15.66

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

@@ -14,7 +14,7 @@ import { runRunner, runRunnerWithLoop, resolveDeletePolicy, resolveSkipPersonal,
 import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
 import { setBandwidthGovernorForTesting } from "../bandwidth.js";
 import { FakeClock, TreeWatcher, } from "../watcher.js";
-import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, shouldQuarantineWatcherDeleteIntents, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, } from "./sync-runner-watch-loop.js";
+import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILE_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, shouldQuarantineWatcherDeleteIntents, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, } from "./sync-runner-watch-loop.js";
 import { PERSONAL_VAULT_JOURNAL_SLUG, readJournal, writeJournal, } from "../journal.js";
 import { HQ_CLOUD_VERSION } from "../version.js";
 import { lockPathFor, OPERATION_LOCKED_EXIT } from "../operation-lock.js";
@@ -4697,6 +4697,62 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         await loop;
         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";
+        const tiny = path.join(hqRoot, tinyRel);
+        const bulk = [0, 1, 2].map((index) => path.join(hqRoot, `companies/indigo/session-${index}.log`));
+        fs.mkdirSync(path.dirname(tiny), { recursive: true });
+        fs.writeFileSync(tiny, "tiny realtime edit");
+        for (const file of bulk)
+            fs.writeFileSync(file, Buffer.alloc(8 * 1024 * 1024));
+        const watcher = makeBatchWatcherStub();
+        let triggerShutdown = () => { };
+        let releaseBulk = () => { };
+        const bulkGate = new Promise((resolve) => { releaseBulk = resolve; });
+        const calls = [];
+        let fullPasses = 0;
+        const runPass = vi.fn().mockImplementation(async (passArgv) => {
+            calls.push(passArgv);
+            if (!passArgv.includes("--scope-path")) {
+                fullPasses += 1;
+                if (fullPasses === 2)
+                    await bulkGate;
+            }
+            return completedPassOutcome();
+        });
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--direction", "push", "--hq-root", hqRoot], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+        });
+        await flushLoopMicrotasks();
+        watcher.emit();
+        await flushLoopMicrotasks();
+        watcher.emit(tinyRel, {
+            paths: new Map([
+                [tiny, tinyRel],
+                ...bulk.map((file, index) => [file, `companies/indigo/session-${index}.log`]),
+            ]),
+        });
+        await flushLoopMicrotasks(30);
+        // origin/main failure: expected a scoped tiny path while the bulk pass is
+        // held, but #408 kept all four paths in the slow lane.
+        expect(calls.filter((argv) => argv.includes("--scope-path"))).toHaveLength(1);
+        expect(calls.flat().join(" ")).toContain("realtime.md");
+        releaseBulk();
+        await flushLoopMicrotasks(30);
+        expect(calls.filter((argv) => argv.includes("--scope-path"))).toHaveLength(2);
+        expect(calls.flat().join(" ")).toContain("session-0.log");
+        triggerShutdown();
+        await loop;
+        fs.rmSync(hqRoot, { recursive: true, force: true });
+    });
     it("fast lane: a small receiver pull dispatches during a slow bulk pass", async () => {
         const watcher = makeWatcherStub();
         let triggerShutdown = () => { };
@@ -4705,6 +4761,14 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         const bulkGate = new Promise((resolve) => { releaseBulk = resolve; });
         const order = [];
         let fullPasses = 0;
+        const journal = readJournal("acme");
+        journal.files["realtime.md"] = {
+            hash: "sha256:x",
+            size: 16,
+            syncedAt: "2026-08-26T00:00:00.000Z",
+            direction: "down",
+        };
+        writeJournal("acme", journal);
         const runPass = vi.fn().mockImplementation(async (passArgv) => {
             if (passArgv.includes("--scope-path")) {
                 order.push("fast-pull");
@@ -4954,12 +5018,28 @@ describe("runRunnerWithLoop — event-push wiring", () => {
                 eventTimestamp: "2026-08-26T00:00:00.000Z",
             })),
         ];
+        for (const [slug, prefix, count] of [["acme", "a", 17], ["beta", "b", 16]]) {
+            const journal = readJournal(slug);
+            for (let index = 0; index < count; index++) {
+                journal.files[`${prefix}-${index}.md`] = {
+                    hash: "sha256:x",
+                    size: 16,
+                    syncedAt: "2026-08-26T00:00:00.000Z",
+                    direction: "down",
+                };
+            }
+            writeJournal(slug, journal);
+        }
         const receiverDrain = receiverSync({
             events,
             signal: new AbortController().signal,
         });
         await flushLoopMicrotasks(20);
-        expect(runPass).not.toHaveBeenCalled();
+        // The 33-event mixed delivery peels its first 32 bounded paths into the
+        // fast lane (17 acme + 15 beta); the final beta event remains slow.
+        expect(runPass).toHaveBeenCalledTimes(2);
+        expect(runPass.mock.calls.flat().join(" ")).toContain("a-16.md");
+        expect(runPass.mock.calls.flat().join(" ")).toContain("b-14.md");
         releaseBulk();
         await receiverDrain;
         triggerShutdown();
@@ -5171,6 +5251,30 @@ describe("runRunnerWithLoop — event-push wiring", () => {
             fs.rmSync(hqRoot, { recursive: true, force: true });
         }
     });
+    it("fast lane: keeps a latest large revision in the slow residue and caps 33 small paths", () => {
+        const hqRoot = fs.mkdtempSync(path.join(os.tmpdir(), "hq-fast-lane-partition-"));
+        const rel = "companies/indigo/revised.md";
+        const absolute = path.join(hqRoot, rel);
+        fs.mkdirSync(path.dirname(absolute), { recursive: true });
+        // The map is the coalescing/affinity boundary: its one value is the latest
+        // revision, so this path cannot appear in both sub-batches.
+        fs.writeFileSync(absolute, Buffer.alloc(DEFAULT_FAST_LANE_MAX_FILE_BYTES + 1));
+        const revised = partitionLocalBatch({ paths: new Map([[absolute, rel]]) });
+        expect(revised.fast).toBeNull();
+        expect(revised.slow?.paths.get(absolute)).toBe(rel);
+        const entries = [];
+        for (let index = 0; index < DEFAULT_FAST_LANE_MAX_FILES + 1; index++) {
+            const file = path.join(hqRoot, `companies/indigo/small-${index}.md`);
+            fs.writeFileSync(file, "x");
+            entries.push([file, `companies/indigo/small-${index}.md`]);
+        }
+        const capped = partitionLocalBatch({ paths: new Map(entries) });
+        expect(capped.fast?.paths.size).toBe(DEFAULT_FAST_LANE_MAX_FILES);
+        // The 33rd path deliberately remains in the slow residue, rather than
+        // creating a second concurrent realtime dispatch.
+        expect(capped.slow?.paths.size).toBe(1);
+        fs.rmSync(hqRoot, { recursive: true, force: true });
+    });
     it("U07: drains the first watcher event after activation without guarded overlap", async () => {
         const watcher = makeWatcherStub();
         let triggerShutdown = () => { };