@kaelio/ktx 0.9.0 → 0.11.0

package/dist/context/llm/codex-runtime.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { noopLogger } from '../core/config.js';
+import { isAbortError, linkAbortSignal } from '../core/abort.js';
 import { isCompletedAgentStep, summarizeCodexExecEvents } from './codex-exec-events.js';
 import { startCodexRuntimeMcpServer, } from './codex-mcp-runtime-server.js';
 import { resolveCodexModel } from './codex-models.js';
@@ -18,8 +18,8 @@ function isTurnCompleted(event) {
     return eventRecord(event)?.type === 'turn.completed';
 }
 /**
- * Drains the Codex stream once, emitting a step as each agent action completes
- * so callers see live progress and the step budget is enforced mid-run. Every
+ * Drains the Codex stream once, counting each completed agent action so the
+ * step budget is enforced mid-run. Every
  * completed agent-action item counts (see {@link isCompletedAgentStep}), so
  * built-in `command_execution` steps decrement the budget the same as
  * `mcp_tool_call`s. A turn that produced no actions still counts as one step,
@@ -48,7 +48,6 @@ async function collectEvents(events, options = {}) {
                 continue;
             }
             completedSteps += 1;
-            await options.onStep?.(completedSteps);
             if (isActionStep && options.stepBudget !== undefined && completedSteps >= options.stepBudget) {
                 budgetExceeded = true;
                 options.abortController?.abort();
@@ -107,14 +106,43 @@ async function mcpForTools(input) {
 function runtimeToolNames(toolSet) {
     return Object.values(toolSet ?? {}).map((descriptor) => descriptor.name);
 }
+const CODEX_RATE_LIMIT_MARKERS = /\b429\b|rate limit|too many requests|quota exceeded|temporarily overloaded/i;
+function isCodexRateLimitError(error) {
+    return !!error && CODEX_RATE_LIMIT_MARKERS.test(error.message);
+}
 export class CodexKtxLlmRuntime {
     deps;
     runner;
-    logger;
     constructor(deps) {
         this.deps = deps;
         this.runner = deps.runner ?? new CodexSdkCliRunner();
-        this.logger = deps.logger ?? noopLogger;
+    }
+    async runWithRateLimitRetry(abortSignal, run, getError) {
+        // maxRetryAttempts() returns 1 when no governor is present or pacing is
+        // disabled, so an opaque rate-limit failure surfaces on the first attempt
+        // instead of being retried with no backoff.
+        const maxAttempts = this.deps.rateLimitGovernor?.maxRetryAttempts() ?? 1;
+        for (let attempt = 0;; attempt += 1) {
+            await this.deps.rateLimitGovernor?.waitForReady(abortSignal);
+            const lastAttempt = attempt >= maxAttempts - 1;
+            try {
+                const result = await run();
+                const error = getError(result);
+                if (!isCodexRateLimitError(error) || lastAttempt) {
+                    return result;
+                }
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    throw error;
+                }
+                const err = error instanceof Error ? error : new Error(String(error));
+                if (!isCodexRateLimitError(err) || lastAttempt) {
+                    throw error;
+                }
+            }
+            this.deps.rateLimitGovernor?.report({ provider: 'codex', status: 'rejected', rateLimitType: 'opaque' });
+        }
     }
     async generateText(input) {
         const startedAt = Date.now();
@@ -138,16 +166,20 @@ export class CodexKtxLlmRuntime {
                     }
                     : {}),
             });
-            const collected = await collectEvents(await this.runner.runStreamed({
-                projectDir: this.deps.projectDir,
-                model,
-                prompt: promptWithSystem(input.system, input.prompt),
-                configOverrides: config.configOverrides,
-                env: config.env,
-            }));
-            const summary = summarizeCodexExecEvents(collected.events, { startedAt });
-            input.onMetrics?.(metrics(summary, startedAt));
-            return assertSuccessfulText(summary, collected.streamError);
+            const result = await this.runWithRateLimitRetry(input.abortSignal, async () => {
+                const collected = await collectEvents(await this.runner.runStreamed({
+                    projectDir: this.deps.projectDir,
+                    model,
+                    prompt: promptWithSystem(input.system, input.prompt),
+                    configOverrides: config.configOverrides,
+                    env: config.env,
+                    ...(input.abortSignal ? { signal: input.abortSignal } : {}),
+                }));
+                const summary = summarizeCodexExecEvents(collected.events, { startedAt });
+                return { collected, summary };
+            }, ({ collected, summary }) => summaryError(summary, collected.streamError));
+            input.onMetrics?.(metrics(result.summary, startedAt));
+            return assertSuccessfulText(result.summary, result.collected.streamError);
         }
         finally {
             await mcp?.close();
@@ -175,17 +207,21 @@ export class CodexKtxLlmRuntime {
                     }
                     : {}),
             });
-            const collected = await collectEvents(await this.runner.runStreamed({
-                projectDir: this.deps.projectDir,
-                model,
-                prompt: promptWithSystem(input.system, input.prompt),
-                configOverrides: config.configOverrides,
-                env: config.env,
-                outputSchema: z.toJSONSchema(input.schema, { target: 'draft-7' }),
-            }));
-            const summary = summarizeCodexExecEvents(collected.events, { startedAt });
-            input.onMetrics?.(metrics(summary, startedAt));
-            return parseStructuredOutput(input.schema, assertSuccessfulText(summary, collected.streamError));
+            const result = await this.runWithRateLimitRetry(input.abortSignal, async () => {
+                const collected = await collectEvents(await this.runner.runStreamed({
+                    projectDir: this.deps.projectDir,
+                    model,
+                    prompt: promptWithSystem(input.system, input.prompt),
+                    configOverrides: config.configOverrides,
+                    env: config.env,
+                    outputSchema: z.toJSONSchema(input.schema, { target: 'draft-7' }),
+                    ...(input.abortSignal ? { signal: input.abortSignal } : {}),
+                }));
+                const summary = summarizeCodexExecEvents(collected.events, { startedAt });
+                return { collected, summary };
+            }, ({ collected, summary }) => summaryError(summary, collected.streamError));
+            input.onMetrics?.(metrics(result.summary, startedAt));
+            return parseStructuredOutput(input.schema, assertSuccessfulText(result.summary, result.collected.streamError));
         }
         finally {
             await mcp?.close();
@@ -214,38 +250,45 @@ export class CodexKtxLlmRuntime {
                     }
                     : {}),
             });
-            const abortController = new AbortController();
-            const onStep = async (stepIndex) => {
+            const result = await this.runWithRateLimitRetry(params.abortSignal, async () => {
+                const linked = linkAbortSignal(params.abortSignal);
+                const abortController = linked.controller;
                 try {
-                    await params.onStepFinish?.({ stepIndex, stepBudget: params.stepBudget });
+                    const collected = await collectEvents(await this.runner.runStreamed({
+                        projectDir: this.deps.projectDir,
+                        model,
+                        prompt: promptWithSystem(params.systemPrompt, params.userPrompt),
+                        configOverrides: config.configOverrides,
+                        env: config.env,
+                        signal: abortController.signal,
+                    }), { stepBudget: params.stepBudget, abortController });
+                    const summary = summarizeCodexExecEvents(collected.events, { startedAt });
+                    return { collected, summary };
                 }
-                catch (error) {
-                    this.logger.warn(`[codex-runner] onStepFinish callback threw; ignoring: ${error instanceof Error ? error.message : String(error)}`);
+                finally {
+                    linked.dispose();
                 }
-            };
-            const collected = await collectEvents(await this.runner.runStreamed({
-                projectDir: this.deps.projectDir,
-                model,
-                prompt: promptWithSystem(params.systemPrompt, params.userPrompt),
-                configOverrides: config.configOverrides,
-                env: config.env,
-                signal: abortController.signal,
-            }), { stepBudget: params.stepBudget, abortController, onStep });
-            const summary = summarizeCodexExecEvents(collected.events, { startedAt });
-            const error = summaryError(summary, collected.streamError);
-            const stopReason = collected.budgetExceeded ? 'budget' : error ? 'error' : summary.stopReason;
+            }, ({ collected, summary }) => summaryError(summary, collected.streamError));
+            const error = summaryError(result.summary, result.collected.streamError);
+            if (isAbortError(error)) {
+                throw error;
+            }
+            const stopReason = result.collected.budgetExceeded ? 'budget' : error ? 'error' : result.summary.stopReason;
             return {
                 stopReason,
                 ...(stopReason === 'error' && error ? { error } : {}),
                 metrics: {
                     totalMs: Date.now() - startedAt,
-                    usage: summary.usage,
-                    stepCount: summary.stepCount,
-                    stepBoundariesMs: summary.stepBoundariesMs,
+                    usage: result.summary.usage,
+                    stepCount: result.summary.stepCount,
+                    stepBoundariesMs: result.summary.stepBoundariesMs,
                 },
             };
         }
         catch (error) {
+            if (isAbortError(error)) {
+                throw error;
+            }
             const err = error instanceof Error ? error : new Error(String(error));
             return {
                 stopReason: 'error',

package/dist/context/llm/local-config.d.ts

@@ -2,19 +2,29 @@ import { createKtxEmbeddingProvider } from '../../llm/embedding-provider.js';
 import { createKtxLlmProvider } from '../../llm/model-provider.js';
 import type { KtxEmbeddingConfig, KtxEmbeddingProvider, KtxLlmConfig, KtxLlmProvider } from '../../llm/types.js';
 import type { KtxProjectEmbeddingConfig, KtxProjectLlmConfig } from '../project/config.js';
+import { AiSdkKtxLlmRuntime } from './ai-sdk-runtime.js';
 import { ClaudeCodeKtxLlmRuntime } from './claude-code-runtime.js';
 import { CodexKtxLlmRuntime } from './codex-runtime.js';
+import type { RateLimitGovernor } from './rate-limit-governor.js';
 import type { KtxLlmRuntimePort } from './runtime-port.js';
+type ClaudeCodeRuntimeDeps = ConstructorParameters<typeof ClaudeCodeKtxLlmRuntime>[0] & {
+    rateLimitGovernor?: RateLimitGovernor;
+};
+type CodexRuntimeDeps = ConstructorParameters<typeof CodexKtxLlmRuntime>[0] & {
+    rateLimitGovernor?: RateLimitGovernor;
+};
+type AiSdkRuntimeDeps = ConstructorParameters<typeof AiSdkKtxLlmRuntime>[0] & {
+    rateLimitGovernor?: RateLimitGovernor;
+};
 interface LocalConfigDeps {
     env?: NodeJS.ProcessEnv;
     projectDir?: string;
+    rateLimitGovernor?: RateLimitGovernor;
     createKtxLlmProvider?: typeof createKtxLlmProvider;
     createKtxEmbeddingProvider?: typeof createKtxEmbeddingProvider;
-    createClaudeCodeRuntime?: (deps: ConstructorParameters<typeof ClaudeCodeKtxLlmRuntime>[0]) => KtxLlmRuntimePort;
-    createCodexRuntime?: (deps: ConstructorParameters<typeof CodexKtxLlmRuntime>[0]) => KtxLlmRuntimePort;
-    createAiSdkRuntime?: (deps: {
-        llmProvider: KtxLlmProvider;
-    }) => KtxLlmRuntimePort;
+    createClaudeCodeRuntime?: (deps: ClaudeCodeRuntimeDeps) => KtxLlmRuntimePort;
+    createCodexRuntime?: (deps: CodexRuntimeDeps) => KtxLlmRuntimePort;
+    createAiSdkRuntime?: (deps: AiSdkRuntimeDeps) => KtxLlmRuntimePort;
 }
 export declare function resolveLocalKtxLlmConfig(config: KtxProjectLlmConfig, env: NodeJS.ProcessEnv): KtxLlmConfig | null;
 /** @internal */

