cursor-opencode-provider 0.2.7 → 0.2.8

package/README.md

@@ -47,7 +47,7 @@ Add the package name to OpenCode config. OpenCode installs npm plugins with Bun
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.2.6"`.
+Pin a version if you want: `"cursor-opencode-provider@0.2.8"`.
 
 ### From a local clone
 
@@ -109,10 +109,13 @@ After login, the plugin fetches your available models and writes them to `<host-
 Model/version caches and Cursor project metadata live under a **host cache root**, resolved in this order:
 
 1. Explicit `createCursor({ cacheDir })` / Effect v2 `Path.cache`
-2. Optional `@opencode-compat/profile` `detect()` when that peer is installed and the host is supported
-3. Local heuristic: `$MIMOCODE_HOME/cache`, then host-named dirs under `$XDG_CACHE_HOME` (Kilo, then MiMo, then OpenCode)
+2. Optional `@opencode-compat/profile` `detect()` when it reports strong environment, binary, or package identity
+3. Explicit `$MIMOCODE_HOME` / `KILO_CONFIG_DIR`, then the provider's host-named install path under `$XDG_CACHE_HOME`
 4. Default `~/.cache/opencode/`
 
+Config-directory presence is deliberately ignored: having MiMo or Kilo installed
+must not redirect a native OpenCode process into that host's cache.
+
 | Kind | Default (OpenCode) | Notes |
 |------|--------------------|-------|
 | Model / version **cache** | `~/.cache/opencode/` | MiMo: `$MIMOCODE_HOME/cache` or `~/.cache/mimocode/`; Kilo: `~/.cache/kilo/` |
@@ -187,7 +190,7 @@ Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `sk-
 | `CURSOR_PROVIDER_DEBUG_FILE` | Debug log path (default: `debug-<pid>.log` under `$TMPDIR/cursor-provider-logs-<uid>/`) |
 | `XDG_CACHE_HOME` | Base for host cache dirs (`$XDG_CACHE_HOME/opencode/`, `…/mimocode/`, or `…/kilo/`) when no explicit `cacheDir` / OCP detect override |
 | `MIMOCODE_HOME` | When set, host cache is `$MIMOCODE_HOME/cache` (MiMo) |
-| `KILO_CONFIG_DIR` | When set (or `~/.config/kilo` exists), host cache is `$XDG_CACHE_HOME/kilo` |
+| `KILO_CONFIG_DIR` | When set, host cache is `$XDG_CACHE_HOME/kilo` |
 | `XDG_DATA_HOME` | When set, OpenCode `auth.json` is read from `$XDG_DATA_HOME/opencode/` instead of `~/.local/share/opencode/` |
 
 `createCursor({ agentBaseURL })` overrides the agent Run host. When unset, the provider resolves the host from Cursor's `GetServerConfig` API (`agentUrlConfig.agentnUrl`, region-specific — e.g. `agentn.us.api5.cursor.sh`, `agent-gcpp-uswest.api5.cursor.sh`) once per process and holds it in memory (never written to disk), so a held-open Run stream is never repointed mid-session. Explicit agent overrides and GetServerConfig results are validated as HTTPS `*.cursor.sh` hosts (Cursor's agent hostnames vary and may change); non-`cursor.sh` hosts are rejected. Shared HTTP/2 connections are rotated before they become server-aged, while existing Runs may finish on their original connection. The lookup sends `{ "telem_enabled": false }` by default; set `telemetryEnabled: true` in provider config, or `CURSOR_GET_SERVER_CONFIG_TELEMETRY=1` for OpenCode/plugin usage, to opt in. If the lookup fails or does not return a valid Cursor agent host, the model call fails clearly instead of falling back to `agentn.global.api5.cursor.sh`.
