letagents 0.12.11 → 0.12.13

package/dist/mcp/server/tools/rooms/inspection-tools.js

@@ -3,8 +3,10 @@ import { join } from "path";
 import { z } from "zod";
 import { getRoomFromConfig } from "../../../config-reader.js";
 import { buildActiveGitRoomContext, getGitCurrentBranch, getGitDefaultBranch, getGitRoomContext, } from "../../../git-remote.js";
-import { currentAgentIdentity, currentAgentIdentityKey, currentRoom, getConversationIdentity, getCurrentLiveSessionPayload, getStoredAgentIdentity, listStoredCodexLiveSessions, toPublicAgentIdentity, toPublicRoomState, withJoinRoomAgentPrompt, } from "../../runtime.js";
+import { currentAgentIdentity, currentAgentIdentityKey, currentRoomMatchesLocator, currentRoom, getConversationIdentity, getCurrentLiveSessionPayload, getStoredAgentIdentity, listStoredCodexLiveSessions, toPublicAgentIdentity, toPublicCurrentRoomState, withJoinRoomAgentPrompt, } from "../../runtime.js";
 import { requireValidWorkerBearerRuntime } from "../../runtime/worker-bearer.js";
+import { getDaemonToolExecutionContext, getRuntimeWorkingDirectory } from "../../runtime/daemon-tool-context.js";
+import { identityFromAgentSession } from "../../runtime/agent-sessions.js";
 import { findExistingConfig, resolveGitRoot, } from "../../repo-context.js";
 import { jsonToolResponse } from "./response.js";
 let ownerAuthStoreLoader = () => import("../../../local-state.js");