package/dist/context/llm/local-config.js

@@ -90,6 +90,7 @@ export function createLocalKtxLlmRuntimeFromConfig(config, deps = {}) {
             projectDir,
             modelSlots: resolved.modelSlots,
             env: deps.env,
+            rateLimitGovernor: deps.rateLimitGovernor,
         });
     }
     if (resolved.backend === 'codex') {
@@ -100,10 +101,14 @@ export function createLocalKtxLlmRuntimeFromConfig(config, deps = {}) {
         return (deps.createCodexRuntime ?? ((runtimeDeps) => new CodexKtxLlmRuntime(runtimeDeps)))({
             projectDir,
             modelSlots: resolved.modelSlots,
+            rateLimitGovernor: deps.rateLimitGovernor,
         });
     }
     const llmProvider = (deps.createKtxLlmProvider ?? createKtxLlmProvider)(resolved);
-    return (deps.createAiSdkRuntime ?? ((runtimeDeps) => new AiSdkKtxLlmRuntime(runtimeDeps)))({ llmProvider });
+    return (deps.createAiSdkRuntime ?? ((runtimeDeps) => new AiSdkKtxLlmRuntime(runtimeDeps)))({
+        llmProvider,
+        rateLimitGovernor: deps.rateLimitGovernor,
+    });
 }
 export function resolveLocalKtxEmbeddingConfig(config, env) {
     if (config.backend === 'none') {

package/dist/context/llm/rate-limit-governor.d.ts

@@ -0,0 +1,103 @@
+export type RateLimitProvider = 'claude-subscription' | 'anthropic-api' | 'vertex' | 'codex';
+type RateLimitSignalStatus = 'allowed' | 'warning' | 'rejected';
+export interface RateLimitSignal {
+    provider: RateLimitProvider;
+    status: RateLimitSignalStatus;
+    resetAtMs?: number;
+    retryAfterMs?: number;
+    utilization?: number;
+    rateLimitType?: string;
+}
+export interface RateLimitRetryConfig {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitter: boolean;
+}
+export interface RateLimitGovernorConfig {
+    enabled: boolean;
+    maxConcurrency: number;
+    throttleThreshold: number;
+    minConcurrencyUnderPressure: number;
+    maxWaitMs?: number;
+    waitStateTickMs: number;
+    retry: RateLimitRetryConfig;
+}
+export type RateLimitWaitState = {
+    kind: 'rate_limit_observed';
+    provider: RateLimitProvider;
+    status: RateLimitSignalStatus;
+    rateLimitType?: string;
+    resetAtMs?: number;
+    retryAfterMs?: number;
+    utilization?: number;
+} | {
+    kind: 'concurrency_adjusted';
+    provider: RateLimitProvider;
+    from: number;
+    to: number;
+    reason: string;
+    rateLimitType?: string;
+    utilization?: number;
+} | {
+    kind: 'wait_started' | 'wait_tick' | 'wait_finished';
+    provider: RateLimitProvider;
+    rateLimitType?: string;
+    resumeAtMs: number;
+    remainingMs: number;
+};
+export interface RateLimitGovernorDeps {
+    now?: () => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    random?: () => number;
+}
+export type RateLimitRelease = () => void;
+type Subscriber = (state: RateLimitWaitState) => void;
+export declare function createRateLimitGovernorConfig(input?: Partial<RateLimitGovernorConfig> & {
+    retry?: Partial<RateLimitRetryConfig>;
+}): RateLimitGovernorConfig;
+export declare class RateLimitGovernor {
+    private readonly config;
+    private readonly now;
+    private readonly sleep;
+    private readonly random;
+    private readonly subscribers;
+    private waiters;
+    private active;
+    private effectiveLimit;
+    private pausedUntilMs;
+    private pausedProvider;
+    private pausedRateLimitType;
+    private pausedTickMs;
+    private opaqueAttempts;
+    private pauseGeneration;
+    private visibleWaitAbort;
+    constructor(config: RateLimitGovernorConfig, deps?: RateLimitGovernorDeps);
+    currentLimit(): number;
+    /**
+     * Total attempts a runtime should make for a single rate-limited LLM call,
+     * including the first try. Returns 1 (no outer retry) when pacing is disabled:
+     * the outer retry loop only exists to cooperate with this governor's pause, so
+     * without active pacing there is no backoff to apply and the backend's own
+     * retry handles transient rejections.
+     */
+    maxRetryAttempts(): number;
+    activeSlots(): number;
+    subscribe(cb: Subscriber): () => void;
+    report(signal: RateLimitSignal): void;
+    waitForReady(signal?: AbortSignal): Promise<void>;
+    acquireWorkSlot(signal?: AbortSignal): Promise<RateLimitRelease>;
+    private applyPause;
+    private resumeAtMsFor;
+    private adjustLimit;
+    private startVisibleWaitTicker;
+    private stopVisibleWaitTicker;
+    private runVisibleWaitTicker;
+    private finishPause;
+    private waitForPause;
+    private waitForSlot;
+    private wakeWaiters;
+    private emitWait;
+    private emit;
+}
+export {};

package/dist/context/llm/rate-limit-governor.js

@@ -0,0 +1,285 @@
+import { createAbortError, throwIfAborted } from '../core/abort.js';
+const defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(createAbortError());
+        return;
+    }
+    const timeout = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => {
+        clearTimeout(timeout);
+        reject(createAbortError());
+    }, { once: true });
+});
+export function createRateLimitGovernorConfig(input = {}) {
+    return {
+        enabled: input.enabled ?? true,
+        maxConcurrency: input.maxConcurrency ?? 1,
+        throttleThreshold: input.throttleThreshold ?? 0.8,
+        minConcurrencyUnderPressure: input.minConcurrencyUnderPressure ?? 1,
+        ...(input.maxWaitMs !== undefined ? { maxWaitMs: input.maxWaitMs } : {}),
+        waitStateTickMs: input.waitStateTickMs ?? 1_000,
+        retry: {
+            maxAttempts: input.retry?.maxAttempts ?? 6,
+            baseDelayMs: input.retry?.baseDelayMs ?? 1_000,
+            maxDelayMs: input.retry?.maxDelayMs ?? 60_000,
+            jitter: input.retry?.jitter ?? true,
+        },
+    };
+}
+export class RateLimitGovernor {
+    config;
+    now;
+    sleep;
+    random;
+    subscribers = new Set();
+    waiters = [];
+    active = 0;
+    effectiveLimit;
+    pausedUntilMs = null;
+    pausedProvider = null;
+    pausedRateLimitType;
+    pausedTickMs = null;
+    opaqueAttempts = new Map();
+    pauseGeneration = 0;
+    visibleWaitAbort = null;
+    constructor(config, deps = {}) {
+        this.config = config;
+        this.now = deps.now ?? Date.now;
+        this.sleep = deps.sleep ?? defaultSleep;
+        this.random = deps.random ?? Math.random;
+        this.effectiveLimit = Math.max(1, config.maxConcurrency);
+    }
+    currentLimit() {
+        return this.config.enabled ? this.effectiveLimit : this.config.maxConcurrency;
+    }
+    /**
+     * Total attempts a runtime should make for a single rate-limited LLM call,
+     * including the first try. Returns 1 (no outer retry) when pacing is disabled:
+     * the outer retry loop only exists to cooperate with this governor's pause, so
+     * without active pacing there is no backoff to apply and the backend's own
+     * retry handles transient rejections.
+     */
+    maxRetryAttempts() {
+        return this.config.enabled ? Math.max(1, this.config.retry.maxAttempts) : 1;
+    }
+    activeSlots() {
+        return this.active;
+    }
+    subscribe(cb) {
+        this.subscribers.add(cb);
+        if (this.pausedUntilMs !== null) {
+            this.startVisibleWaitTicker();
+        }
+        return () => {
+            this.subscribers.delete(cb);
+            if (this.subscribers.size === 0) {
+                this.stopVisibleWaitTicker();
+                this.wakeWaiters();
+            }
+        };
+    }
+    report(signal) {
+        if (!this.config.enabled) {
+            return;
+        }
+        this.emit({
+            kind: 'rate_limit_observed',
+            provider: signal.provider,
+            status: signal.status,
+            ...(signal.rateLimitType ? { rateLimitType: signal.rateLimitType } : {}),
+            ...(signal.resetAtMs !== undefined ? { resetAtMs: signal.resetAtMs } : {}),
+            ...(signal.retryAfterMs !== undefined ? { retryAfterMs: signal.retryAfterMs } : {}),
+            ...(signal.utilization !== undefined ? { utilization: signal.utilization } : {}),
+        });
+        if (signal.status === 'rejected') {
+            this.applyPause(signal);
+            return;
+        }
+        if (signal.status === 'warning' || (signal.utilization ?? 0) >= this.config.throttleThreshold) {
+            this.adjustLimit(Math.max(1, this.config.minConcurrencyUnderPressure), signal, 'provider pressure');
+            return;
+        }
+        this.opaqueAttempts.delete(signal.provider);
+        if ((signal.utilization ?? 0) < this.config.throttleThreshold) {
+            this.adjustLimit(Math.max(1, this.config.maxConcurrency), signal, 'provider recovered');
+        }
+    }
+    async waitForReady(signal) {
+        throwIfAborted(signal);
+        if (!this.config.enabled) {
+            return;
+        }
+        await this.waitForPause(signal);
+        throwIfAborted(signal);
+    }
+    async acquireWorkSlot(signal) {
+        throwIfAborted(signal);
+        if (!this.config.enabled) {
+            this.active += 1;
+            return () => {
+                this.active -= 1;
+            };
+        }
+        while (true) {
+            throwIfAborted(signal);
+            await this.waitForPause(signal);
+            throwIfAborted(signal);
+            if (this.active < this.effectiveLimit) {
+                this.active += 1;
+                let released = false;
+                return () => {
+                    if (released)
+                        return;
+                    released = true;
+                    this.active -= 1;
+                    this.wakeWaiters();
+                };
+            }
+            await this.waitForSlot(signal);
+        }
+    }
+    applyPause(signal) {
+        const resumeAtMs = this.resumeAtMsFor(signal);
+        const boundedResumeAtMs = this.config.maxWaitMs === undefined ? resumeAtMs : Math.min(resumeAtMs, this.now() + this.config.maxWaitMs);
+        if (this.pausedUntilMs === null || boundedResumeAtMs > this.pausedUntilMs) {
+            this.pausedUntilMs = boundedResumeAtMs;
+            this.pausedProvider = signal.provider;
+            this.pausedRateLimitType = signal.rateLimitType;
+            this.pausedTickMs = signal.rateLimitType === 'opaque' ? Math.max(1, boundedResumeAtMs - this.now()) : null;
+            this.emitWait('wait_started');
+            this.startVisibleWaitTicker();
+            this.wakeWaiters();
+        }
+        this.adjustLimit(Math.max(1, this.config.minConcurrencyUnderPressure), signal, 'provider rejected');
+    }
+    resumeAtMsFor(signal) {
+        if (signal.resetAtMs !== undefined) {
+            return signal.resetAtMs;
+        }
+        if (signal.retryAfterMs !== undefined) {
+            return this.now() + signal.retryAfterMs;
+        }
+        const attempts = this.opaqueAttempts.get(signal.provider) ?? 0;
+        this.opaqueAttempts.set(signal.provider, Math.min(attempts + 1, this.config.retry.maxAttempts));
+        const base = Math.min(this.config.retry.maxDelayMs, this.config.retry.baseDelayMs * 2 ** Math.min(attempts, this.config.retry.maxAttempts - 1));
+        const jitterMultiplier = this.config.retry.jitter ? 0.75 + this.random() * 0.5 : 1;
+        return this.now() + Math.round(base * jitterMultiplier);
+    }
+    adjustLimit(to, signal, reason) {
+        const bounded = Math.max(1, Math.min(this.config.maxConcurrency, to));
+        if (bounded === this.effectiveLimit) {
+            return;
+        }
+        const from = this.effectiveLimit;
+        this.effectiveLimit = bounded;
+        this.emit({
+            kind: 'concurrency_adjusted',
+            provider: signal.provider,
+            from,
+            to: bounded,
+            reason,
+            ...(signal.rateLimitType ? { rateLimitType: signal.rateLimitType } : {}),
+            ...(signal.utilization !== undefined ? { utilization: signal.utilization } : {}),
+        });
+        this.wakeWaiters();
+    }
+    startVisibleWaitTicker() {
+        if (this.subscribers.size === 0 || this.pausedUntilMs === null) {
+            return;
+        }
+        this.stopVisibleWaitTicker();
+        const generation = (this.pauseGeneration += 1);
+        const controller = new AbortController();
+        this.visibleWaitAbort = controller;
+        void this.runVisibleWaitTicker(generation, controller.signal).catch(() => undefined);
+    }
+    stopVisibleWaitTicker() {
+        this.visibleWaitAbort?.abort();
+        this.visibleWaitAbort = null;
+    }
+    async runVisibleWaitTicker(generation, signal) {
+        while (!signal.aborted && generation === this.pauseGeneration && this.pausedUntilMs !== null) {
+            const remainingMs = this.pausedUntilMs - this.now();
+            if (remainingMs <= 0) {
+                this.finishPause(generation);
+                return;
+            }
+            this.emitWait('wait_tick');
+            await this.sleep(Math.min(this.pausedTickMs ?? this.config.waitStateTickMs, remainingMs), signal);
+        }
+    }
+    finishPause(generation) {
+        if (generation !== undefined && generation !== this.pauseGeneration) {
+            return;
+        }
+        this.emitWait('wait_finished');
+        this.pausedUntilMs = null;
+        this.pausedProvider = null;
+        this.pausedRateLimitType = undefined;
+        this.pausedTickMs = null;
+        this.stopVisibleWaitTicker();
+        this.wakeWaiters();
+    }
+    async waitForPause(signal) {
+        throwIfAborted(signal);
+        while (this.pausedUntilMs !== null) {
+            const remainingMs = this.pausedUntilMs - this.now();
+            if (remainingMs <= 0) {
+                this.finishPause();
+                return;
+            }
+            if (this.visibleWaitAbort !== null) {
+                await this.waitForSlot(signal);
+            }
+            else {
+                await this.sleep(Math.min(this.pausedTickMs ?? this.config.waitStateTickMs, remainingMs), signal);
+            }
+            throwIfAborted(signal);
+        }
+    }
+    waitForSlot(signal) {
+        if (signal?.aborted) {
+            return Promise.reject(createAbortError());
+        }
+        return new Promise((resolve, reject) => {
+            const wake = () => {
+                cleanup();
+                resolve();
+            };
+            const onAbort = () => {
+                cleanup();
+                reject(createAbortError());
+            };
+            const cleanup = () => {
+                this.waiters = this.waiters.filter((candidate) => candidate !== wake);
+                signal?.removeEventListener('abort', onAbort);
+            };
+            this.waiters.push(wake);
+            signal?.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    wakeWaiters() {
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const waiter of waiters) {
+            waiter();
+        }
+    }
+    emitWait(kind) {
+        if (this.pausedUntilMs === null || this.pausedProvider === null) {
+            return;
+        }
+        this.emit({
+            kind,
+            provider: this.pausedProvider,
+            ...(this.pausedRateLimitType ? { rateLimitType: this.pausedRateLimitType } : {}),
+            resumeAtMs: this.pausedUntilMs,
+            remainingMs: Math.max(0, this.pausedUntilMs - this.now()),
+        });
+    }
+    emit(state) {
+        for (const subscriber of this.subscribers) {
+            subscriber(state);
+        }
+    }
+}