@@ -271,8 +274,9 @@ Project `instructions` may reference absolute or `~/` paths (OpenCode parity). S
 - **Configured MCP tools keep their upstream server id** — OpenCode builtins and plugin/custom tools are advertised under a synthetic `opencode` MCP server. Tools whose flattened name matches an MCP server in merged `opencode.json` configuration (`github_create_pull_request`, …) are grouped into that server's `mcp_descriptors` / `provider_identifier` (`github`, …). Unknown underscore-containing names stay under `opencode` rather than being guessed incorrectly. Cursor's MCP-state exec probe is answered from the same advertised descriptors before the actual tool request, using the full canonical tool-definition identity required by native `get_mcp_tools`; exec still reconstructs the full OpenCode tool id.
 - **Display completions are notifications, not execution requests** — Cursor `tool_call_*` frames use a typed `ToolCall` oneof. The provider decodes them for diagnostics but only mirrors finalized todo/plan state (`update_todos_tool_call` / `create_plan_tool_call`) into advertised OpenCode `todowrite`; the completed payload already contains the authoritative final list. Interactive, data-returning, and side-effecting completions are never replayed as new tools because their result could not be returned to Cursor. Exec-backed native subagent/Task and Pi read/bash/edit/write/grep/find/ls calls use their typed request/result fields instead. Unknown display variants are logged. All 37 Cursor CLI exec request/result pairs are inventoried by field and name; known-but-unsupported and future unknown exec variants fail explicitly rather than receiving a guessed response that could deadlock the Run.
 - **Tool availability is per OpenCode agent** — Cursor can request native capabilities such as Task even when a child or restricted OpenCode agent did not advertise the corresponding host tool. The provider prompts Cursor with the exact current catalog and checks every decoded host-tool exec request against it. An unavailable request is answered on Cursor's correlated typed result channel and is never emitted as OpenCode's `invalid` tool.
+- **Host web tools use collision-safe aliases** — Cursor sees `custom_websearch` / `custom_webfetch`, and the held Run maps each alias back to an executable OpenCode tool with its schema, permission check, and correlated result intact. The plugin registers its search fallback directly as `custom_websearch`, avoiding OpenCode's reserved `websearch` id filter for third-party providers and taking precedence over MCP search providers such as Brave without host environment configuration. Exact host `webfetch` is translated the same way. Cursor's UI-bound native web interactions stay disabled because their approval replies cannot carry OpenCode tool results.
 - **Background shells are non-interactive** — Cursor's native background-shell spawn and soft-background shell-stream timeouts are bridged through OpenCode's foreground-only `bash` tool. With bash/zsh, the classic plugin keeps the original permission/UI command and executes the wrapper through `shell.env` (`BASH_ENV` / `ZDOTDIR`); OpenCode's non-interactive sh/dash argv ignores those startup variables, so the plugin uses a short `exec /bin/sh '<wrapper-file>'` command backed by the same private wrapper. Native background-spawn requests also carry a self-contained marker-producing fallback when the classic hooks are absent. Spawn/soft-bg wrappers detach with `nohup`, redirect output under `${TMPDIR:-/tmp}/cursor-opencode-{bg,shell}.*`, and return the real PID (or typed timeout/exit) to Cursor. Private markers and OpenCode's `<shell_metadata>` envelope are stripped before storage/render, with a short still-running / started / timed-out status line left for the bash bubble. Requests that require `write_shell_stdin` are rejected explicitly because OpenCode does not expose an interactive background-process lifecycle through its AI SDK tool interface. The POSIX wrap path is not implemented for native Windows PowerShell/`cmd`.
