veryfront 0.1.47 → 0.1.49

package/src/src/observability/tracing/span-operations.ts

@@ -84,14 +84,19 @@ export class SpanOperations {
   private mapSpanKind(kind?: SpanOptions["kind"]): SpanKind {
     if (!kind) return this.api.SpanKind.INTERNAL;
 
-    const kindMap: Record<string, SpanKind> = {
-      internal: this.api.SpanKind.INTERNAL,
-      server: this.api.SpanKind.SERVER,
-      client: this.api.SpanKind.CLIENT,
-      producer: this.api.SpanKind.PRODUCER,
-      consumer: this.api.SpanKind.CONSUMER,
-    };
-
-    return kindMap[kind.toLowerCase()] ?? this.api.SpanKind.INTERNAL;
+    switch (kind) {
+      case "internal":
+        return this.api.SpanKind.INTERNAL;
+      case "server":
+        return this.api.SpanKind.SERVER;
+      case "client":
+        return this.api.SpanKind.CLIENT;
+      case "producer":
+        return this.api.SpanKind.PRODUCER;
+      case "consumer":
+        return this.api.SpanKind.CONSUMER;
+      default:
+        return this.api.SpanKind.INTERNAL;
+    }
   }
 }

package/src/src/platform/compat/console/node.ts

@@ -17,16 +17,10 @@ type PicoColors = {
   reset: (s: string) => string;
 };
 
