@namzu/sdk 7.0.0 → 8.0.0

package/dist/runtime/query/guard.d.ts

@@ -34,6 +34,34 @@ export declare class GuardCoordinator {
      * one field, let the resume branch hand it over.
      */
     restoreElapsed(elapsedMs: number): void;
+    /**
+     * Wall-clock left before this run is asked to start finishing.
+     *
+     * NOT the time left before the deadline, and the difference is the whole
+     * point. The checks above run BETWEEN iterations, so anything that waits
+     * inside one cannot be stopped by them, and a caller sizing such a wait
+     * needs a number the run actually owns: a fixed two-minute hold measured
+     * against a run configured for twenty seconds kept it open for 120,267 ms.
+     *
+     * Measuring to the DEADLINE was the first attempt and it was wrong. The
+     * binding constraint is `budgetWarningThreshold`, the point at which this
+     * guard stops asking for more work and asks for a closing summary — that
+     * last slice exists so the run can produce an answer, and a wait sized
+     * against the deadline eats into it. Half of the time-to-deadline, started
+     * just under the threshold, ends at 95% of the budget: half the closing
+     * reserve spent waiting for a result the closing answer was supposed to
+     * use.
+     *
+     * Zero once the threshold has passed, which is also how a caller gets the
+     * re-evaluation it needs: `forceFinalize` is sampled at the top of an
+     * iteration and this is read when the wait is about to start, so a long
+     * iteration that crossed the line in between is told to wait for nothing.
+     *
+     * Reads through the same `startTime` the limit checks use, so a run
+     * resumed from a checkpoint (see `restoreElapsed`) reports the time left
+     * on the RUN rather than on the process now hosting it.
+     */
+    remainingBeforeFinalizeMs(): number;
     beforeIteration(runMgr: RunPersistence, abortSignal: AbortSignal): GuardCheckResult;
 }
 //# sourceMappingURL=guard.d.ts.map

package/dist/runtime/query/guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../../src/runtime/query/guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,WAAW,WAAW;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,gBAAgB;IAChC,UAAU,EAAE,OAAO,CAAA;IACnB,aAAa,EAAE,OAAO,CAAA;IACtB,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,WAAW,EAAE,OAAO,CAAA;CACpB;AAED,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,SAAS,CAAQ;gBAEb,MAAM,EAAE,WAAW;IAc/B;;;;;;;OAOG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIvC,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,GAAG,gBAAgB;CAmCnF"}
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../../src/runtime/query/guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,WAAW,WAAW;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,gBAAgB;IAChC,UAAU,EAAE,OAAO,CAAA;IACnB,aAAa,EAAE,OAAO,CAAA;IACtB,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,WAAW,EAAE,OAAO,CAAA;CACpB;AAED,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,SAAS,CAAQ;gBAEb,MAAM,EAAE,WAAW;IAc/B;;;;;;;OAOG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIvC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,yBAAyB,IAAI,MAAM;IAKnC,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,GAAG,gBAAgB;CAmCnF"}

package/dist/runtime/query/guard.js