-- **Cursor-native interaction queries remain headless** — Cursor UI/approval *queries* (as distinct from display tool calls) still cannot be surfaced through the AI SDK provider interface. The normal system prompt redirects questions, planning, plan-mode transitions, and known-URL fetching to equivalent OpenCode tools only when they are advertised (`question`, `todowrite`, `plan_enter` / `plan_exit`, `webfetch`); native web/PR/MCP/image/SCM requests are declined so they remain behind OpenCode's tools and permissions. Separately from display `create_plan_tool_call` → `todowrite` mirroring, interaction `create_plan_request_query` is auto-acked (CLI headless parity) with success and an empty `plan_uri`, so Cursor may treat the plan as accepted without an OpenCode UI confirm. Compaction prompts are unchanged. Unknown future interaction variants fail the turn explicitly instead of hanging the Run stream.
+- **Cursor-native interaction queries remain headless** — Cursor UI/approval *queries* (as distinct from display tool calls) still cannot be surfaced through the AI SDK provider interface. The normal system prompt redirects questions, planning, plan-mode transitions, and available web capabilities to executable host tools (`question`, `todowrite`, `plan_enter` / `plan_exit`, `custom_websearch`, `custom_webfetch`); native web/PR/MCP/image/SCM requests are declined so they remain behind host tool permissions. Separately from display `create_plan_tool_call` → `todowrite` mirroring, interaction `create_plan_request_query` is auto-acked (CLI headless parity) with success and an empty `plan_uri`, so Cursor may treat the plan as accepted without an OpenCode UI confirm. Compaction prompts are unchanged. Unknown future interaction variants fail the turn explicitly instead of hanging the Run stream.
 - **Compaction resets Cursor conversation state** — the classic plugin marks OpenCode's `compaction` agent explicitly. On those turns the provider mints an isolated Cursor `conversation_id`, drops the prior checkpoint + KV blobs, preserves real tool outputs as OpenCode-host observations in the seed history, and re-advertises the session's last tool catalog while refusing execution during the summary itself. The first normal turn then rebases once more onto a fresh conversation seeded with OpenCode's compacted prompt and normal system instructions, so the summary-agent checkpoint cannot suppress later tool calls. Ordinary no-tool / `toolChoice:none` calls do not reset conversation state.
 - **Conversation bindings and compaction catalogs are bounded** — process-global per-session bindings, prior tool catalogs, and pending post-compaction rebases use a 256-session LRU bound. Evicting a conversation binding also drops its checkpoint and KV blobs.
 - **Interrupted Runs resume from checkpoints** — a remote EOF, Connect end-stream, or trailer error is never emitted as a successful `stop`. When the failed Run produced an eligible checkpoint, the provider opens a new RPC for the same conversation and sends that state with `ResumeAction`, so completed text and tool work are not replayed. Before any stateful output, an interruption without a checkpoint can still rebase from OpenCode history. Stateful interruptions without a checkpoint are surfaced because replay would be ambiguous; retry exhaustion remains explicit. A transport closure after `turn_ended` is treated as successful completion.
@@ -280,4 +284,4 @@ Project `instructions` may reference absolute or `~/` paths (OpenCode parity). S
 
 ## License
 
-MIT
+MIT

package/dist/agent-url.d.ts

@@ -1,3 +1,9 @@
+type AgentUrlOptions = {
+    apiBaseURL?: string;
+    baseURL?: string;
+    telemetryEnabled?: boolean;
+    timeoutMs?: number;
+};
 /**
  * Resolve the Run stream origin for this account via the `GetServerConfig`
  * Connect RPC. Memoized for the process lifetime.
@@ -8,10 +14,7 @@
  *
  * Concurrent callers share a single in-flight fetch.
  */
-export declare function resolveAgentUrl(token: string, options?: {
-    apiBaseURL?: string;
-    baseURL?: string;
-    telemetryEnabled?: boolean;
-}): Promise<string>;
+export declare function resolveAgentUrl(token: string, options?: AgentUrlOptions): Promise<string>;
 /** Reset the in-process memo. Tests only. */
 export declare function resetAgentUrlCache(): void;
+export {};

package/dist/auth.js

@@ -1,5 +1,7 @@
 import { CURSOR_API_HOST, CURSOR_WEBSITE_HOST } from "./shared.js";
+import { withAbortDeadline } from "./deadline.js";
 const API_BASE = `https://${CURSOR_API_HOST}`;
