@indigoai-us/hq-cloud 6.15.0 → 6.15.2

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

@@ -3979,6 +3979,115 @@ describe("runRunnerWithLoop — event-push wiring", () => {
         await loop;
     });
 });
+describe("runRunnerWithLoop — U58 realtime scheduler guard", () => {
+    it("feeds a watcher-originated V2 drain through the same single-flight guard as the poll", async () => {
+        const watcher = makeWatcherStub();
+        let triggerShutdown = () => { };
+        let releasePoll = () => { };
+        const pollGate = new Promise((resolve) => { releasePoll = resolve; });
+        let active = 0;
+        let maximumActive = 0;
+        let passes = 0;
+        const runPass = vi.fn().mockImplementation(async () => {
+            active += 1;
+            maximumActive = Math.max(maximumActive, active);
+            passes += 1;
+            if (passes === 1)
+                await pollGate;
+            active -= 1;
+            return 0;
+        });
+        let signal = null;
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--hq-root", "/tmp/hq"], {
+            runPass,
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            sleep: () => new Promise(() => { }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+            startRealtimeScheduler: async (opts) => ({
+                signal: (source) => {
+                    if (source !== "watcher")
+                        return;
+                    signal = () => undefined;
+                    void opts.runGuarded(async () => {
+                        active += 1;
+                        maximumActive = Math.max(maximumActive, active);
+                        active -= 1;
+                    });
+                },
+                checkHighWater: async () => undefined,
+                dispose: async () => undefined,
+            }),
+        });
+        for (let i = 0; i < 6; i++)
+            await Promise.resolve();
+        expect(active).toBe(1);
+        watcher.emit("companies/indigo/v2.md");
+        for (let i = 0; i < 4; i++)
+            await Promise.resolve();
+        expect(signal).not.toBeNull();
+        expect(maximumActive).toBe(1);
+        releasePoll();
+        for (let i = 0; i < 8; i++)
+            await Promise.resolve();
+        expect(maximumActive).toBe(1);
+        triggerShutdown();
+        await loop;
+    });
+    it("checks high-water at five minutes even when the normal poll cadence is ten", async () => {
+        const watcher = makeWatcherStub();
+        const clockState = { now: 0 };
+        const sleepState = {
+            delays: [],
+            resolve: null,
+        };
+        let triggerShutdown = () => { };
+        let releaseInitial = () => { };
+        const initial = new Promise((resolve) => { releaseInitial = resolve; });
+        let passes = 0;
+        const checkHighWater = vi.fn().mockResolvedValue(undefined);
+        const loop = runRunnerWithLoop(["--companies", "--watch", "--event-push", "--poll-remote-ms", "600000", "--hq-root", "/tmp/hq"], {
+            runPass: async () => {
+                passes += 1;
+                if (passes === 1)
+                    await initial;
+                return 0;
+            },
+            clock: new FakeClock(),
+            createWatcher: () => watcher,
+            monotonicNow: () => clockState.now,
+            sleep: (delay) => new Promise((resolve) => {
+                sleepState.delays.push(delay);
+                sleepState.resolve = resolve;
+            }),
+            onShutdownSignal: (handler) => {
+                triggerShutdown = handler;
+                return () => { };
+            },
+            startRealtimeScheduler: async () => ({
+                signal: () => undefined,
+                checkHighWater,
+                dispose: async () => undefined,
+            }),
+        });
+        for (let i = 0; i < 6; i++)
+            await Promise.resolve();
+        releaseInitial();
+        for (let i = 0; i < 6; i++)
+            await Promise.resolve();
+        expect(sleepState.delays[0]).toBe(300_000);
+        clockState.now = 300_000;
+        sleepState.resolve?.();
+        for (let i = 0; i < 8; i++)
+            await Promise.resolve();
+        expect(checkHighWater).toHaveBeenCalledOnce();
+        triggerShutdown();
+        await loop;
+    });
+});
 describe("runRunnerWithLoop — accumulate-and-drain scoped push", () => {
     const watchArgv = [
         "--companies",