@ashx-j/lunr 0.1.0

package/dist/builtin-extensions/pi-subagents/src/watchdog/runtime.js

@@ -0,0 +1,647 @@
+// @ts-nocheck
+import { createHash } from "node:crypto";
+import { computeWatchdogRepoChangeSignature, eventIndicatesRepoEdit } from "./change-signature.js";
+import { WatchdogEmissionGuard } from "./emission-guard.js";
+import { collectWatchdogLspDiagnostics, formatWatchdogLspDiagnosticsBlock, WatchdogLspDiagnosticsLedger, watchdogWarningFromLspDiagnostics, } from "./lsp-diagnostics.js";
+import { resolveWatchdogConfig } from "./settings.js";
+import { formatWatchdogTurnDelta } from "./turn-delta.js";
+import { normalizeWatchdogWarningDetails } from "./warning-format.js";
+const DEFAULT_REVIEW = () => ({ warnings: [] });
+const MAX_REVIEW_INPUT_CHARS = 24_000;
+const REVIEW_DELTA_SEPARATOR = "\n\n---\n\n";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function promptFromBeforeAgentStart(event) {
+    if (!event || typeof event !== "object")
+        return undefined;
+    const input = event;
+    if (typeof input.prompt === "string")
+        return input.prompt;
+    if (typeof input.systemPrompt === "string")
+        return input.systemPrompt;
+    return undefined;
+}
+function reviewInputSignature(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+export class MainWatchdogRuntime {
+    cwd;
+    resolveConfig;
+    review;
+    reviewConnected;
+    reviewDescription;
+    displayWarning;
+    reviewChangesOnly;
+    lspDiagnostics;
+    lspLedger = new WatchdogLspDiagnosticsLedger();
+    configResult;
+    sessionOverrideEnabled;
+    sessionModelOverride;
+    status = "idle";
+    pendingDeltas = [];
+    pendingDeltaChars = 0;
+    guard = new WatchdogEmissionGuard();
+    guardMaxWarnings = null;
+    epoch = 0;
+    reviewIdCounter = 0;
+    agentEndIdCounter = 0;
+    activeAgentEndId;
+    activeAgentEndAbortController;
+    activeReviewId;
+    activeReviewWarning;
+    reviewing = false;
+    waitingAtAgentEnd = false;
+    disposed = false;
+    includeUserPromptInNextDelta = false;
+    userPrompt;
+    waiters = [];
+    lastWarning;
+    lastError;
+    lastReviewInputSignature;
+    turnStartChangeSignature;
+    lastReviewedChangeSignature;
+    currentChangedPaths;
+    lastLspSnapshot;
+    observedRepoEditThisTurn = false;
+    failedReviews = 0;
+    staleReviews = 0;
+    constructor(options = {}) {
+        this.cwd = options.cwd ?? process.cwd();
+        this.resolveConfig = options.resolveConfig ?? resolveWatchdogConfig;
+        this.review = options.review ?? DEFAULT_REVIEW;
+        this.reviewConnected = Boolean(options.review);
+        this.reviewDescription = options.reviewDescription ?? (options.review ? "injected seam" : "not wired");
+        this.displayWarning = options.displayWarning;
+        this.reviewChangesOnly = options.reviewChangesOnly === true;
+        this.lspDiagnostics = options.lspDiagnostics ?? collectWatchdogLspDiagnostics;
+        this.configResult = this.resolveConfig(this.cwd);
+        this.guardMaxWarnings = this.configResult.config.maxWarnings;
+        this.guard = new WatchdogEmissionGuard({ maxWarnings: this.guardMaxWarnings });
+        this.turnStartChangeSignature = this.currentRepoChangeSignature();
+        this.lastReviewedChangeSignature = this.turnStartChangeSignature?.key;
+    }
+    bindSession(ctx) {
+        this.cwd = ctx.cwd;
+        this.sessionOverrideEnabled = undefined;
+        this.sessionModelOverride = undefined;
+        this.reset("session_start", { clearReviewInputSignature: true, resetChangeSignature: true, clearLspLedger: true });
+        this.refreshConfig(ctx.cwd);
+        this.resetRepoChangeBaseline();
+    }
+    refreshConfig(cwd = this.cwd) {
+        this.cwd = cwd;
+        const wasEnabled = this.isEnabled();
+        const session = this.sessionOverrideEnabled === undefined && this.sessionModelOverride === undefined
+            ? undefined
+            : {
+                ...(this.sessionOverrideEnabled === undefined ? {} : { enabled: this.sessionOverrideEnabled }),
+                main: {
+                    ...(this.sessionOverrideEnabled === undefined ? {} : { enabled: this.sessionOverrideEnabled }),
+                    ...(this.sessionModelOverride ?? {}),
+                },
+            };
+        this.configResult = this.resolveConfig(this.cwd, session === undefined ? undefined : { session });
+        if (this.configResult.config.maxWarnings !== this.guardMaxWarnings) {
+            this.guardMaxWarnings = this.configResult.config.maxWarnings;
+            this.guard = new WatchdogEmissionGuard({ maxWarnings: this.guardMaxWarnings });
+        }
+        if (wasEnabled && !this.isEnabled())
+            this.invalidateActiveReview("watchdog disabled");
+        return this.configResult;
+    }
+    setSessionEnabled(enabled, cwd = this.cwd) {
+        this.sessionOverrideEnabled = enabled;
+        this.reset("session override");
+        this.refreshConfig(cwd);
+        return this.getSnapshot();
+    }
+    setSessionModel(patch, cwd = this.cwd) {
+        const next = { ...(this.sessionModelOverride ?? {}) };
+        if (patch.model === null)
+            delete next.model;
+        else if (patch.model !== undefined)
+            next.model = patch.model;
+        if (patch.thinking === null)
+            delete next.thinking;
+        else if (patch.thinking !== undefined)
+            next.thinking = patch.thinking;
+        this.sessionModelOverride = next.model === undefined && next.thinking === undefined ? undefined : next;
+        this.reset("session model override");
+        this.refreshConfig(cwd);
+        return this.getSnapshot();
+    }
+    clearSessionModel(cwd = this.cwd) {
+        this.sessionModelOverride = undefined;
+        this.reset("session model override cleared");
+        this.refreshConfig(cwd);
+        return this.getSnapshot();
+    }
+    clearSessionOverride(cwd = this.cwd) {
+        this.sessionOverrideEnabled = undefined;
+        this.sessionModelOverride = undefined;
+        this.reset("session override cleared");
+        this.refreshConfig(cwd);
+        return this.getSnapshot();
+    }
+    reset(_reason = "reset", options = {}) {
+        this.abortActiveAgentEnd();
+        this.epoch++;
+        this.status = "idle";
+        this.clearPendingDeltas();
+        this.reviewing = false;
+        this.waitingAtAgentEnd = false;
+        this.activeReviewId = undefined;
+        this.activeReviewWarning = undefined;
+        this.includeUserPromptInNextDelta = false;
+        this.userPrompt = undefined;
+        this.lastError = undefined;
+        this.currentChangedPaths = undefined;
+        this.observedRepoEditThisTurn = false;
+        if (options.clearLspLedger) {
+            this.lspLedger.reset();
+            this.lastLspSnapshot = undefined;
+        }
+        if (options.clearReviewInputSignature)
+            this.lastReviewInputSignature = undefined;
+        if (options.resetChangeSignature)
+            this.resetRepoChangeBaseline({ reviewed: true });
+        this.guard.reset();
+        this.resolveWaiters(true);
+    }
+    dispose() {
+        this.disposed = true;
+        this.abortActiveAgentEnd();
+        this.epoch++;
+        this.status = "idle";
+        this.clearPendingDeltas();
+        this.reviewing = false;
+        this.waitingAtAgentEnd = false;
+        this.activeReviewId = undefined;
+        this.activeReviewWarning = undefined;
+        this.lastReviewInputSignature = undefined;
+        this.currentChangedPaths = undefined;
+        this.lastLspSnapshot = undefined;
+        this.lspLedger.reset();
+        this.observedRepoEditThisTurn = false;
+        this.resolveWaiters(false);
+    }
+    handleBeforeAgentStart(event, ctx) {
+        if (this.disposed)
+            return;
+        this.reset("before_agent_start");
+        this.refreshConfig(ctx.cwd);
+        this.userPrompt = promptFromBeforeAgentStart(event);
+        this.includeUserPromptInNextDelta = Boolean(this.userPrompt?.trim());
+        this.resetRepoChangeBaseline();
+    }
+    handleTurnEnd(event, ctx) {
+        if (this.disposed)
+            return;
+        this.refreshConfig(ctx.cwd);
+        if (!this.isEnabled())
+            return;
+        try {
+            this.observedRepoEditThisTurn ||= eventIndicatesRepoEdit(event);
+            const delta = formatWatchdogTurnDelta({
+                includeUserPrompt: this.includeUserPromptInNextDelta,
+                userPrompt: this.userPrompt,
+                events: [event],
+            });
+            this.includeUserPromptInNextDelta = false;
+            this.enqueueDelta(delta);
+        }
+        catch (error) {
+            this.fail(`Failed to format watchdog turn delta: ${errorMessage(error)}`);
+        }
+    }
+    enqueueDelta(delta) {
+        if (this.disposed || !delta.trim() || !this.isEnabled())
+            return;
+        this.appendBoundedDelta(delta);
+        if (!this.reviewing && !this.waitingAtAgentEnd)
+            this.status = "queued";
+    }
+    async handleAgentEnd(_event, ctx) {
+        if (this.disposed)
+            return;
+        this.refreshConfig(ctx.cwd);
+        if (!this.isEnabled())
+            return;
+        const changeSignature = this.resolveReviewChangeSignature(ctx.cwd);
+        if (this.reviewChangesOnly && !changeSignature) {
+            this.clearPendingDeltas();
+            if (this.status === "queued")
+                this.status = "idle";
+            this.resolveWaiters(true);
+            return;
+        }
+        if (changeSignature && changeSignature.key === this.lastReviewedChangeSignature) {
+            this.clearPendingDeltas();
+            this.status = "idle";
+            this.resolveWaiters(true);
+            return;
+        }
+        this.waitingAtAgentEnd = true;
+        const agentEndEpoch = this.epoch;
+        const agentEndId = ++this.agentEndIdCounter;
+        const lspAbortController = new AbortController();
+        this.activeAgentEndId = agentEndId;
+        this.activeAgentEndAbortController = lspAbortController;
+        try {
+            this.guard.startModelUpdate();
+            const lspBlock = await this.collectLspDiagnostics(changeSignature, {
+                epoch: agentEndEpoch,
+                agentEndId,
+                signal: lspAbortController.signal,
+            });
+            if (this.activeAgentEndAbortController === lspAbortController)
+                this.activeAgentEndAbortController = undefined;
+            if (!this.isAgentEndCurrent(agentEndEpoch, agentEndId))
+                return;
+            const delta = this.buildReviewInput(changeSignature, lspBlock);
+            this.clearPendingDeltas();
+            if (!delta.trim()) {
+                this.waitingAtAgentEnd = false;
+                if (this.status === "queued")
+                    this.status = "idle";
+                this.resolveWaiters(true);
+                return;
+            }
+            const signature = reviewInputSignature(delta);
+            if (!this.reviewChangesOnly && signature === this.lastReviewInputSignature) {
+                this.waitingAtAgentEnd = false;
+                this.status = "idle";
+                this.resolveWaiters(true);
+                return;
+            }
+            const outcome = await this.reviewDelta(delta, this.configResult.config.agentEndTimeoutMs);
+            this.waitingAtAgentEnd = false;
+            if (outcome === "timeout") {
+                this.staleReviews++;
+                this.invalidateActiveReview("agent-end timeout");
+                this.status = "stale";
+                this.markLastWarningStale();
+                this.resolveWaiters(true);
+                return;
+            }
+            if (outcome === "completed" && this.status !== "failed" && this.status !== "stale") {
+                this.lastReviewInputSignature = signature;
+                if (changeSignature)
+                    this.lastReviewedChangeSignature = changeSignature.key;
+                this.currentChangedPaths = changeSignature?.changedPaths;
+                this.status = "idle";
+            }
+            this.resolveWaiters(true);
+        }
+        finally {
+            if (this.activeAgentEndAbortController === lspAbortController)
+                this.activeAgentEndAbortController = undefined;
+            if (this.activeAgentEndId === agentEndId)
+                this.activeAgentEndId = undefined;
+        }
+    }
+    recordDisplayedWarning(warning) {
+        const details = normalizeWatchdogWarningDetails(warning, { state: "displayed", source: warning.source ?? "main" });
+        this.lastWarning = details;
+        return details;
+    }
+    getSnapshot(cwd) {
+        if (cwd)
+            this.refreshConfig(cwd);
+        return {
+            status: this.status,
+            enabled: this.isEnabled(),
+            config: this.configResult.config,
+            configOk: this.configResult.ok,
+            errors: [...this.configResult.errors],
+            sources: [...this.configResult.sources],
+            bufferedDeltas: this.pendingDeltas.length,
+            epoch: this.epoch,
+            ...(this.activeReviewId !== undefined ? { activeReviewId: this.activeReviewId } : {}),
+            ...(this.sessionOverrideEnabled !== undefined ? { sessionOverride: this.sessionOverrideEnabled } : {}),
+            ...(this.sessionModelOverride !== undefined ? { sessionModelOverride: { ...this.sessionModelOverride } } : {}),
+            ...(this.lastWarning ? { lastWarning: this.lastWarning } : {}),
+            ...(this.lastError ? { lastError: this.lastError } : {}),
+            failedReviews: this.failedReviews,
+            staleReviews: this.staleReviews,
+            reviewConnected: this.reviewConnected,
+            reviewDescription: this.reviewDescription,
+            autoFollowQueued: false,
+            reviewTrigger: this.reviewChangesOnly ? "repo-edits" : "turn-delta",
+            ...(this.currentChangedPaths?.length ? { changedPaths: [...this.currentChangedPaths] } : {}),
+            lsp: this.lspSnapshot(),
+        };
+    }
+    async waitForIdle(timeoutMs = 1_000) {
+        return this.waitForSettled(timeoutMs);
+    }
+    isEnabled() {
+        return this.configResult.ok && this.configResult.config.main.enabled;
+    }
+    abortActiveAgentEnd() {
+        this.activeAgentEndAbortController?.abort();
+        this.activeAgentEndAbortController = undefined;
+        this.activeAgentEndId = undefined;
+    }
+    isAgentEndCurrent(epoch, agentEndId) {
+        return !this.disposed && this.epoch === epoch && this.activeAgentEndId === agentEndId && this.waitingAtAgentEnd && this.isEnabled();
+    }
+    isCurrent(epoch, reviewId) {
+        return !this.disposed && this.epoch === epoch && this.activeReviewId === reviewId;
+    }
+    acceptWarning(epoch, reviewId, warning) {
+        if (!this.isCurrent(epoch, reviewId) || !this.isEnabled())
+            return false;
+        const decision = this.guard.evaluate(warning);
+        if (!decision.accepted)
+            return false;
+        const details = normalizeWatchdogWarningDetails(warning, {
+            state: "candidate",
+            source: warning.source ?? "main",
+            identity: decision.identity,
+        });
+        this.lastWarning = details;
+        this.activeReviewWarning = details;
+        return true;
+    }
+    displayBoundaryWarning(warning) {
+        if (!this.isEnabled())
+            return false;
+        const decision = this.guard.evaluate(warning);
+        if (!decision.accepted)
+            return false;
+        const details = normalizeWatchdogWarningDetails(warning, {
+            state: "displayed",
+            source: warning.source ?? "main",
+            identity: decision.identity,
+            displayedAt: new Date().toISOString(),
+        });
+        this.lastWarning = details;
+        this.displayWarning?.(details);
+        return true;
+    }
+    invalidateActiveReview(_reason) {
+        this.abortActiveAgentEnd();
+        this.epoch++;
+        this.status = "idle";
+        this.clearPendingDeltas();
+        this.reviewing = false;
+        this.waitingAtAgentEnd = false;
+        this.activeReviewId = undefined;
+        this.activeReviewWarning = undefined;
+    }
+    async reviewDelta(delta, timeoutMs) {
+        if (this.reviewing || this.disposed)
+            return "stale";
+        this.reviewing = true;
+        const reviewEpoch = this.epoch;
+        const reviewId = ++this.reviewIdCounter;
+        this.activeReviewId = reviewId;
+        this.activeReviewWarning = undefined;
+        this.status = "reviewing";
+        let timeout;
+        const abortController = new AbortController();
+        const reviewPromise = Promise.resolve().then(() => this.review({
+            delta,
+            epoch: reviewEpoch,
+            reviewId,
+            config: this.configResult.config,
+            signal: abortController.signal,
+            emitWarning: (warning) => this.acceptWarning(reviewEpoch, reviewId, warning),
+        }));
+        try {
+            const result = await Promise.race([
+                reviewPromise,
+                new Promise((resolve) => {
+                    timeout = setTimeout(() => resolve("timeout"), timeoutMs);
+                }),
+            ]);
+            if (result === "timeout") {
+                abortController.abort();
+                return "timeout";
+            }
+            if (!this.isCurrent(reviewEpoch, reviewId))
+                return "stale";
+            for (const warning of result?.warnings ?? [])
+                this.acceptWarning(reviewEpoch, reviewId, warning);
+            if (result?.stopReason && result.stopReason !== "stop") {
+                this.fail(`Watchdog review ended with stop reason '${result.stopReason}'.`);
+                return "completed";
+            }
+            this.displayAcceptedReviewWarning();
+            return "completed";
+        }
+        catch (error) {
+            if (this.isCurrent(reviewEpoch, reviewId)) {
+                this.fail(`Watchdog review failed: ${errorMessage(error)}`);
+                return "completed";
+            }
+            return "stale";
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            if (this.epoch === reviewEpoch && this.activeReviewId === reviewId) {
+                this.reviewing = false;
+                this.activeReviewId = undefined;
+                this.activeReviewWarning = undefined;
+            }
+            this.resolveWaiters(this.isSettled());
+        }
+    }
+    displayAcceptedReviewWarning() {
+        if (!this.activeReviewWarning)
+            return;
+        const details = {
+            ...this.activeReviewWarning,
+            state: "displayed",
+            displayedAt: new Date().toISOString(),
+        };
+        this.lastWarning = details;
+        this.displayWarning?.(details);
+    }
+    currentRepoChangeSignature(cwd = this.cwd) {
+        return this.reviewChangesOnly ? computeWatchdogRepoChangeSignature(cwd) : undefined;
+    }
+    resetRepoChangeBaseline(options = {}) {
+        this.turnStartChangeSignature = this.currentRepoChangeSignature(options.cwd ?? this.cwd);
+        if (options.reviewed)
+            this.lastReviewedChangeSignature = this.turnStartChangeSignature?.key;
+        else
+            this.lastReviewedChangeSignature ??= this.turnStartChangeSignature?.key;
+        this.currentChangedPaths = this.turnStartChangeSignature?.changedPaths;
+        this.observedRepoEditThisTurn = false;
+    }
+    resolveReviewChangeSignature(cwd = this.cwd) {
+        if (!this.reviewChangesOnly)
+            return undefined;
+        const current = this.currentRepoChangeSignature(cwd);
+        if (current) {
+            this.currentChangedPaths = current.changedPaths;
+            if (current.key === this.turnStartChangeSignature?.key)
+                return undefined;
+            if (current.changedPaths.length === 0)
+                return undefined;
+            return current;
+        }
+        return this.observedRepoEditThisTurn
+            ? { root: cwd, key: `observed-edit:${this.epoch}:${this.reviewIdCounter}:${this.pendingDeltaChars}`, changedPaths: [] }
+            : undefined;
+    }
+    async collectLspDiagnostics(changeSignature, current) {
+        const config = this.configResult.config.lsp;
+        if (!config.enabled || !changeSignature?.changedPaths.length) {
+            this.lastLspSnapshot = {
+                enabled: config.enabled,
+                status: config.enabled ? "skipped" : "disabled",
+                checkedPaths: [],
+                skippedPaths: [],
+                diagnostics: [],
+                diagnosticCount: 0,
+                freshDiagnosticCount: 0,
+                updatedAt: new Date().toISOString(),
+            };
+            return "";
+        }
+        try {
+            const raw = await this.lspDiagnostics({
+                cwd: this.cwd,
+                root: changeSignature.root,
+                changedPaths: changeSignature.changedPaths,
+                config,
+                signal: current.signal,
+            });
+            if (!this.isAgentEndCurrent(current.epoch, current.agentEndId))
+                return "";
+            const diagnosticCount = raw.diagnostics.length;
+            const fresh = this.lspLedger.reduce(raw);
+            this.lastLspSnapshot = {
+                ...fresh,
+                enabled: true,
+                diagnosticCount,
+                freshDiagnosticCount: fresh.diagnostics.length,
+                updatedAt: new Date().toISOString(),
+            };
+            const warning = watchdogWarningFromLspDiagnostics(fresh);
+            if (warning)
+                this.displayBoundaryWarning(warning);
+            return formatWatchdogLspDiagnosticsBlock(fresh);
+        }
+        catch (error) {
+            if (!this.isAgentEndCurrent(current.epoch, current.agentEndId))
+                return "";
+            this.lastLspSnapshot = {
+                enabled: true,
+                status: "failed",
+                checkedPaths: [],
+                skippedPaths: changeSignature.changedPaths,
+                diagnostics: [],
+                diagnosticCount: 0,
+                freshDiagnosticCount: 0,
+                message: `LSP diagnostics failed: ${errorMessage(error)}`,
+                updatedAt: new Date().toISOString(),
+            };
+            return "";
+        }
+    }
+    lspSnapshot() {
+        if (this.lastLspSnapshot)
+            return {
+                ...this.lastLspSnapshot,
+                checkedPaths: [...this.lastLspSnapshot.checkedPaths],
+                skippedPaths: [...this.lastLspSnapshot.skippedPaths],
+                diagnostics: [...this.lastLspSnapshot.diagnostics],
+            };
+        const enabled = this.isEnabled() && this.configResult.config.lsp.enabled;
+        return {
+            enabled,
+            status: enabled ? "skipped" : "disabled",
+            checkedPaths: [],
+            skippedPaths: [],
+            diagnostics: [],
+            diagnosticCount: 0,
+            freshDiagnosticCount: 0,
+        };
+    }
+    appendBoundedDelta(delta) {
+        let entry = delta.trim();
+        if (!entry)
+            return;
+        if (entry.length > MAX_REVIEW_INPUT_CHARS)
+            entry = entry.slice(-MAX_REVIEW_INPUT_CHARS);
+        this.pendingDeltas.push(entry);
+        this.pendingDeltaChars += entry.length;
+        while (this.pendingDeltas.length > 1 && this.pendingDeltaChars + (this.pendingDeltas.length - 1) * REVIEW_DELTA_SEPARATOR.length > MAX_REVIEW_INPUT_CHARS) {
+            const removed = this.pendingDeltas.shift();
+            if (removed)
+                this.pendingDeltaChars -= removed.length;
+        }
+    }
+    buildReviewInput(changeSignature, lspBlock = "") {
+        const input = this.pendingDeltas.join(REVIEW_DELTA_SEPARATOR);
+        const changes = changeSignature?.changedPaths.length
+            ? ["Changed repo paths:", ...changeSignature.changedPaths.slice(0, 200).map((file) => `- ${file}`)].join("\n")
+            : "";
+        const contextPieces = [changes, lspBlock].filter(Boolean);
+        if (!contextPieces.length)
+            return input.length > MAX_REVIEW_INPUT_CHARS ? input.slice(-MAX_REVIEW_INPUT_CHARS) : input;
+        const maxContextLength = Math.floor(MAX_REVIEW_INPUT_CHARS / 2);
+        const maxPieceLength = Math.max(1_000, Math.floor(maxContextLength / contextPieces.length));
+        const boundedContext = contextPieces.map((piece) => piece.length > maxPieceLength
+            ? `${piece.slice(0, maxPieceLength - 6)}\n- ...`
+            : piece).join(REVIEW_DELTA_SEPARATOR);
+        const separatorLength = input ? REVIEW_DELTA_SEPARATOR.length : 0;
+        const inputBudget = MAX_REVIEW_INPUT_CHARS - boundedContext.length - separatorLength;
+        const boundedInput = inputBudget <= 0
+            ? ""
+            : input.length > inputBudget
+                ? input.slice(-inputBudget)
+                : input;
+        return [boundedContext, boundedInput].filter(Boolean).join(REVIEW_DELTA_SEPARATOR);
+    }
+    clearPendingDeltas() {
+        this.pendingDeltas = [];
+        this.pendingDeltaChars = 0;
+    }
+    fail(message) {
+        this.failedReviews++;
+        this.lastError = message;
+        this.status = "failed";
+        this.clearPendingDeltas();
+        this.resolveWaiters(true);
+    }
+    markLastWarningStale() {
+        if (!this.lastWarning || this.lastWarning.state === "displayed")
+            return;
+        this.lastWarning = { ...this.lastWarning, stale: true, state: "stale" };
+    }
+    isSettled() {
+        return !this.reviewing && this.pendingDeltas.length === 0;
+    }
+    waitForSettled(timeoutMs) {
+        if (this.isSettled())
+            return Promise.resolve(true);
+        return new Promise((resolve) => {
+            const waiter = {
+                resolve,
+                timer: setTimeout(() => {
+                    this.waiters = this.waiters.filter((entry) => entry !== waiter);
+                    resolve(false);
+                }, timeoutMs),
+            };
+            this.waiters.push(waiter);
+        });
+    }
+    resolveWaiters(settled) {
+        if (!settled && !this.disposed)
+            return;
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const waiter of waiters) {
+            clearTimeout(waiter.timer);
+            waiter.resolve(settled);
+        }
+    }
+}
+//# sourceMappingURL=runtime.js.map