+const AUTH_REQUEST_TIMEOUT_MS = 5_000;
 export class AuthExchangeError extends Error {
     cause;
     constructor(message, cause) {
@@ -72,37 +74,67 @@ export function useAuthToken(token) {
     return { accessToken: token };
 }
 export async function exchangeApiKey(apiKey, baseUrl = API_BASE) {
-    const res = await fetch(`${baseUrl}/auth/exchange_user_api_key`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`,
-        },
-        body: "{}",
+    return withAbortDeadline(AUTH_REQUEST_TIMEOUT_MS, () => new AuthExchangeError("API key exchange timed out"), async (signal) => {
+        let res;
+        try {
+            res = await fetch(`${baseUrl}/auth/exchange_user_api_key`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: "{}",
+                signal,
+            });
+        }
+        catch (cause) {
+            throw new AuthExchangeError("API key exchange request failed", cause);
+        }
+        if (!res.ok) {
+            throw new AuthExchangeError(`API key exchange failed: ${res.status} ${res.statusText}`);
+        }
+        let body;
+        try {
+            body = await res.json();
+        }
+        catch (cause) {
+            throw new AuthExchangeError("API key exchange returned malformed JSON", cause);
+        }
+        if (typeof body.accessToken !== "string" || typeof body.refreshToken !== "string") {
+            throw new AuthExchangeError("Exchange response missing tokens");
+        }
+        return { accessToken: body.accessToken, refreshToken: body.refreshToken };
     });
-    if (!res.ok) {
-        throw new AuthExchangeError(`API key exchange failed: ${res.status} ${res.statusText}`);
-    }
-    const body = await res.json();
-    if (!body.accessToken || !body.refreshToken) {
-        throw new AuthExchangeError("Exchange response missing tokens");
-    }
-    return { accessToken: body.accessToken, refreshToken: body.refreshToken };
 }
 export async function refreshAccessToken(refreshToken, baseUrl = API_BASE) {
-    const res = await fetch(`${baseUrl}/auth/token`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ refreshToken }),
+    return withAbortDeadline(AUTH_REQUEST_TIMEOUT_MS, () => new AuthRefreshError("Token refresh timed out"), async (signal) => {
+        let res;
+        try {
+            res = await fetch(`${baseUrl}/auth/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ refreshToken }),
+                signal,
+            });
+        }
+        catch (cause) {
+            throw new AuthRefreshError("Token refresh request failed", cause);
+        }
+        if (!res.ok) {
+            throw new AuthRefreshError(`Token refresh failed: ${res.status} ${res.statusText}`);
+        }
+        let body;
+        try {
+            body = await res.json();
+        }
+        catch (cause) {
+            throw new AuthRefreshError("Token refresh returned malformed JSON", cause);
+        }
+        if (typeof body.accessToken !== "string" || typeof body.refreshToken !== "string") {
+            throw new AuthRefreshError("Refresh response missing tokens");
+        }
+        return { accessToken: body.accessToken, refreshToken: body.refreshToken };
     });
-    if (!res.ok) {
-        throw new AuthRefreshError(`Token refresh failed: ${res.status} ${res.statusText}`);
-    }
-    const body = await res.json();
-    if (!body.accessToken || !body.refreshToken) {
-        throw new AuthRefreshError("Refresh response missing tokens");
-    }
-    return { accessToken: body.accessToken, refreshToken: body.refreshToken };
 }
 // Cache JWTs obtained via API-key exchange so doStream doesn't re-exchange
 // on every turn when the caller only supplied `apiKey`.

package/dist/context/build.js

@@ -61,6 +61,12 @@ export async function buildRequestContext(input) {
             enabled: true,
             mcp_descriptors: nested,
         },
+        // This provider always rejects native web_search/web_fetch interaction
+        // queries with a headless-UI reason (see interactions.ts). Advertise that
+        // unavailability up front so Cursor prefers the collision-safe
+        // custom_web* aliases instead of routing through a query doomed to fail.
+        web_search_enabled: false,
+        web_fetch_enabled: false,
         // Completeness: true only for sections we actually gathered.
         rules_info_complete: true,
         env_info_complete: true,

package/dist/context/paths.d.ts

@@ -1,4 +1,15 @@
 export type HostPathEnv = NodeJS.ProcessEnv;