@@ -29,16 +31,18 @@ export function registerRoomInspectionTools(server) {
 }
 export async function getCurrentRoomPayload(conversationId) {
     const runtime = requireValidWorkerBearerRuntime();
-    const workerAuth = runtime.mode === "worker"
-        ? { source: "worker_bearer", expires_at: null, account: null }
+    const daemonContext = getDaemonToolExecutionContext();
+    const publicCurrentRoom = toPublicCurrentRoomState();
+    const workerAuth = runtime.mode !== "owner"
+        ? { source: runtime.mode === "worker" ? "worker_bearer" : "daemon_supervised", expires_at: null, account: null }
         : null;
-    const localCodexDetails = runtime.mode === "worker"
+    const localCodexDetails = runtime.mode !== "owner"
         ? { current_local_codex_session: null, local_codex_session_count: 0 }
         : {
             current_local_codex_session: getCurrentLiveSessionPayload(currentRoom?.room_id),
             local_codex_session_count: listStoredCodexLiveSessions().length,
         };
-    if (!currentRoom) {
+    if (!publicCurrentRoom) {
         return {
             connected: false,
             message: "Not currently in any room",
@@ -46,16 +50,19 @@ export async function getCurrentRoomPayload(conversationId) {
             ...(workerAuth ? { auth: workerAuth } : {}),
         };
     }
-    const auth = runtime.mode === "worker"
+    const auth = runtime.mode !== "owner"
         ? null
         : (await ownerAuthStoreLoader()).getStoredAuth();
-    return withJoinRoomAgentPrompt({
+    const payload = {
         connected: true,
-        ...toPublicRoomState(currentRoom),
+        ...publicCurrentRoom,
+        ...(runtime.mode === "supervised" ? { room_binding: "daemon_supervised" } : {}),
         ...localCodexDetails,
-        agent_identity: toPublicAgentIdentity(getConversationIdentity(conversationId)
-            ?? currentAgentIdentity
-            ?? getStoredAgentIdentity(currentAgentIdentityKey)),
+        agent_identity: toPublicAgentIdentity(daemonContext
+            ? identityFromAgentSession(daemonContext.agentSession)
+            : getConversationIdentity(conversationId)
+                ?? currentAgentIdentity
+                ?? getStoredAgentIdentity(currentAgentIdentityKey)),
         auth: workerAuth ?? (auth
             ? {
                 source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
@@ -63,10 +70,15 @@ export async function getCurrentRoomPayload(conversationId) {
                 account: auth.account ?? null,
             }
             : null),
-    });
+    };
+    // A daemon-supervised worker is already bound to its exact authorized room.
+    // A normal join prompt is both false and dangerous here because it can lead
+    // the provider to request an unrelated room move.
+    return runtime.mode === "supervised" ? payload : withJoinRoomAgentPrompt(payload);
 }
 function getRepoInspectionPayload(targetDir) {
-    const startDir = targetDir || process.cwd();
+    const runtime = requireValidWorkerBearerRuntime();
+    const startDir = targetDir || getRuntimeWorkingDirectory();
     const repoRoot = resolveGitRoot(startDir);
     const configDir = repoRoot ? findExistingConfig(startDir) : null;
     const configPath = configDir ? join(configDir, ".letagents.json") : null;
@@ -79,8 +91,8 @@ function getRepoInspectionPayload(targetDir) {
             defaultBranch: repoRoot ? getGitDefaultBranch(repoRoot) : null,
         })
         : null;
-    const detectedRoom = configGitContext?.activeRoom ?? gitContext?.activeRoom ?? null;
-    const currentRoomMatchesContext = Boolean(currentRoom && detectedRoom && currentRoom.room_id === detectedRoom);
+    const detectedRoom = configGitContext?.activeRoomLocator ?? gitContext?.activeRoomLocator ?? null;
+    const currentRoomMatchesContext = currentRoomMatchesLocator(detectedRoom);
     return {
         cwd: startDir,
         repo_context_status: repoRoot ? "git_repo_detected" : "not_inside_git_repo",
@@ -88,17 +100,23 @@ function getRepoInspectionPayload(targetDir) {
         config_file: configPath ?? null,
         config_contents: readConfigContents(configPath),
         configured_room_from_file: configuredRoom ?? null,
-        configured_active_room_from_context: configGitContext?.activeRoom ?? null,
-        derived_room_from_git: gitContext?.activeRoom ?? null,
+        configured_active_room_from_context: configGitContext?.activeRoomLocator ?? null,
+        derived_room_from_git: gitContext?.activeRoomLocator ?? null,
         derived_repo_room_from_git: gitContext?.repoRoom ?? null,
-        derived_branch_room_from_git: gitContext?.activeRefRoom ?? null,
+        derived_branch_room_from_git: gitContext?.activeRefRoomLocator ?? null,
         git_current_branch: gitContext?.currentBranch ?? configGitContext?.currentBranch ?? null,
         git_default_branch: gitContext?.defaultBranch ?? configGitContext?.defaultBranch ?? null,
         detected_room_from_context: detectedRoom ?? null,
-        current_room: toPublicRoomState(currentRoom),
-        current_room_scope: currentRoomScope(currentRoomMatchesContext, detectedRoom),
-        warning: repoWarning({ repoRoot, detectedRoom, currentRoomMatchesContext }),
-        join_hint: joinHint({ repoRoot, detectedRoom, currentRoomMatchesContext }),
+        current_room: toPublicCurrentRoomState(),
+        current_room_scope: runtime.mode === "supervised"
+            ? "daemon_supervised_exact_room"
+            : currentRoomScope(currentRoomMatchesContext, detectedRoom),
+        warning: runtime.mode === "supervised"
+            ? null
+            : repoWarning({ repoRoot, detectedRoom, currentRoomMatchesContext }),
+        join_hint: runtime.mode === "supervised"
+            ? null
+            : joinHint({ repoRoot, detectedRoom, currentRoomMatchesContext }),
     };
 }
 function readConfigContents(configPath) {

package/dist/mcp/server/tools/rooms/repo-initialization-tool.js

@@ -5,6 +5,7 @@ import { getGitRemoteIdentity } from "../../../git-remote.js";
 import { joinRoomIdentifier, } from "../../runtime.js";
 import { findExistingConfig, resolveGitRoot, } from "../../repo-context.js";
 import { jsonToolResponse } from "./response.js";
+import { getRuntimeWorkingDirectory } from "../../runtime/daemon-tool-context.js";
 export function registerRepoInitializationTool(server) {
     server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat by creating a .letagents.json config file. " +
         "This explicitly sets up repo-based room auto-join. Reads git remote to derive the room name, " +
@@ -19,7 +20,7 @@ export function registerRepoInitializationTool(server) {
             .optional()
             .describe("Working directory hint for repo detection. Defaults to the current process directory."),
     }, async ({ room, cwd: targetDir }) => {
-        const startDir = targetDir || process.cwd();
+        const startDir = targetDir || getRuntimeWorkingDirectory();
         const repoRoot = resolveGitRoot(startDir);
         if (!repoRoot) {
             return jsonToolResponse({

package/dist/mcp/server/tools/supervised-room-turn.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+const MAX_ROOM_REPLY_BYTES = 32 * 1024;
+function completionResponse(outcome) {
+    const payload = {
+        accepted: true,
+        outcome,
+        instruction: "The daemon recorded this exact turn completion. End the provider turn without sending the activating reply through another tool.",
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+/**
+ * Cursor's documented terminal `result` is the concatenation of every
+ * assistant delta, including progress narration. A supervised provider must
+ * therefore propose its public reply over a distinct, turn-scoped channel.
+ *
+ * This tool is registered only for `supervised_room_turn`. The normal
+ * supervised tool facade binds it to the exact provider turn and commits its
+ * request/result through the durable bounded-effect journal before the daemon
+ * will consider it publishable.
+ */
+export function registerSupervisedRoomTurnTools(server) {
+    server.tool("complete_room_turn", "Record the single public completion for this supervised room turn. Call exactly once after all work is finished. Progress text outside this tool is live activity only and is never published as the room reply.", {
+        outcome: z.enum(["reply", "no_reply"]).describe("Use reply to publish one answer, or no_reply when the activating message needs no response."),
+        text: z.string().optional().describe("The concise public room reply. Required only when outcome is reply."),
+    }, async ({ outcome, text }) => {
+        const normalized = text?.trim() ?? "";
+        if (outcome === "reply") {
+            if (!normalized)
+                throw new Error("complete_room_turn requires non-empty text when outcome is reply.");
+            if (Buffer.byteLength(normalized, "utf8") > MAX_ROOM_REPLY_BYTES) {
+                throw new Error("complete_room_turn reply exceeds the 32 KiB public-message limit.");
+            }
+        }
+        else if (normalized) {
+            throw new Error("complete_room_turn must omit text when outcome is no_reply.");
+        }
+        return completionResponse(outcome);
+    });
+}

package/dist/mcp/server/tools/tasks/board-tools.js

@@ -4,6 +4,34 @@ import { createTask, listTasks } from "./api.js";
 import { resolveTaskToolIdentity, resolveTaskToolTarget, taskActorPayload, } from "./context.js";
 import { jsonToolResponse, taskToolError } from "./response.js";
 import { boardIntentApprovalSchema, TASK_STATUSES, workerTaskIdentitySchema } from "./schemas.js";
+export const MAX_BOARD_WORKFLOW_ARTIFACTS_PER_TASK = 4;
+export const MAX_BOARD_WORKFLOW_REFS_PER_TASK = 4;
+function compactBoardWorkflowArtifact(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const artifact = value;
+    // A change-summary detail may itself contain hundreds of files. The board is
+    // an index; callers that need complete artifact detail use get_room_artifacts.
+    return Object.fromEntries(Object.entries(artifact).filter(([key]) => key !== "detail"));
+}
+export function compactTaskForBoard(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const task = value;
+    const artifacts = Array.isArray(task.workflow_artifacts) ? task.workflow_artifacts : [];
+    const refs = Array.isArray(task.workflow_refs) ? task.workflow_refs : [];
+    return {
+        ...task,
+        workflow_artifacts: artifacts
+            .slice(-MAX_BOARD_WORKFLOW_ARTIFACTS_PER_TASK)
+            .map(compactBoardWorkflowArtifact),
+        workflow_refs: refs.slice(-MAX_BOARD_WORKFLOW_REFS_PER_TASK),
+        workflow_artifact_count: artifacts.length,
+        workflow_ref_count: refs.length,
+        workflow_artifacts_truncated: artifacts.length > MAX_BOARD_WORKFLOW_ARTIFACTS_PER_TASK,
+        workflow_refs_truncated: refs.length > MAX_BOARD_WORKFLOW_REFS_PER_TASK,
+    };
+}
 export function registerTaskBoardTools(server) {
     server.tool("add_task", "Add a new task to the room board. Tasks normally start as 'proposed' and must be " +
         "accepted before an agent can claim them. Agent-created tasks require coordinator " +
@@ -59,7 +87,7 @@ export function registerTaskBoardTools(server) {
             const qs = pageParams.toString();
             const result = await listTasks(target, qs);
             const tasks = result.tasks ?? [];
-            allTasks.push(...tasks);
+            allTasks.push(...tasks.map(compactTaskForBoard));
             if (!result.has_more || tasks.length === 0)
                 break;
             const lastTask = tasks[tasks.length - 1];
@@ -68,6 +96,10 @@ export function registerTaskBoardTools(server) {
             afterCursor = lastTask.id;
         }
         await heartbeatRoomPresence(target.effectiveRoomId, await ensureAgentIdentity());
-        return jsonToolResponse({ success: true, tasks: allTasks }, 2);
+        return jsonToolResponse({
+            success: true,
+            tasks: allTasks,
+            artifact_detail_instruction: "Board tasks contain bounded artifact summaries. Use get_room_artifacts for complete workflow artifact detail.",
+        }, 2);
     });
 }

package/dist/mcp/server.js

@@ -5,14 +5,21 @@ import { registerRoomResources } from "./server/resources.js";
 import { registerTools } from "./server/register-tools.js";
 import { attachMcpServer, autoJoinFromContext, shutdownRuntime } from "./server/runtime.js";
 import { requireValidWorkerBearerRuntime } from "./server/runtime/worker-bearer.js";
-const server = new McpServer({
-    name: "letagents",
-    version: "0.2.0",
-});
-attachMcpServer(server);
-registerRoomResources(server);
-registerTools(server);
+import { executionProfile } from "./server/runtime/execution-profile.js";
+import { LETAGENTS_RUNTIME_CONTRACT_ARG, letAgentsRuntimeContract, } from "./server/runtime-contract.js";
 async function main() {
+    if (process.argv.slice(2).includes(LETAGENTS_RUNTIME_CONTRACT_ARG)) {
+        process.stdout.write(`${JSON.stringify(letAgentsRuntimeContract())}\n`);
+        return;
+    }
+    const server = new McpServer({
+        name: "letagents",
+        version: "0.2.0",
+    });
+    attachMcpServer(server);
+    registerRoomResources(server);
+    const profile = executionProfile();
+    registerTools(server, profile);
     requireValidWorkerBearerRuntime();
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/mcp/sse-client.js

@@ -1,19 +1,33 @@
 import { encodeRoomIdPath } from "./room-id.js";
+const MAX_SSE_FRAME_BYTES = 1024 * 1024;
+class SseFrameOverflowError extends Error {
+    constructor() {
+        super("SSE frame exceeded bounded size");
+        this.name = "SseFrameOverflowError";
+    }
+}
+class SseFrameMalformedError extends Error {
+    constructor(options) {
+        super("SSE frame was malformed", options);
+        this.name = "SseFrameMalformedError";
+    }
+}
 export class SseClient {
     apiUrl;
     getAccessToken;
     subscriptions = new Map();
+    eventCursors = new Map();
     constructor(apiUrl, getAccessToken) {
         this.apiUrl = apiUrl.replace(/\/$/, "");
         this.getAccessToken = getAccessToken;
     }
-    subscribe(target, onMessage) {
+    subscribe(target, onMessage, onGap) {
         const subscriptionKey = target.roomId;
         if (this.subscriptions.has(subscriptionKey)) {
             return;
         }
         const controller = new AbortController();
-        const promise = this.consumeStream(target, controller.signal, onMessage)
+        const promise = this.consumeStream(target, controller.signal, onMessage, onGap)
             .catch((error) => {
             if (controller.signal.aborted) {
                 return;
@@ -51,17 +65,41 @@ export class SseClient {
             Authorization: `Bearer ${token}`,
         };
     }
-    async consumeStream(target, signal, onMessage) {
-        try {
-            await this.openStream(this.withIncludePromptOnly(this.withAgentIdentityQuery(`${this.apiUrl}/rooms/${encodeRoomIdPath(target.roomId)}/messages/stream`, target)), signal, onMessage);
-            return;
-        }
-        catch (error) {
-            if (!target.projectId || !this.isMissingRouteError(error)) {
-                throw error;
+    async consumeStream(target, signal, onMessage, onGap) {
+        let lastEventId = this.eventCursors.get(target.roomId) ?? null;
+        let useLegacyRoute = false;
+        let retryMs = 1_000;
+        while (!signal.aborted) {
+            const baseUrl = useLegacyRoute && target.projectId
+                ? `${this.apiUrl}/projects/${encodeURIComponent(target.projectId)}/messages/stream`
+                : `${this.apiUrl}/rooms/${encodeRoomIdPath(target.roomId)}/messages/stream`;
+            const url = this.withIncludePromptOnly(this.withAgentIdentityQuery(baseUrl, target));
+            try {
+                lastEventId = await this.openStream(url, signal, target.roomId, lastEventId, onMessage, onGap);
+                retryMs = 1_000;
             }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                if (error instanceof SseFrameOverflowError || error instanceof SseFrameMalformedError) {
+                    lastEventId = null;
+                }
+                if (this.isMissingRouteError(error)) {
+                    if (!useLegacyRoute && target.projectId) {
+                        useLegacyRoute = true;
+                        continue;
+                    }
+                    // A missing room/route is terminal. Retrying it forever creates
+                    // background traffic and can never heal without a new room join.
+                    throw error;
+                }
+                console.error(`SSE stream disconnected for room ${target.roomId}:`, error);
+            }
+            if (signal.aborted)
+                return;
+            await waitForRetry(signal, retryMs);
+            retryMs = Math.min(Math.ceil(retryMs * 1.5), 30_000);
         }
-        await this.openStream(this.withIncludePromptOnly(this.withAgentIdentityQuery(`${this.apiUrl}/projects/${encodeURIComponent(target.projectId)}/messages/stream`, target)), signal, onMessage);
     }
     withIncludePromptOnly(url) {
         return `${url}${url.includes("?") ? "&" : "?"}include_prompt_only=1`;
@@ -80,9 +118,14 @@ export class SseClient {
         }
         return `${url}${url.includes("?") ? "&" : "?"}${params.toString()}`;
     }
-    async openStream(url, signal, onMessage) {
+    async openStream(url, signal, roomId, lastEventId, onMessage, onGap) {
+        const headers = await this.getHeaders();
+        if (signal.aborted)
+            return lastEventId;
+        if (lastEventId)
+            headers["Last-Event-ID"] = lastEventId;
         const response = await fetch(url, {
-            headers: await this.getHeaders(),
+            headers,
             signal,
         });
         if (!response.ok) {
@@ -94,43 +137,143 @@ export class SseClient {
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
+        let bufferBytes = 0;
         while (!signal.aborted) {
             const { value, done } = await reader.read();
             if (done) {
                 break;
             }
             buffer += decoder.decode(value, { stream: true });
+            bufferBytes += value.byteLength;
+            if (bufferBytes > MAX_SSE_FRAME_BYTES) {
+                // The cursor is no longer safe: an unterminated/oversize frame may
+                // contain an event we could not parse. Force pull-state repair before
+                // reconnecting and never retain attacker-controlled remainder bytes.
+                this.eventCursors.delete(roomId);
+                try {
+                    onGap?.({ room_id: roomId, event_cursor: null, gap: true });
+                }
+                catch (error) {
+                    console.error("SSE gap callback failed:", error);
+                }
+                await reader.cancel("SSE frame exceeded bounded size").catch(() => undefined);
+                throw new SseFrameOverflowError();
+            }
             let boundaryIndex = buffer.indexOf("\n\n");
+            let consumedFrame = false;
             while (boundaryIndex !== -1) {
                 const rawEvent = buffer.slice(0, boundaryIndex);
                 buffer = buffer.slice(boundaryIndex + 2);
-                this.handleEvent(rawEvent, onMessage);
+                try {
+                    lastEventId = this.handleEvent(rawEvent, lastEventId, onMessage, onGap);
+                }
+                catch (error) {
+                    // A complete but malformed typed frame is the same lost-boundary
+                    // condition as an oversized frame. Never reconnect from its cursor
+                    // and replay it forever; force the authorized pull-state repair.
+                    this.eventCursors.delete(roomId);
+                    try {
+                        onGap?.({ room_id: roomId, event_cursor: null, gap: true });
+                    }
+                    catch (gapError) {
+                        console.error("SSE gap callback failed:", gapError);
+                    }
+                    await reader.cancel("SSE frame was malformed").catch(() => undefined);
+                    throw new SseFrameMalformedError({ cause: error });
+                }
+                this.rememberEventCursor(roomId, lastEventId);
+                consumedFrame = true;
                 boundaryIndex = buffer.indexOf("\n\n");
             }
+            if (consumedFrame)
+                bufferBytes = new TextEncoder().encode(buffer).byteLength;
         }
         const trailing = buffer + decoder.decode();
         if (trailing.trim()) {
-            this.handleEvent(trailing, onMessage);
+            try {
+                lastEventId = this.handleEvent(trailing, lastEventId, onMessage, onGap);
+            }
+            catch (error) {
+                this.eventCursors.delete(roomId);
+                try {
+                    onGap?.({ room_id: roomId, event_cursor: null, gap: true });
+                }
+                catch (gapError) {
+                    console.error("SSE gap callback failed:", gapError);
+                }
+                throw new SseFrameMalformedError({ cause: error });
+            }
+            this.rememberEventCursor(roomId, lastEventId);
         }
+        return lastEventId;
     }
-    handleEvent(rawEvent, onMessage) {
+    handleEvent(rawEvent, lastEventId, onMessage, onGap) {
         const normalizedEvent = rawEvent.replace(/\r/g, "");
-        const dataLines = normalizedEvent
-            .split("\n")
+        const lines = normalizedEvent.split("\n");
+        const eventName = lines.find((line) => line.startsWith("event:"))?.slice(6).trim() || "message";
+        const frameId = lines.find((line) => line.startsWith("id:"))?.slice(3).trim() || null;
+        const dataLines = lines
             .filter((line) => line.startsWith("data:"))
             .map((line) => line.slice(5).trimStart());
         if (dataLines.length === 0) {
-            return;
+            return frameId ?? lastEventId;
         }
         // No prompt enrichment here: the only SSE subscriber (room-state.ts) discards
         // the message body, and expanding the room-agent prompt on this background
         // path would consume the once-per-session full-prompt delivery before the
         // agent ever sees it. Prompt expansion happens only on visible tool
         // responses (runtime/messages.ts).
-        onMessage(JSON.parse(dataLines.join("\n")));
+        const payload = JSON.parse(dataLines.join("\n"));
+        if (eventName === "room_sync") {
+            if (payload.gap === true) {
+                try {
+                    onGap?.(payload);
+                }
+                catch (error) {
+                    console.error("SSE gap callback failed:", error);
+                }
+            }
+            if (Object.prototype.hasOwnProperty.call(payload, "event_cursor")) {
+                return typeof payload.event_cursor === "string" ? payload.event_cursor : null;
+            }
+            return frameId ?? lastEventId;
+        }
+        try {
+            onMessage(payload);
+        }
+        catch (error) {
+            console.error("SSE message callback failed:", error);
+        }
+        return frameId ?? lastEventId;
     }
     isMissingRouteError(error) {
         return (error instanceof Error &&
             /status 404|status 405|Cannot (GET|POST|PATCH)/.test(error.message));
     }
+    rememberEventCursor(roomId, cursor) {
+        this.eventCursors.delete(roomId);
+        if (!cursor)
+            return;
+        this.eventCursors.set(roomId, cursor);
+        while (this.eventCursors.size > 32) {
+            const oldestRoomId = this.eventCursors.keys().next().value;
+            if (!oldestRoomId)
+                break;
+            this.eventCursors.delete(oldestRoomId);
+        }
+    }
+}
+function waitForRetry(signal, delayMs) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(finish, delayMs);
+        timer.unref?.();
+        function finish() {
+            signal.removeEventListener("abort", finish);
+            clearTimeout(timer);
+            resolve();
+        }
+        signal.addEventListener("abort", finish, { once: true });
+    });
 }