@indigoai-us/hq-cloud 6.18.44-alpha.2 → 6.18.44-alpha.21

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

@@ -10396,6 +10396,92 @@ describe("runRunnerWithLoop — U58 realtime scheduler guard", () => {
     });
 });
 describe("CooperativePassScheduler", () => {
+    function heldCapYield() {
+        let releaseSleep = () => { };
+        const sleep = new Promise((resolve) => { releaseSleep = resolve; });
+        let markSleepEntered = () => { };
+        const sleepEntered = new Promise((resolve) => { markSleepEntered = resolve; });
+        const caps = {
+            beginChore: () => { },
+            endChore: () => { },
+            suspendForHandoff: () => { },
+            resumeAfterHandoff: () => { },
+            applyAtCheckpoint: async (handoff) => {
+                markSleepEntered();
+                await sleep;
+                await handoff();
+            },
+        };
+        return { caps, sleepEntered, releaseSleep: () => releaseSleep() };
+    }
+    it("reports a hand-off when realtime work starts during a cap throttle sleep", async () => {
+        const yieldState = heldCapYield();
+        const scheduler = new CooperativePassScheduler(() => 0, CHORE_STARVATION_CAP_MS, {
+            caps: yieldState.caps,
+        });
+        let handedOff;
+        const chore = scheduler.submit(async ({ checkpoint }) => {
+            handedOff = await checkpoint();
+            return 0;
+        }, "chore");
+        await yieldState.sleepEntered;
+        let realtimeRan = false;
+        await scheduler.submit(async () => {
+            realtimeRan = true;
+            return 0;
+        }, "realtime", "slow", false, undefined, false, true);
+        expect(realtimeRan).toBe(true);
+        yieldState.releaseSleep();
+        await chore;
+        // The pull continuation overlays journal deltas only when checkpoint()
+        // reports a hand-off, so work admitted during the sleep must count.
+        expect(handedOff).toBe(true);
+    });
+    it("keeps one un-fenced backlog pass at a time across cap sleep slices", async () => {
+        const yieldState = heldCapYield();
+        const scheduler = new CooperativePassScheduler(() => 0, CHORE_STARVATION_CAP_MS, {
+            caps: yieldState.caps,
+        });
+        const chore = scheduler.submit(async ({ checkpoint }) => {
+            await checkpoint();
+            return 0;
+        }, "chore");
+        await yieldState.sleepEntered;
+        let releaseFirst = () => { };
+        const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+        let markFirstStarted = () => { };
+        const firstStarted = new Promise((resolve) => { markFirstStarted = resolve; });
+        let running = 0;
+        let maxRunning = 0;
+        let secondStarted = false;
+        const first = scheduler.submit(async () => {
+            running += 1;
+            maxRunning = Math.max(maxRunning, running);
+            markFirstStarted();
+            await firstGate;
+            running -= 1;
+            return 0;
+        }, "realtime");
+        await firstStarted;
+        const second = scheduler.submit(async () => {
+            running += 1;
+            maxRunning = Math.max(maxRunning, running);
+            secondStarted = true;
+            running -= 1;
+            return 0;
+        }, "realtime");
+        // The next sleep slice re-enters the hand-off while the first un-fenced
+        // pass still runs; it must not free that pass's reservation.
+        yieldState.releaseSleep();
+        for (let i = 0; i < 20; i++)
+            await Promise.resolve();
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        expect(secondStarted).toBe(false);
+        releaseFirst();
+        await Promise.all([first, second, chore]);
+        expect(secondStarted).toBe(true);
+        expect(maxRunning).toBe(1);
+    });
     it("admits a second realtime watcher op during a full-pass transfer only when the HQ flag is on", async () => {
         let releaseTransfer = () => { };
         const transferGate = new Promise((resolve) => { releaseTransfer = resolve; });