+type CompatDetectResult = {
+    id: string;
+    supported: boolean;
+    source?: string;
+    profile: {
+        paths: {
+            cacheDir: string;
+        };
+    };
+};
+type CompatDetector = () => CompatDetectResult;
 /**
  * Pin the process-wide cache root. Highest precedence for {@link opencodeGlobalCacheDir}.
  * Use for host-injected `Path.cache` or an explicit `createCursor({ cacheDir })`.
@@ -7,15 +18,18 @@ export declare function setHostCacheDirOverride(dir: string | undefined): void;
 export declare function getHostCacheDirOverride(): string | undefined;
 /**
  * Resolve the host cache directory without an override.
- * Mirrors OCP HostProfile drafts: MiMo (`mimocode` / `$MIMOCODE_HOME`), Kilo (`kilo`),
- * then OpenCode (`opencode`). Prefer fork config dirs when several exist.
+ *
+ * Explicit host environment wins. Otherwise, an installed provider inherits
+ * the host-named cache containing its module. A source checkout or otherwise
+ * unidentifiable install defaults to OpenCode. Merely having another host's
+ * config directory installed is not evidence that it owns this process.
  */
-export declare function resolveHostCacheDir(env?: HostPathEnv): string;
+export declare function resolveHostCacheDir(env?: HostPathEnv, moduleUrl?: string): string;
 /**
  * Best-effort: if `@opencode-compat/profile` is installed, adopt `detect().profile.paths.cacheDir`
  * when the host is supported. No-op when OCP is absent or detection fails.
  */
-export declare function adoptCompatHostCacheDir(): Promise<string | undefined>;
+export declare function adoptCompatHostCacheDir(detector?: CompatDetector): Promise<string | undefined>;
 /** OpenCode / host global config dir (`~/.config/<app>`). Still OpenCode-named for rule discovery. */
 export declare function opencodeGlobalConfigDir(): string;
 /**
@@ -23,8 +37,8 @@ export declare function opencodeGlobalConfigDir(): string;
  *
  * Precedence:
  * 1. {@link setHostCacheDirOverride} / `createCursor({ cacheDir })` (host `Path.cache`)
- * 2. OCP `detect()` when {@link adoptCompatHostCacheDir} ran successfully
- * 3. Local host heuristic ({@link resolveHostCacheDir})
+ * 2. Strong OCP `detect()` identity when {@link adoptCompatHostCacheDir} ran successfully
+ * 3. Explicit host environment / provider install path ({@link resolveHostCacheDir})
  */
 export declare function opencodeGlobalCacheDir(): string;
 /**
@@ -50,3 +64,4 @@ export declare function opencodeProjectDir(workspaceRoot: string): string;
 /** Ensure {@link opencodeProjectDir} exists (mode 0o700) and return it. */
 export declare function ensureOpencodeProjectDir(workspaceRoot: string): string;
 export declare function resolveHomeRelative(p: string): string;
+export {};

package/dist/context/paths.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { trace } from "../debug.js";
 /** Explicit host cache root (e.g. Effect v2 `Path.cache`, or `createCursor({ cacheDir })`). */
 let hostCacheDirOverride;
@@ -13,11 +14,6 @@ function xdgCacheHome(env = process.env) {
         return env.XDG_CACHE_HOME;
     return path.join(resolveHome(env), ".cache");
 }
-function xdgConfigHome(env = process.env) {
-    if (env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0)
-        return env.XDG_CONFIG_HOME;
-    return path.join(resolveHome(env), ".config");
-}
 /**
  * Pin the process-wide cache root. Highest precedence for {@link opencodeGlobalCacheDir}.
  * Use for host-injected `Path.cache` or an explicit `createCursor({ cacheDir })`.
@@ -30,23 +26,35 @@ export function getHostCacheDirOverride() {
 }
 /**
  * Resolve the host cache directory without an override.
- * Mirrors OCP HostProfile drafts: MiMo (`mimocode` / `$MIMOCODE_HOME`), Kilo (`kilo`),
- * then OpenCode (`opencode`). Prefer fork config dirs when several exist.
+ *
+ * Explicit host environment wins. Otherwise, an installed provider inherits
+ * the host-named cache containing its module. A source checkout or otherwise
+ * unidentifiable install defaults to OpenCode. Merely having another host's
+ * config directory installed is not evidence that it owns this process.
  */