@@ -21,6 +21,37 @@ export class GuardCoordinator {
     restoreElapsed(elapsedMs) {
         this.startTime = Date.now() - Math.max(0, elapsedMs);
     }
+    /**
+     * Wall-clock left before this run is asked to start finishing.
+     *
+     * NOT the time left before the deadline, and the difference is the whole
+     * point. The checks above run BETWEEN iterations, so anything that waits
+     * inside one cannot be stopped by them, and a caller sizing such a wait
+     * needs a number the run actually owns: a fixed two-minute hold measured
+     * against a run configured for twenty seconds kept it open for 120,267 ms.
+     *
+     * Measuring to the DEADLINE was the first attempt and it was wrong. The
+     * binding constraint is `budgetWarningThreshold`, the point at which this
+     * guard stops asking for more work and asks for a closing summary — that
+     * last slice exists so the run can produce an answer, and a wait sized
+     * against the deadline eats into it. Half of the time-to-deadline, started
+     * just under the threshold, ends at 95% of the budget: half the closing
+     * reserve spent waiting for a result the closing answer was supposed to
+     * use.
+     *
+     * Zero once the threshold has passed, which is also how a caller gets the
+     * re-evaluation it needs: `forceFinalize` is sampled at the top of an
+     * iteration and this is read when the wait is about to start, so a long
+     * iteration that crossed the line in between is told to wait for nothing.
+     *
+     * Reads through the same `startTime` the limit checks use, so a run
+     * resumed from a checkpoint (see `restoreElapsed`) reports the time left
+     * on the RUN rather than on the process now hosting it.
+     */
+    remainingBeforeFinalizeMs() {
+        const finalizeAt = this.limitConfig.timeoutMs * this.limitConfig.budgetWarningThreshold;
+        return Math.max(0, finalizeAt - (Date.now() - this.startTime));
+    }
     beforeIteration(runMgr, abortSignal) {
         const limitState = {
             aborted: abortSignal.aborted,

package/dist/runtime/query/guard.js.map

@@ -1 +1 @@
-{"version":3,"file":"guard.js","sourceRoot":"","sources":["../../../src/runtime/query/guard.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AA0BjF,MAAM,OAAO,gBAAgB;IACpB,WAAW,CAAoB;IAC/B,SAAS,CAAQ;IAEzB,YAAY,MAAmB;QAC9B,IAAI,CAAC,WAAW,GAAG,gBAAgB,CAClC,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,YAAY,EACnB,MAAM,CAAC,aAAa,CACpB,CAAA;QACD,oEAAoE;QACpE,gEAAgE;QAChE,kEAAkE;QAClE,SAAS;QACT,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,eAAe,IAAI,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,SAAiB;QAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;IACrD,CAAC;IAED,eAAe,CAAC,MAAsB,EAAE,WAAwB;QAC/D,MAAM,UAAU,GAAG;YAClB,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC,WAAW;YAC1C,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS;YACpC,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;YACzC,SAAS,EAAE,IAAI,CAAC,SAAS;SACzB,CAAA;QAED,MAAM,WAAW,GAAG,mBAAmB,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;QAErE,IAAI,WAAW,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACtC,OAAO;gBACN,UAAU,EAAE,IAAI;gBAChB,aAAa,EAAE,KAAK;gBACpB,UAAU,EAAE,WAAW,CAAC,MAAM;gBAC9B,WAAW,EAAE,WAAW,CAAC,MAAM,KAAK,WAAW;aAC/C,CAAA;QACF,CAAC;QAED,IAAI,WAAW,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO;gBACN,UAAU,EAAE,KAAK;gBACjB,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE,WAAW,CAAC,MAAM;gBAC9B,WAAW,EAAE,KAAK;aAClB,CAAA;QACF,CAAC;QAED,OAAO;YACN,UAAU,EAAE,KAAK;YACjB,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,KAAK;SAClB,CAAA;IACF,CAAC;CACD"}
+{"version":3,"file":"guard.js","sourceRoot":"","sources":["../../../src/runtime/query/guard.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AA0BjF,MAAM,OAAO,gBAAgB;IACpB,WAAW,CAAoB;IAC/B,SAAS,CAAQ;IAEzB,YAAY,MAAmB;QAC9B,IAAI,CAAC,WAAW,GAAG,gBAAgB,CAClC,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,YAAY,EACnB,MAAM,CAAC,aAAa,CACpB,CAAA;QACD,oEAAoE;QACpE,gEAAgE;QAChE,kEAAkE;QAClE,SAAS;QACT,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,eAAe,IAAI,CAAC,CAAC,CAAA;IACvE,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,SAAiB;QAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;IACrD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,yBAAyB;QACxB,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAAA;QACvF,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAA;IAC/D,CAAC;IAED,eAAe,CAAC,MAAsB,EAAE,WAAwB;QAC/D,MAAM,UAAU,GAAG;YAClB,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC,WAAW;YAC1C,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS;YACpC,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;YACzC,SAAS,EAAE,IAAI,CAAC,SAAS;SACzB,CAAA;QAED,MAAM,WAAW,GAAG,mBAAmB,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;QAErE,IAAI,WAAW,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACtC,OAAO;gBACN,UAAU,EAAE,IAAI;gBAChB,aAAa,EAAE,KAAK;gBACpB,UAAU,EAAE,WAAW,CAAC,MAAM;gBAC9B,WAAW,EAAE,WAAW,CAAC,MAAM,KAAK,WAAW;aAC/C,CAAA;QACF,CAAC;QAED,IAAI,WAAW,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO;gBACN,UAAU,EAAE,KAAK;gBACjB,aAAa,EAAE,IAAI;gBACnB,UAAU,EAAE,WAAW,CAAC,MAAM;gBAC9B,WAAW,EAAE,KAAK;aAClB,CAAA;QACF,CAAC;QAED,OAAO;YACN,UAAU,EAAE,KAAK;YACjB,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,KAAK;SAClB,CAAA;IACF,CAAC;CACD"}

package/dist/runtime/query/iteration/__tests__/settle-grace.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=settle-grace.test.d.ts.map

package/dist/runtime/query/iteration/__tests__/settle-grace.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle-grace.test.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/query/iteration/__tests__/settle-grace.test.ts"],"names":[],"mappings":""}

package/dist/runtime/query/iteration/__tests__/settle-grace.test.js

@@ -0,0 +1,226 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { CompletionInbox } from '../../../../gateway/completion-inbox.js';
+import { ToolRegistry } from '../../../../registry/tool/execute.js';
+import { DELEGATION_TIMEOUT_MS } from '../../../../tools/coordinator/index.js';
+import { createUserMessage } from '../../../../types/message/index.js';
+import { GuardCoordinator } from '../../guard.js';
+import { drainQuery } from '../../index.js';
+import { settleGraceMs } from '../index.js';
+/**
+ * How long a finishing run waits for a worker it launched.
+ *
+ * This used to be a constant — 120 seconds, unrelated to the run holding it.
+ * Measured before the change: a run configured `timeoutMs: 20_000` was held
+ * open for 120,267 ms, because the hold sits INSIDE an iteration and the guard
+ * only checks between them, so nothing could interrupt it. The same constant
+ * abandoned workers observed at 4m21s, 5m58s and 8m04s on runs that had hours
+ * left.
+ */
+describe('the grace is a share of what the run has left', () => {
+    it('takes half, so the turn that reads the result still has time to happen', () => {
+        // The fraction is the whole argument. Spending everything remaining
+        // would deliver a notification into a run with no turn left to act on
+        // it — the failure this mechanism exists to prevent, in a new costume.
+        expect(settleGraceMs(60_000)).toBe(30_000);
+    });
+    it('holds for nothing when the run has nothing left', () => {
+        // A decision, not a rounding artefact: with no time left there is no
+        // turn in which to read a notification, so waiting can only delay a
+        // stop that is already due. Nothing is lost — `waitForArrival` returns
+        // before it looks at its timer when a completion is already in hand.
+        expect(settleGraceMs(0)).toBe(0);
+    });
+    it('cannot outlive the deadline it was derived from', () => {
+        // Bounded by construction, which is why the guard's inability to
+        // interrupt a hold needs no new interrupt seam.
+        for (const remaining of [1, 250, 30_000, 600_000, 3_600_000]) {
+            expect(settleGraceMs(remaining)).toBeLessThan(remaining);
+        }
+    });
+    it('stops at the longest this subsystem ever waits for a worker', () => {
+        // Only reachable for a host whose run timeout exceeds two hours.
+        expect(settleGraceMs(10 * 60 * 60 * 1000)).toBe(DELEGATION_TIMEOUT_MS);
+    });
+});
+describe('the guard reports time to the finalize point, not to the deadline', () => {
+    it('stops short of the closing reserve', () => {
+        // 90% of the budget, not 100%. The last tenth is what the guard keeps
+        // so a run can produce a closing answer; a wait sized against the
+        // deadline spends it on waiting instead.
+        const guard = new GuardCoordinator({ tokenBudget: 1_000, timeoutMs: 60_000 });
+        const remaining = guard.remainingBeforeFinalizeMs();
+        expect(remaining).toBeLessThanOrEqual(54_000);
+        expect(remaining).toBeGreaterThan(50_000);
+    });
+    it('subtracts the time a previous process already spent', () => {
+        // A run resumed from a checkpoint gets the remainder of ITS budget, not
+        // a fresh clock — otherwise N resumes buy N x timeoutMs, and a hold
+        // sized from the fresh clock would outlive the real deadline.
+        const guard = new GuardCoordinator({ tokenBudget: 1_000, timeoutMs: 60_000 });
+        guard.restoreElapsed(50_000);
+        expect(guard.remainingBeforeFinalizeMs()).toBeLessThanOrEqual(4_000);
+        expect(guard.remainingBeforeFinalizeMs()).toBeGreaterThan(1_000);
+    });
+    it('reports nothing once the run is already past the finalize point', () => {
+        // 95% elapsed: the guard is about to ask for a closing summary, and a
+        // hold opened here would be taken out of the answer's time.
+        const guard = new GuardCoordinator({ tokenBudget: 1_000, timeoutMs: 60_000 });
+        guard.restoreElapsed(57_000);
+        expect(guard.remainingBeforeFinalizeMs()).toBe(0);
+    });
+    it('never reports a negative remainder', () => {
+        const guard = new GuardCoordinator({ tokenBudget: 1_000, timeoutMs: 1_000 });
+        guard.restoreElapsed(500_000);
+        expect(guard.remainingBeforeFinalizeMs()).toBe(0);
+    });
+});
+describe('the hold cannot reach into the run closing reserve', () => {
+    it('ends before the finalize point however late it starts', () => {
+        // The failure the finalize-relative input exists for. Against the
+        // DEADLINE, a hold beginning at elapsed fraction e ends at
+        // 0.5 + 0.5e — so one starting just under the 0.9 threshold ends at
+        // 95% of the budget, with half the closing reserve gone. Against the
+        // finalize point it cannot cross 90% at all.
+        const timeoutMs = 60_000;
+        const finalizeAt = timeoutMs * 0.9;
+        for (const elapsed of [0, 30_000, 50_000, 53_000, 53_900]) {
+            const remainingBeforeFinalize = Math.max(0, finalizeAt - elapsed);
+            const endsAt = elapsed + settleGraceMs(remainingBeforeFinalize);
+            expect(endsAt, `a hold starting at ${elapsed}ms crossed the finalize point`).toBeLessThanOrEqual(finalizeAt);
+        }
+    });
+});
+const ZERO_USAGE = {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cachedTokens: 0,
+    cacheWriteTokens: 0,
+};
+/** Answers straight away. The hold is the only thing that can delay this run. */
+class AnswersImmediately {
+    id = 'answers';
+    name = 'Answers Immediately';
+    async *chatStream() {
+        yield { id: 'm1', delta: { content: 'Done.' } };
+        yield { id: 'm1', delta: {}, finishReason: 'stop', usage: ZERO_USAGE };
+    }
+}
+const workdirs = [];
+afterEach(async () => {
+    await Promise.all(workdirs.map((dir) => rm(dir, { recursive: true, force: true })));
+    workdirs.length = 0;
+});
+/**
+ * The loop, not the helper.
+ *
+ * `settleGraceMs` has its own tests above and every one of them passes with
+ * the loop still calling a constant. Only a real run can say which number the
+ * hold actually used.
+ */
+describe('the hold a run pays is the one its own budget allows', () => {
+    async function runHoldingFor(timeoutMs) {
+        const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-grace-'));
+        workdirs.push(workingDirectory);
+        const inbox = new CompletionInbox();
+        // `getTask` because the inbox asks the gateway about a task whose
+        // completion may have been announced before the launch was recorded.
+        // A double that omits a method the interface requires is not a smaller
+        // gateway, it is a broken one.
+        inbox.attach({ onTaskCompleted: () => () => { }, getTask: () => undefined });
+        // Outstanding and never settling: the worst case the bound exists for.
+        // `expect` records the launch as well, so the inbox owns this task.
+        inbox.expect('tsk_never');
+        const startedAt = Date.now();
+        await drainQuery({
+            provider: new AnswersImmediately(),
+            tools: new ToolRegistry(),
+            completionInbox: inbox,
+            agentId: 'agent_test',
+            agentName: 'Test Agent',
+            messages: [createUserMessage('go')],
+            workingDirectory,
+            runConfig: {
+                model: 'mock-model',
+                timeoutMs,
+                tokenBudget: 100_000,
+                maxIterations: 2,
+                maxResponseTokens: 256,
+            },
+            sessionId: 'ses_grace',
+            threadId: 'thd_grace',
+            projectId: 'prj_grace',
+            tenantId: 'tnt_grace',
+        });
+        return Date.now() - startedAt;
+    }
+    it('a two-second run does not wait two minutes for a worker', async () => {
+        const elapsed = await runHoldingFor(2_000);
+        // Half of two seconds, plus whatever the turn itself costs. The number
+        // this replaced would have parked here for 120 s regardless.
+        expect(elapsed, 'the hold outlived the run budget that bounds it').toBeLessThan(5_000);
+    }, 200_000);
+    it('a run with no time left does not hold at all', async () => {
+        // The guard stops this run at the top of its first iteration, so no
+        // hold is even reached — which is the point: the last tenth of a run
+        // already never holds, so no artificial minimum has to defend it.
+        const elapsed = await runHoldingFor(1);
+        expect(elapsed).toBeLessThan(2_000);
+    }, 200_000);
+    it('still delivers a completion that arrives inside the grace', async () => {
+        // The bound must not become an excuse to drop what was nearly ready.
+        const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-grace-hit-'));
+        workdirs.push(workingDirectory);
+        const inbox = new CompletionInbox();
+        let announce;
+        inbox.attach({
+            onTaskCompleted: (cb) => {
+                announce = cb;
+                return () => {
+                    announce = undefined;
+                };
+            },
+            getTask: () => undefined,
+        });
+        inbox.expect('tsk_soon');
+        const timer = setTimeout(() => {
+            announce?.({
+                taskId: 'tsk_soon',
+                agentId: 'reviewer',
+                state: 'completed',
+                createdAt: 0,
+                completedAt: 1,
+                result: { status: 'completed', result: 'ARRIVED INSIDE THE GRACE' },
+            });
+        }, 150);
+        timer.unref?.();
+        const run = await drainQuery({
+            provider: new AnswersImmediately(),
+            tools: new ToolRegistry(),
+            completionInbox: inbox,
+            agentId: 'agent_test',
+            agentName: 'Test Agent',
+            messages: [createUserMessage('go')],
+            workingDirectory,
+            runConfig: {
+                model: 'mock-model',
+                timeoutMs: 30_000,
+                tokenBudget: 100_000,
+                maxIterations: 3,
+                maxResponseTokens: 256,
+            },
+            sessionId: 'ses_grace',
+            threadId: 'thd_grace',
+            projectId: 'prj_grace',
+            tenantId: 'tnt_grace',
+        });
+        const userText = run.messages
+            .filter((m) => m.role === 'user')
+            .map((m) => (typeof m.content === 'string' ? m.content : ''));
+        expect(userText.some((m) => m.includes('ARRIVED INSIDE THE GRACE'))).toBe(true);
+    }, 200_000);
+});
+//# sourceMappingURL=settle-grace.test.js.map

package/dist/runtime/query/iteration/__tests__/settle-grace.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle-grace.test.js","sourceRoot":"","sources":["../../../../../src/runtime/query/iteration/__tests__/settle-grace.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAA;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAA;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAA;AAG9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAA;AAGtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C;;;;;;;;;GASG;AAEH,QAAQ,CAAC,+CAA+C,EAAE,GAAG,EAAE;IAC9D,EAAE,CAAC,wEAAwE,EAAE,GAAG,EAAE;QACjF,oEAAoE;QACpE,sEAAsE;QACtE,uEAAuE;QACvE,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAC3C,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QAC1D,qEAAqE;QACrE,oEAAoE;QACpE,uEAAuE;QACvE,qEAAqE;QACrE,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QAC1D,iEAAiE;QACjE,gDAAgD;QAChD,KAAK,MAAM,SAAS,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;YAC9D,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,SAAS,CAAC,CAAA;QACzD,CAAC;IACF,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACtE,iEAAiE;QACjE,MAAM,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAA;IACvE,CAAC,CAAC,CAAA;AACH,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,mEAAmE,EAAE,GAAG,EAAE;IAClF,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAC7C,sEAAsE;QACtE,kEAAkE;QAClE,yCAAyC;QACzC,MAAM,KAAK,GAAG,IAAI,gBAAgB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAA;QAE7E,MAAM,SAAS,GAAG,KAAK,CAAC,yBAAyB,EAAE,CAAA;QAEnD,MAAM,CAAC,SAAS,CAAC,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAA;QAC7C,MAAM,CAAC,SAAS,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAA;IAC1C,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC9D,wEAAwE;QACxE,oEAAoE;QACpE,8DAA8D;QAC9D,MAAM,KAAK,GAAG,IAAI,gBAAgB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAA;QAC7E,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAE5B,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAA;QACpE,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,CAAA;IACjE,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QAC1E,sEAAsE;QACtE,4DAA4D;QAC5D,MAAM,KAAK,GAAG,IAAI,gBAAgB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAA;QAC7E,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAE5B,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAClD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAC7C,MAAM,KAAK,GAAG,IAAI,gBAAgB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAA;QAC5E,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAA;QAE7B,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAClD,CAAC,CAAC,CAAA;AACH,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,oDAAoD,EAAE,GAAG,EAAE;IACnE,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAChE,kEAAkE;QAClE,2DAA2D;QAC3D,oEAAoE;QACpE,qEAAqE;QACrE,6CAA6C;QAC7C,MAAM,SAAS,GAAG,MAAM,CAAA;QACxB,MAAM,UAAU,GAAG,SAAS,GAAG,GAAG,CAAA;QAElC,KAAK,MAAM,OAAO,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;YAC3D,MAAM,uBAAuB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,CAAA;YACjE,MAAM,MAAM,GAAG,OAAO,GAAG,aAAa,CAAC,uBAAuB,CAAC,CAAA;YAE/D,MAAM,CACL,MAAM,EACN,sBAAsB,OAAO,+BAA+B,CAC5D,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;IACF,CAAC,CAAC,CAAA;AACH,CAAC,CAAC,CAAA;AAEF,MAAM,UAAU,GAAG;IAClB,YAAY,EAAE,CAAC;IACf,gBAAgB,EAAE,CAAC;IACnB,WAAW,EAAE,CAAC;IACd,YAAY,EAAE,CAAC;IACf,gBAAgB,EAAE,CAAC;CACnB,CAAA;AAED,iFAAiF;AACjF,MAAM,kBAAkB;IACd,EAAE,GAAG,SAAS,CAAA;IACd,IAAI,GAAG,qBAAqB,CAAA;IACrC,KAAK,CAAC,CAAC,UAAU;QAChB,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CAAA;QAC/C,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,CAAA;IACvE,CAAC;CACD;AAED,MAAM,QAAQ,GAAa,EAAE,CAAA;AAC7B,SAAS,CAAC,KAAK,IAAI,EAAE;IACpB,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;IACnF,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAA;AACpB,CAAC,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,QAAQ,CAAC,sDAAsD,EAAE,GAAG,EAAE;IACrE,KAAK,UAAU,aAAa,CAAC,SAAiB;QAC7C,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,cAAc,CAAC,CAAC,CAAA;QACtE,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;QAE/B,MAAM,KAAK,GAAG,IAAI,eAAe,EAAE,CAAA;QACnC,kEAAkE;QAClE,qEAAqE;QACrE,uEAAuE;QACvE,+BAA+B;QAC/B,KAAK,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS,EAAW,CAAC,CAAA;QACpF,uEAAuE;QACvE,oEAAoE;QACpE,KAAK,CAAC,MAAM,CAAC,WAAqB,CAAC,CAAA;QAEnC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QAC5B,MAAM,UAAU,CAAC;YAChB,QAAQ,EAAE,IAAI,kBAAkB,EAAE;YAClC,KAAK,EAAE,IAAI,YAAY,EAAE;YACzB,eAAe,EAAE,KAAK;YACtB,OAAO,EAAE,YAAY;YACrB,SAAS,EAAE,YAAY;YACvB,QAAQ,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACnC,gBAAgB;YAChB,SAAS,EAAE;gBACV,KAAK,EAAE,YAAY;gBACnB,SAAS;gBACT,WAAW,EAAE,OAAO;gBACpB,aAAa,EAAE,CAAC;gBAChB,iBAAiB,EAAE,GAAG;aACtB;YACD,SAAS,EAAE,WAAwB;YACnC,QAAQ,EAAE,WAAuB;YACjC,SAAS,EAAE,WAAwB;YACnC,QAAQ,EAAE,WAAuB;SACxB,CAAC,CAAA;QACX,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA;IAC9B,CAAC;IAED,EAAE,CAAC,yDAAyD,EAAE,KAAK,IAAI,EAAE;QACxE,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,CAAA;QAE1C,uEAAuE;QACvE,6DAA6D;QAC7D,MAAM,CAAC,OAAO,EAAE,iDAAiD,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;IACvF,CAAC,EAAE,OAAO,CAAC,CAAA;IAEX,EAAE,CAAC,8CAA8C,EAAE,KAAK,IAAI,EAAE;QAC7D,oEAAoE;QACpE,qEAAqE;QACrE,kEAAkE;QAClE,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,CAAC,CAAC,CAAA;QAEtC,MAAM,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;IACpC,CAAC,EAAE,OAAO,CAAC,CAAA;IAEX,EAAE,CAAC,2DAA2D,EAAE,KAAK,IAAI,EAAE;QAC1E,qEAAqE;QACrE,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAA;QAC1E,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAA;QAE/B,MAAM,KAAK,GAAG,IAAI,eAAe,EAAE,CAAA;QACnC,IAAI,QAA+C,CAAA;QACnD,KAAK,CAAC,MAAM,CAAC;YACZ,eAAe,EAAE,CAAC,EAA2B,EAAE,EAAE;gBAChD,QAAQ,GAAG,EAAE,CAAA;gBACb,OAAO,GAAG,EAAE;oBACX,QAAQ,GAAG,SAAS,CAAA;gBACrB,CAAC,CAAA;YACF,CAAC;YACD,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS;SACf,CAAC,CAAA;QACX,KAAK,CAAC,MAAM,CAAC,UAAoB,CAAC,CAAA;QAClC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC7B,QAAQ,EAAE,CAAC;gBACV,MAAM,EAAE,UAAoB;gBAC5B,OAAO,EAAE,UAAU;gBACnB,KAAK,EAAE,WAAW;gBAClB,SAAS,EAAE,CAAC;gBACZ,WAAW,EAAE,CAAC;gBACd,MAAM,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,0BAA0B,EAAE;aACrD,CAAC,CAAA;QACjB,CAAC,EAAE,GAAG,CAAC,CAAA;QACP,KAAK,CAAC,KAAK,EAAE,EAAE,CAAA;QAEf,MAAM,GAAG,GAAG,MAAM,UAAU,CAAC;YAC5B,QAAQ,EAAE,IAAI,kBAAkB,EAAE;YAClC,KAAK,EAAE,IAAI,YAAY,EAAE;YACzB,eAAe,EAAE,KAAK;YACtB,OAAO,EAAE,YAAY;YACrB,SAAS,EAAE,YAAY;YACvB,QAAQ,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACnC,gBAAgB;YAChB,SAAS,EAAE;gBACV,KAAK,EAAE,YAAY;gBACnB,SAAS,EAAE,MAAM;gBACjB,WAAW,EAAE,OAAO;gBACpB,aAAa,EAAE,CAAC;gBAChB,iBAAiB,EAAE,GAAG;aACtB;YACD,SAAS,EAAE,WAAwB;YACnC,QAAQ,EAAE,WAAuB;YACjC,SAAS,EAAE,WAAwB;YACnC,QAAQ,EAAE,WAAuB;SACxB,CAAC,CAAA;QAEX,MAAM,QAAQ,GAAI,GAAG,CAAC,QAAiD;aACrE,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC;aAChC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QAE9D,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChF,CAAC,EAAE,OAAO,CAAC,CAAA;AACZ,CAAC,CAAC,CAAA"}

package/dist/runtime/query/iteration/index.d.ts

@@ -4,10 +4,62 @@ import type { IterationContext } from './phases/index.js';
 export type { IterationContext } from './phases/index.js';
 export type { PhaseSignal } from './phases/index.js';
 export type { ToolReviewOutcome } from './phases/index.js';
+/**
+ * How long a finishing run waits for a background worker it launched.
+ *
+ * Derived from the run rather than fixed, because a constant is wrong in both
+ * directions at once. The 120 seconds this replaces held a run configured for
+ * a twenty-second timeout open for 120,267 ms — six times its own budget, and
+ * unreachable by the guard, which only checks between iterations — while on an
+ * hour-long run it abandoned workers measured at 4m21s, 5m58s and 8m04s, all
+ * of them well inside the hour the delegation tools themselves declare.
+ *
+ * **Bounded by construction, and against the right boundary.** The input is
+ * time-to-FINALIZE, not time-to-deadline (see
+ * `GuardCoordinator.remainingBeforeFinalizeMs`). Measuring to the deadline was
+ * the first attempt and it was wrong in a way that looked safe: a hold cannot
+ * outlive the deadline either way, but half of the time-to-deadline started
+ * just under the warning threshold ends at 95% of the budget — so the slice
+ * that exists for the run to produce a closing answer is half spent waiting
+ * for the result that answer was supposed to use. Against the finalize point
+ * the hold cannot reach the reserve at all, which is what makes the guard's
+ * inability to interrupt a hold a non-issue rather than a smaller issue.
+ *
+ * **The floor of zero is a decision, not a clamp artefact.** A run with no
+ * time left before it must start finishing has no turn in which to read a
+ * notification, so waiting could only delay a stop that is already due.
+ * Nothing is lost by it: `CompletionInbox.waitForArrival` returns before it
+ * looks at its timer when a completion is already in hand, so a zero grace
+ * still delivers everything that has arrived. No minimum is invented on top,
+ * because zero is exactly what a run past the threshold should wait — and
+ * reading the remainder at hold time rather than trusting `forceFinalize`,
+ * which is sampled at the top of the iteration, is what makes a long iteration
+ * that crossed the line in between compute it.
+ *
+ * **The ceiling is the longest anything in this subsystem waits for a
+ * delegated worker.** It binds only for a host whose run timeout exceeds
+ * roughly two and a quarter hours; below that the fraction is smaller.
+ */
+export declare function settleGraceMs(remainingBeforeFinalizeMs: number): number;
 export declare class IterationOrchestrator {
     private ctx;
     /** Rejections so far. See {@link DEFAULT_ANSWER_REVIEW_LIMIT}. */
     private answerReviewAttempts;
+    /**
+     * The previous iteration held a `stopWhen` decision open for a worker.
+     *
+     * Set when the stop predicate fired and the run took one extra turn to
+     * read a delegated result, so the turn that then ends the run can report
+     * WHY it is over. Without it the outcome was right and the record was
+     * wrong: the run stopped because the host said so and reported `end_turn`,
+     * and this repo carries thirteen `StopReason` values precisely so that a
+     * run which ends for a nameable reason names it.
+     *
+     * Lives for exactly one iteration — see the read-and-clear at the top of
+     * the loop, which is the only site that touches it besides the one that
+     * sets it.
+     */
+    private stopDeferredForOutstandingWork;
     constructor(ctx: IterationContext);
     /**
      * Adopt the run's span after construction.
@@ -18,6 +70,46 @@ export declare class IterationOrchestrator {
      */
     setRootSpan(span: Span): void;
     runLoop(): AsyncGenerator<RunEvent>;
+    /**
+     * Hold the run open for a worker that has not finished, and deliver it.
+     *
+     * Returns whether a completion arrived and was put in the transcript — the
+     * caller continues the loop on `true`, so the model gets a turn in which to
+     * USE the result. That turn is the entire justification for waiting, which
+     * is why only the exits that can still take one call this.
+     *
+     * Bounded by `settleGraceMs` and by `maxIterations`, so a worker that never
+     * finishes cannot keep the run open.
+     */
+    private holdForOutstandingWork;
+    /**
+     * Account for delegated work on the way out: deliver what arrived, and say
+     * what did not.
+     *
+     * A run that ends with a worker outstanding must not leave the impression
+     * that the worker's result was delivered. There are exactly two honest
+     * outcomes and this does both:
+     *
+     *  - **What has already arrived is delivered.** It makes no false claim,
+     *    and dropping it is pure loss — the message rides out on
+     *    `Run.messages`, so a host reads it and the next turn of a continued
+     *    thread starts with it. This does NOT wait: a hold buys the model a
+     *    turn in which to USE a result, and on an exit whose answer is already
+     *    decided there is no such turn, so waiting would delay a settled answer
+     *    to append text this run will not read. The bounded hold stays where it
+     *    was, on the exits that do have a turn left.
+     *  - **What is still running is NAMED, not cancelled.** Giving up on a wait
+     *    is a statement about the waiter, not about the work — the rule
+     *    `wait-with-idle-bound.ts` already states for the same subsystem — and
+     *    "the parent answered early" is a weaker warrant for killing a child
+     *    than "the clock ran out", not a stronger one. Killing a worker that
+     *    may be mid-write is a policy only the host can judge, and it has
+     *    `cancel_task` and the run controller to judge it with.
+     */
+    private settleOutstandingWork;
+    /** Delegated work this run walked away from. See {@link settleOutstandingWork}. */
+    private recordAbandonedWork;
+    private deliverArrivedCompletions;
     /**
      * Ask the host how to shape this step.
      *

package/dist/runtime/query/iteration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/query/iteration/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAkB,MAAM,oBAAoB,CAAA;AA6B9D,OAAO,KAAK,EAEX,QAAQ,EACR,UAAU,EAEV,MAAM,6BAA6B,CAAA;AAUpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAMzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACzD,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAsB1D,qBAAa,qBAAqB;IACjC,OAAO,CAAC,GAAG,CAAkB;IAC7B,kEAAkE;IAClE,OAAO,CAAC,oBAAoB,CAAI;gBAEpB,GAAG,EAAE,gBAAgB;IAIjC;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAItB,OAAO,IAAI,cAAc,CAAC,QAAQ,CAAC;IAsuB1C;;;;;;;OAOG;YACW,WAAW;IA2EzB,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IAEzC,QAAQ,IAAI,SAAS,UAAU,EAAE;IAIjC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAgDlB,wEAAwE;IACxE,OAAO,CAAC,wBAAwB,CAAI;IACpC,OAAO,CAAC,oBAAoB,CAAQ;IAEpC,OAAO,CAAC,0BAA0B;IAIlC,uEAAuE;IACvE,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;OAOG;IACH;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,kBAAkB;IA4B1B,OAAO,CAAC,uBAAuB;IAe/B;;;;;;;;;;;OAWG;YACW,YAAY;IAiB1B,6DAA6D;YAC/C,UAAU;IAsBxB,OAAO,CAAC,oBAAoB;YAOd,oBAAoB;CA6ElC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/runtime/query/iteration/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAkB,MAAM,oBAAoB,CAAA;AA+B9D,OAAO,KAAK,EAEX,QAAQ,EACR,UAAU,EAEV,MAAM,6BAA6B,CAAA;AAUpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAMzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACzD,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AA+B1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,yBAAyB,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED,qBAAa,qBAAqB;IACjC,OAAO,CAAC,GAAG,CAAkB;IAC7B,kEAAkE;IAClE,OAAO,CAAC,oBAAoB,CAAI;IAChC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,8BAA8B,CAAQ;gBAElC,GAAG,EAAE,gBAAgB;IAIjC;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAItB,OAAO,IAAI,cAAc,CAAC,QAAQ,CAAC;IA4yB1C;;;;;;;;;;OAUG;YACY,sBAAsB;IA+BrC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,qBAAqB;IAK7B,mFAAmF;IACnF,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,yBAAyB;IA8BjC;;;;;;;OAOG;YACW,WAAW;IAyFzB,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IAEzC,QAAQ,IAAI,SAAS,UAAU,EAAE;IAIjC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAgDlB,wEAAwE;IACxE,OAAO,CAAC,wBAAwB,CAAI;IACpC,OAAO,CAAC,oBAAoB,CAAQ;IAEpC,OAAO,CAAC,0BAA0B;IAIlC,uEAAuE;IACvE,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;OAOG;IACH;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,kBAAkB;IA4B1B,OAAO,CAAC,uBAAuB;IAe/B;;;;;;;;;;;OAWG;YACW,YAAY;IAiB1B,6DAA6D;YAC/C,UAAU;IAsBxB,OAAO,CAAC,oBAAoB;YAOd,oBAAoB;CA6ElC"}