-let pc: PicoColors | null = null;
-
-async function ensurePc(): Promise<PicoColors> {
-  if (pc) return pc;
-
-  const mod = await import("picocolors");
-  pc = mod.default as PicoColors;
-
-  return pc;
-}
+// NOTE: pc is null because lazy initialization was removed as dead code.
+// Colors on Node.js currently fall through to identity (no-op).
+// The console/index.ts fallback colors and ANSI module handle the actual coloring.
+const pc: PicoColors | null = null;
 
 function lazyColor(fn: keyof PicoColors): (s: string) => string {
   return (s: string) => pc?.[fn]?.(s) ?? s;
@@ -65,7 +59,3 @@ export const {
   strikethrough,
   reset,
 } = colors;
-
-export async function initColors(): Promise<void> {
-  await ensurePc();
-}

package/src/src/platform/compat/fs.ts

@@ -310,12 +310,22 @@ export async function symlink(target: string, path: string): Promise<void> {
   await fs.symlink(target, path);
 }
 
+type DenoGlobal = typeof dntShim.dntGlobalThis & {
+  Deno?: {
+    errors?: {
+      NotFound?: new (...args: unknown[]) => Error;
+      AlreadyExists?: new (...args: unknown[]) => Error;
+    };
+  };
+};
+
 export function isNotFoundError(error: unknown): boolean {
-  if (isDeno && error instanceof (dntShim.dntGlobalThis as any).Deno.errors.NotFound) return true;
+  const NotFound = (dntShim.dntGlobalThis as DenoGlobal).Deno?.errors?.NotFound;
+  if (isDeno && NotFound && error instanceof NotFound) return true;
   if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return true;
   if (
     error instanceof Error && error.name === "VeryfrontError" &&
-    (error as any).slug === "file-not-found"
+    (error as { slug?: string }).slug === "file-not-found"
   ) {
     return true;
   }
@@ -323,6 +333,7 @@ export function isNotFoundError(error: unknown): boolean {
 }
 
 export function isAlreadyExistsError(error: unknown): boolean {
-  if (isDeno && error instanceof (dntShim.dntGlobalThis as any).Deno.errors.AlreadyExists) return true;
+  const AlreadyExists = (dntShim.dntGlobalThis as DenoGlobal).Deno?.errors?.AlreadyExists;
+  if (isDeno && AlreadyExists && error instanceof AlreadyExists) return true;
   return (error as NodeJS.ErrnoException)?.code === "EEXIST";
 }

package/src/src/platform/compat/opaque-deps.ts

@@ -22,12 +22,42 @@ function resolve(pkg: string, version: string): string {
   return isDeno ? `npm:${pkg}@${version}` : pkg;
 }
 
+// deno-lint-ignore no-explicit-any -- Opaque deps have unknown shapes; callers cast at call site
+type OpaqueModule = any;
+
 /** Lazily import `@huggingface/transformers` (+ onnxruntime, ~500MB). */
-export function importTransformers(): Promise<any> {
+export function importTransformers(): Promise<OpaqueModule> {
   return dynamicImport(resolve("@huggingface/transformers", "3.4.2"));
 }
 
 /** Lazily import `@anthropic-ai/claude-agent-sdk` (~69MB). */
-export function importClaudeAgentSDK(): Promise<any> {
+export function importClaudeAgentSDK(): Promise<OpaqueModule> {
   return dynamicImport(resolve("@anthropic-ai/claude-agent-sdk", "0.2.37"));
 }
+
+/**
+ * Lazily import kreuzberg document extraction.
+ *
+ * Unlike the other opaque deps above, kreuzberg is a core framework
+ * dependency that must work in compiled binaries. The Deno path uses
+ * a regular `import()` (not `dynamicImport`) so `deno compile` can
+ * trace and embed `@kreuzberg/wasm`. The Node/Bun path uses `dynamicImport`
+ * to resolve `@kreuzberg/node` from the project's node_modules at runtime.
+ */
+export async function importKreuzberg(): Promise<{
+  extractBytes: (
+    data: Uint8Array,
+    mimeType: string,
+  ) => Promise<{ content: string }>;
+}> {
+  if (isDeno) {
+    // Regular import — visible to deno compile, resolved via deno.json import map
+    const mod = await import("@kreuzberg/wasm") as unknown as
+      & { initWasm?: () => Promise<void> }
+      & { extractBytes: (data: Uint8Array, mimeType: string) => Promise<{ content: string }> };
+    await mod.initWasm?.();
+    return mod;
+  }
+  // Opaque import — resolved from node_modules at runtime
+  return dynamicImport("@kreuzberg/node");
+}

package/src/src/platform/compat/path/basic-operations.ts

@@ -1,13 +1,21 @@
 import { hasNodePath, isDeno, nodePath } from "./runtime.js";
 
-function useNodePath(): boolean {
-  return !isDeno && hasNodePath;
+function hasWindowsLikePath(path: string): boolean {
+  return path.includes("\\") || /^[A-Za-z]:/.test(path) || path.startsWith("\\\\");
 }
 
-export function join(...paths: string[]): string {
-  if (useNodePath()) return nodePath!.join(...paths);
+function useNodePath(paths: string[]): boolean {
+  return !isDeno && hasNodePath && !paths.some(hasWindowsLikePath);
+}
 
+/** Normalize backslashes to forward slashes (for Deno on Windows). */
+function normSep(p: string): string {
+  return p.includes("\\") ? p.replace(/\\/g, "/") : p;
+}
+
+export function join(...paths: string[]): string {
   const joined = paths
+    .map(normSep)
     .filter((p) => p.length > 0)
     .join("/")
     .replace(/\/+/g, "/")
@@ -17,21 +25,22 @@ export function join(...paths: string[]): string {
 }
 
 export function dirname(path: string): string {
-  if (useNodePath()) return nodePath!.dirname(path);
+  if (useNodePath([path])) return nodePath!.dirname(path);
 
-  const lastSlash = path.lastIndexOf("/");
+  const p = normSep(path);
+  const lastSlash = p.lastIndexOf("/");
   if (lastSlash === -1) return ".";
   if (lastSlash === 0) return "/";
-  return path.slice(0, lastSlash);
+  return p.slice(0, lastSlash);
 }
 
 export function basename(path: string, ext?: string): string {
-  if (useNodePath()) {
+  if (useNodePath([path])) {
     // Only pass ext if defined - Bun is strict about this parameter
     return ext === undefined ? nodePath!.basename(path) : nodePath!.basename(path, ext);
   }
 
-  let normalizedPath = path;
+  let normalizedPath = normSep(path);
   while (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
     normalizedPath = normalizedPath.slice(0, -1);
   }
@@ -45,7 +54,7 @@ export function basename(path: string, ext?: string): string {
 }
 
 export function extname(path: string): string {
-  if (useNodePath()) return nodePath!.extname(path);
+  if (useNodePath([path])) return nodePath!.extname(path);
 
   const base = basename(path);
   const lastDot = base.lastIndexOf(".");

package/src/src/platform/compat/path/resolution.ts

@@ -1,18 +1,45 @@
 import * as dntShim from "../../../../_dnt.shims.js";
 import { hasNodePath, isDeno, nodePath } from "./runtime.js";
 
-function useNodePath(): boolean {
-  return !isDeno && hasNodePath;
+function hasWindowsLikePath(path: string): boolean {
+  return path.includes("\\") || /^[A-Za-z]:/.test(path) || path.startsWith("\\\\");
 }
 
+function useNodePath(paths: string[]): boolean {
+  return !isDeno && hasNodePath && !paths.some(hasWindowsLikePath);
+}
+
+/** Normalize backslashes to forward slashes (for Deno on Windows). */
+function normSep(p: string): string {
+  return p.includes("\\") ? p.replace(/\\/g, "/") : p;
+}
+
+/** Match Windows drive letter prefix like "C:/" */
+const DRIVE_LETTER = /^[A-Za-z]:\//;
+
 export function resolve(...paths: string[]): string {
-  if (useNodePath()) return nodePath!.resolve(...paths);
+  if (useNodePath(paths)) return nodePath!.resolve(...paths);
+
+  let resolvedPath = normSep(dntShim.dntGlobalThis.Deno?.cwd?.() ?? "/");
 
-  let resolvedPath = dntShim.dntGlobalThis.Deno?.cwd() ?? "/";
+  for (const rawPath of paths) {
+    if (!rawPath) continue;
+    const path = normSep(rawPath);
+    if (path.startsWith("/") || DRIVE_LETTER.test(path)) {
+      resolvedPath = path;
+    } else {
+      resolvedPath = `${resolvedPath}/${path}`;
+    }
+  }
 
-  for (const path of paths) {
-    if (!path) continue;
-    resolvedPath = path.startsWith("/") ? path : `${resolvedPath}/${path}`;
+  // Preserve drive letter prefix (e.g. "D:/") if present
+  let prefix = "/";
+  const driveMatch = resolvedPath.match(DRIVE_LETTER);
+  if (driveMatch) {
+    prefix = driveMatch[0]; // e.g. "D:/"
+    resolvedPath = resolvedPath.slice(prefix.length);
+  } else if (resolvedPath.startsWith("/")) {
+    resolvedPath = resolvedPath.slice(1);
   }
 
   const parts = resolvedPath.split("/").filter(Boolean);
@@ -26,22 +53,34 @@ export function resolve(...paths: string[]): string {
     if (part !== ".") resolved.push(part);
   }
 
-  return `/${resolved.join("/")}`;
+  return `${prefix}${resolved.join("/")}`;
 }
 
 export function isAbsolute(path: string): boolean {
-  if (useNodePath()) return nodePath!.isAbsolute(path);
-  // Deno fallback: Unix, Windows drive letters, and UNC paths
+  if (useNodePath([path]) && nodePath!.isAbsolute(path)) return true;
+  // Cross-platform fallback: Unix, Windows drive letters, and UNC paths
   if (path.startsWith("/")) return true;
-  if (/^[A-Za-z]:[\/\\]/.test(path)) return true;
+  if (/^[A-Za-z]:[/\\]/.test(path)) return true;
   return /^\\\\[^\\]+\\[^\\]+/.test(path);
 }
 
 export function relative(from: string, to: string): string {
-  if (useNodePath()) return nodePath!.relative(from, to);
+  if (useNodePath([from, to])) {
+    const relativePath = nodePath!.relative(from, to);
+    return relativePath || ".";
+  }
+
+  const resolvedFrom = resolve(from);
+  const resolvedTo = resolve(to);
+
+  // Strip drive prefix for comparison (both will share the same drive after resolve)
+  const fromDrive = resolvedFrom.match(DRIVE_LETTER);
+  const fromBase = fromDrive ? resolvedFrom.slice(fromDrive[0].length) : resolvedFrom.slice(1);
+  const toDrive = resolvedTo.match(DRIVE_LETTER);
+  const toBase = toDrive ? resolvedTo.slice(toDrive[0].length) : resolvedTo.slice(1);
 
-  const fromParts = resolve(from).split("/").filter(Boolean);
-  const toParts = resolve(to).split("/").filter(Boolean);
+  const fromParts = fromBase.split("/").filter(Boolean);
+  const toParts = toBase.split("/").filter(Boolean);
 
   let common = 0;
   const minLen = Math.min(fromParts.length, toParts.length);
@@ -58,11 +97,23 @@ export function relative(from: string, to: string): string {
 }
 
 export function normalize(path: string): string {
-  if (useNodePath()) return nodePath!.normalize(path);
+  if (useNodePath([path])) return nodePath!.normalize(path);
   if (path === "") return ".";
 
-  const abs = isAbsolute(path);
-  const parts = path.split("/").filter((p) => p && p !== ".");
+  const p = normSep(path);
+  const abs = isAbsolute(p);
+
+  // Preserve drive letter prefix
+  let prefix = "";
+  const driveMatch = p.match(DRIVE_LETTER);
+  if (driveMatch) {
+    prefix = driveMatch[0];
+  } else if (abs) {
+    prefix = "/";
+  }
+
+  const pathWithoutPrefix = driveMatch ? p.slice(prefix.length) : abs ? p.slice(1) : p;
+  const parts = pathWithoutPrefix.split("/").filter((s) => s && s !== ".");
 
   const normalized: string[] = [];
 
@@ -83,7 +134,7 @@ export function normalize(path: string): string {
 
   const result = normalized.join("/");
 
-  if (abs) return result ? `/${result}` : "/";
+  if (abs) return result ? `${prefix}${result}` : prefix || "/";
 
   return result || ".";
 }

package/src/src/platform/compat/path/url-conversion.ts

@@ -2,6 +2,11 @@ import * as dntShim from "../../../../_dnt.shims.js";
 import { hasNodePath, isDeno } from "./runtime.js";
 import { isAbsolute, resolve } from "./resolution.js";
 
+type GlobalWithRequire = typeof dntShim.dntGlobalThis & {
+  require?: (specifier: string) => { fileURLToPath?: (url: string | URL) => string };
+  Deno?: { cwd?: () => string; build?: { os?: string } };
+};
+
 let _fileURLToPath: ((url: string | URL) => string) | null = null;
 
 function getFileURLToPath(): ((url: string | URL) => string) | null {
@@ -9,10 +14,8 @@ function getFileURLToPath(): ((url: string | URL) => string) | null {
   if (!hasNodePath) return null;
 
   try {
-    const nodeUrl = (dntShim.dntGlobalThis as any).require?.("node:url");
-    const fileURLToPath = nodeUrl?.fileURLToPath as
-      | ((url: string | URL) => string)
-      | undefined;
+    const nodeUrl = (dntShim.dntGlobalThis as GlobalWithRequire).require?.("node:url");
+    const fileURLToPath = nodeUrl?.fileURLToPath;
 
     if (!fileURLToPath) return null;
 
@@ -30,8 +33,9 @@ export function fromFileUrl(url: string | URL): string {
   const urlString = typeof url === "string" ? url : url.toString();
 
   if (isDeno) {
-    const hasCwd = Boolean((dntShim.Deno as any).cwd);
-    const isWindows = (dntShim.dntGlobalThis as any).Deno?.build?.os === "windows";
+    const g = dntShim.dntGlobalThis as GlobalWithRequire;
+    const hasCwd = Boolean(g.Deno?.cwd);
+    const isWindows = g.Deno?.build?.os === "windows";
 
     if (hasCwd && isWindows) {
       return decodeURIComponent(urlString.slice(8).replace(/\//g, "\\"));

package/src/src/platform/compat/process.ts

@@ -162,16 +162,6 @@ export function getEnvBoolean(
   return fallback;
 }
 
-/**
- * Get an environment variable or throw if not set
- * @throws Error if the environment variable is not set
- */
-export function requireEnv(key: string): string {
-  const value = getEnv(key);
-  if (value === undefined) throw new Error(`Required environment variable "${key}" is not set`);
-  return value;
-}
-
 export function setEnv(key: string, value: string): void {
   if (IS_DENO) {
     dntShim.Deno.env.set(key, value);
@@ -223,12 +213,6 @@ export function pid(): number {
   return 0;
 }
 
-export function ppid(): number {
-  if (IS_DENO && "ppid" in dntShim.Deno) return dntShim.Deno.ppid || 0;
-  if (hasNodeProcess) return nodeProcess!.ppid || 0;
-  return 0;
-}
-
 export function memoryUsage(): {
   rss: number;
   heapTotal: number;
@@ -289,44 +273,6 @@ export function getTerminalSize(): { columns: number; rows: number } {
   return defaultSize;
 }
 
-/**
- * Get network interfaces
- */
-export async function getNetworkInterfaces(): Promise<
-  Array<{ name: string; address: string; family: "IPv4" | "IPv6" }>
-> {
-  if (IS_DENO) {
-    return dntShim.Deno.networkInterfaces().map((iface) => ({
-      name: iface.name,
-      address: iface.address,
-      family: iface.family as "IPv4" | "IPv6",
-    }));
-  }
-
-  // Bun and Node.js both support node:os
-  if (!hasNodeProcess && !IS_BUN) {
-    throw new Error("networkInterfaces() is not supported in this runtime");
-  }
-
-  // Use dynamicImport to avoid static analysis by bundlers
-  const os = await dynamicImport<typeof import("node:os")>("node:os");
-  const interfaces = os.networkInterfaces();
-  const result: Array<{ name: string; address: string; family: "IPv4" | "IPv6" }> = [];
-
-  for (const [name, addrs] of Object.entries(interfaces)) {
-    if (!addrs) continue;
-    for (const addr of addrs) {
-      result.push({
-        name,
-        address: addr.address,
-        family: addr.family as "IPv4" | "IPv6",
-      });
-    }
-  }
-
-  return result;
-}
-
 /**
  * Get runtime version string
  */
@@ -535,10 +481,14 @@ export function readStdinByteSync(): number | null {
 
   if (IS_BUN) {
     // Bun: read one byte from the file descriptor directly
-    // deno-lint-ignore no-explicit-any
-    const Bun = (dntShim.dntGlobalThis as any).Bun;
-    const chunk = Bun?.stdin?.read?.(1);
-    if (chunk && chunk.length > 0) return chunk[0];
+    const BunGlobal =
+      (dntShim.dntGlobalThis as { Bun?: { stdin?: { read?: (n: number) => Uint8Array | null } } })
+        .Bun;
+    const chunk = BunGlobal?.stdin?.read?.(1);
+    if (chunk && chunk.length > 0) {
+      const first = chunk.at(0);
+      return first ?? null;
+    }
     return null;
   }
 
@@ -566,6 +516,61 @@ export interface CommandOptions {
   inherit?: boolean;
   /** Use shell to run the command (needed for .cmd files on Windows) */
   shell?: boolean;
+  /** Kill the command if it exceeds this duration (milliseconds) */
+  timeoutMs?: number;
+}
+
+const COMMAND_TIMEOUT_EXIT_CODE = 124;
+const FORCE_KILL_GRACE_MS = 250;
+
+function createTimeoutResult(
+  timeoutMs: number,
+  stdout?: string,
+  stderr?: string,
+): CommandResult {
+  return {
+    success: false,
+    code: COMMAND_TIMEOUT_EXIT_CODE,
+    stdout,
+    stderr: `${stderr ?? ""}\nCommand timed out after ${timeoutMs}ms`.trim(),
+  };
+}
+
+function createProcessTimeout(
+  timeoutMs: number | undefined,
+  terminate: () => void,
+  forceTerminate: () => void,
+): { hasTimedOut: () => boolean; clear: () => void } {
+  let timedOut = false;
+  let timeoutId: ReturnType<typeof dntShim.setTimeout> | undefined;
+  let forceKillId: ReturnType<typeof dntShim.setTimeout> | undefined;
+
+  if (timeoutMs && timeoutMs > 0) {
+    timeoutId = dntShim.setTimeout(() => {
+      timedOut = true;
+      try {
+        terminate();
+      } catch {
+        // Best-effort terminate.
+      }
+
+      forceKillId = dntShim.setTimeout(() => {
+        try {
+          forceTerminate();
+        } catch {
+          // Best-effort force terminate.
+        }
+      }, FORCE_KILL_GRACE_MS);
+    }, timeoutMs);
+  }
+
+  return {
+    hasTimedOut: () => timedOut,
+    clear: () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (forceKillId) clearTimeout(forceKillId);
+    },
+  };
 }
 
 async function readStreamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
@@ -604,8 +609,16 @@ export async function runCommand(
   cmd: string,
   options: CommandOptions = {},
 ): Promise<CommandResult> {
-  const { args = [], cwd: cmdCwd, env: cmdEnv, capture = false, inherit = false, shell = false } =
-    options;
+  const {
+    args = [],
+    cwd: cmdCwd,
+    env: cmdEnv,
+    capture = false,
+    inherit = false,
+    shell = false,
+    timeoutMs,
+  } = options;
+  const effectiveTimeoutMs = timeoutMs && timeoutMs > 0 ? Math.floor(timeoutMs) : undefined;
 
   // Determine stdio mode: inherit > capture > null
   const stdioMode = inherit ? "inherit" : capture ? "piped" : "null";
@@ -620,15 +633,31 @@ export async function runCommand(
       stderr: stdioMode,
     });
 
-    const output = await command.output();
-    const decoder = new TextDecoder();
+    const child = command.spawn();
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => child.kill("SIGTERM"),
+      () => child.kill("SIGKILL"),
+    );
 
-    return {
-      success: output.success,
-      code: output.code,
-      stdout: capture ? decoder.decode(output.stdout) : undefined,
-      stderr: capture ? decoder.decode(output.stderr) : undefined,
-    };
+    try {
+      const [status, stdout, stderr] = await Promise.all([
+        child.status,
+        capture && child.stdout ? readStreamToString(child.stdout) : Promise.resolve(undefined),
+        capture && child.stderr ? readStreamToString(child.stderr) : Promise.resolve(undefined),
+      ]);
+
+      if (timeout.hasTimedOut()) return createTimeoutResult(effectiveTimeoutMs!, stdout, stderr);
+
+      return {
+        success: status.success,
+        code: status.code,
+        stdout,
+        stderr,
+      };
+    } finally {
+      timeout.clear();
+    }
   }
 
   if (IS_BUN) {
@@ -644,6 +673,7 @@ export async function runCommand(
           exited: Promise<number>;
           stdout: ReadableStream<Uint8Array> | null;
           stderr: ReadableStream<Uint8Array> | null;
+          kill?: (signal?: string | number) => void;
         };
       };
     };
@@ -667,17 +697,25 @@ export async function runCommand(
       stderr: bunStdio,
     });
 
-    const code = await proc.exited;
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => proc.kill?.("SIGTERM"),
+      () => proc.kill?.("SIGKILL"),
+    );
 
-    let stdout: string | undefined;
-    let stderr: string | undefined;
+    try {
+      const [code, stdout, stderr] = await Promise.all([
+        proc.exited,
+        capture && proc.stdout ? readStreamToString(proc.stdout) : Promise.resolve(undefined),
+        capture && proc.stderr ? readStreamToString(proc.stderr) : Promise.resolve(undefined),
+      ]);
 
-    if (capture) {
-      stdout = proc.stdout ? await readStreamToString(proc.stdout) : undefined;
-      stderr = proc.stderr ? await readStreamToString(proc.stderr) : undefined;
-    }
+      if (timeout.hasTimedOut()) return createTimeoutResult(effectiveTimeoutMs!, stdout, stderr);
 
-    return { success: code === 0, code, stdout, stderr };
+      return { success: code === 0, code, stdout, stderr };
+    } finally {
+      timeout.clear();
+    }
   }
 
   if (!hasNodeProcess) return { success: false, code: 1 };
@@ -705,6 +743,11 @@ export async function runCommand(
     let stdout = "";
     let stderr = "";
     const decoder = new TextDecoder();
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => child.kill("SIGTERM"),
+      () => child.kill("SIGKILL"),
+    );
 
     if (capture) {
       child.stdout?.on("data", (data: Uint8Array) => {
@@ -716,6 +759,19 @@ export async function runCommand(
     }
 
     child.on("close", (code) => {
+      timeout.clear();
+
+      if (timeout.hasTimedOut()) {
+        resolve(
+          createTimeoutResult(
+            effectiveTimeoutMs!,
+            capture ? stdout : undefined,
+            capture ? stderr : undefined,
+          ),
+        );
+        return;
+      }
+
       resolve({
         success: code === 0,
         code: code ?? 1,
@@ -725,6 +781,7 @@ export async function runCommand(
     });
 
     child.on("error", () => {
+      timeout.clear();
       resolve({ success: false, code: 1 });
     });
   });

package/src/src/provider/index.ts

@@ -21,6 +21,7 @@ import "../../_dnt.polyfills.js";
 export {
   clearModelProviders,
   ensureModelReady,
+  findAvailableCloudModel,
   getRegisteredModelProviders,
   hasModelProvider,
   registerModelProvider,