-export function resolveHostCacheDir(env = process.env) {
+export function resolveHostCacheDir(env = process.env, moduleUrl = import.meta.url) {
     const mimoHome = env.MIMOCODE_HOME;
     if (mimoHome && mimoHome.length > 0) {
         return path.join(mimoHome, "cache");
     }
-    const configHome = xdgConfigHome(env);
     const cacheHome = xdgCacheHome(env);
     const kiloConfig = env.KILO_CONFIG_DIR;
-    // Prefer more specific fork dirs before OpenCode (same order as OCP detect).
-    if ((kiloConfig && kiloConfig.length > 0) || existsSync(path.join(configHome, "kilo"))) {
+    if (kiloConfig && kiloConfig.length > 0) {
         return path.join(cacheHome, "kilo");
     }
-    if (existsSync(path.join(configHome, "mimocode"))) {
-        return path.join(cacheHome, "mimocode");
+    let modulePath;
+    try {
+        modulePath = moduleUrl.startsWith("file:") ? fileURLToPath(moduleUrl) : path.resolve(moduleUrl);
+    }
+    catch {
+        modulePath = undefined;
+    }
+    if (modulePath) {
+        for (const host of ["mimocode", "kilo", "opencode"]) {
+            const root = path.resolve(cacheHome, host);
+            if (modulePath === root || modulePath.startsWith(`${root}${path.sep}`))
+                return root;
+        }
     }
     return path.join(cacheHome, "opencode");
 }
@@ -54,12 +62,18 @@ export function resolveHostCacheDir(env = process.env) {
  * Best-effort: if `@opencode-compat/profile` is installed, adopt `detect().profile.paths.cacheDir`
  * when the host is supported. No-op when OCP is absent or detection fails.
  */
-export async function adoptCompatHostCacheDir() {
+export async function adoptCompatHostCacheDir(detector) {
+    if (hostCacheDirOverride)
+        return hostCacheDirOverride;
     try {
-        const { detect } = await import("@opencode-compat/profile");
+        const detect = detector ?? (await import("@opencode-compat/profile")).detect;
         const result = detect();
         if (!result.supported || result.id === "unknown")
             return undefined;
+        if (!result.source || !["env", "binary", "package"].includes(result.source)) {
+            trace(`host-cache: ignored weak OCP detect host=${result.id} source=${result.source ?? "unknown"}`);
+            return undefined;
+        }
         const cacheDir = result.profile.paths.cacheDir;
         if (!cacheDir || cacheDir.length === 0)
             return undefined;
@@ -80,8 +94,8 @@ export function opencodeGlobalConfigDir() {
  *
  * Precedence:
  * 1. {@link setHostCacheDirOverride} / `createCursor({ cacheDir })` (host `Path.cache`)
- * 2. OCP `detect()` when {@link adoptCompatHostCacheDir} ran successfully
- * 3. Local host heuristic ({@link resolveHostCacheDir})
+ * 2. Strong OCP `detect()` identity when {@link adoptCompatHostCacheDir} ran successfully
+ * 3. Explicit host environment / provider install path ({@link resolveHostCacheDir})
  */
 export function opencodeGlobalCacheDir() {
     if (hostCacheDirOverride)

package/dist/deadline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bound a complete async operation, not only fetch(). Response body readers can
+ * ignore abort signals, so Promise.race remains the authoritative deadline.
+ *
+ * Rejects with `timeoutError()` before aborting so callers observe the domain
+ * timeout error rather than a generic AbortError.
+ */
+export declare function withAbortDeadline<T>(timeoutMs: number, timeoutError: () => Error, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/deadline.js

@@ -0,0 +1,25 @@
+/**
+ * Bound a complete async operation, not only fetch(). Response body readers can
+ * ignore abort signals, so Promise.race remains the authoritative deadline.
+ *
+ * Rejects with `timeoutError()` before aborting so callers observe the domain
+ * timeout error rather than a generic AbortError.
+ */
+export async function withAbortDeadline(timeoutMs, timeoutError, run) {
+    const controller = new AbortController();
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(timeoutError());
+            controller.abort();
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([run(controller.signal), deadline]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}