veryfront 0.1.49 → 0.1.51

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

@@ -14,6 +14,8 @@
  *
  * @module platform/compat
  */
+import * as dntShim from "../../../_dnt.shims.js";
+
 
 import { isDeno } from "./runtime.js";
 import { dynamicImport } from "./dynamic-import.js";
@@ -22,7 +24,7 @@ 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
+// deno-lint-ignore no-explicit-any -- callers assign to their own typed variable; any allows implicit narrowing at each call site
 type OpaqueModule = any;
 
 /** Lazily import `@huggingface/transformers` (+ onnxruntime, ~500MB). */
@@ -32,6 +34,9 @@ export function importTransformers(): Promise<OpaqueModule> {
 
 /** Lazily import `@anthropic-ai/claude-agent-sdk` (~69MB). */
 export function importClaudeAgentSDK(): Promise<OpaqueModule> {
+  // Allow tests to inject a mock SDK without loading the real 69 MB package.
+  const mock = (dntShim.dntGlobalThis as Record<string, unknown>).__vfMockClaudeSDK;
+  if (mock && typeof mock === "object" && "query" in mock) return Promise.resolve(mock);
   return dynamicImport(resolve("@anthropic-ai/claude-agent-sdk", "0.2.37"));
 }
 

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

@@ -1,13 +1,9 @@
-import { hasNodePath, isDeno, nodePath } from "./runtime.js";
+import { isDeno, nodePath } from "./runtime.js";
 
 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;
@@ -25,7 +21,7 @@ export function join(...paths: string[]): string {
 }
 
 export function dirname(path: string): string {
-  if (useNodePath([path])) return nodePath!.dirname(path);
+  if (!isDeno && nodePath && !hasWindowsLikePath(path)) return nodePath.dirname(path);
 
   const p = normSep(path);
   const lastSlash = p.lastIndexOf("/");
@@ -35,9 +31,9 @@ export function dirname(path: string): string {
 }
 
 export function basename(path: string, ext?: string): string {
-  if (useNodePath([path])) {
+  if (!isDeno && nodePath && !hasWindowsLikePath(path)) {
     // Only pass ext if defined - Bun is strict about this parameter
-    return ext === undefined ? nodePath!.basename(path) : nodePath!.basename(path, ext);
+    return ext === undefined ? nodePath.basename(path) : nodePath.basename(path, ext);
   }
 
   let normalizedPath = normSep(path);
@@ -54,7 +50,7 @@ export function basename(path: string, ext?: string): string {
 }
 
 export function extname(path: string): string {
-  if (useNodePath([path])) return nodePath!.extname(path);
+  if (!isDeno && nodePath && !hasWindowsLikePath(path)) return nodePath.extname(path);
 
   const base = basename(path);
   const lastDot = base.lastIndexOf(".");

package/src/src/platform/compat/path/parse-format.ts

@@ -1,11 +1,11 @@
-import { hasNodePath, isDeno, nodePath } from "./runtime.js";
+import { isDeno, nodePath } from "./runtime.js";
 import { basename, dirname, extname, join } from "./basic-operations.js";
 import { isAbsolute } from "./resolution.js";
 import type { PathObject } from "./types.js";
 
 export function parse(path: string): PathObject {
-  if (!isDeno && hasNodePath) {
-    return nodePath!.parse(path);
+  if (!isDeno && nodePath) {
+    return nodePath.parse(path);
   }
 
   const dir = dirname(path);
@@ -22,8 +22,8 @@ export function parse(path: string): PathObject {
 }
 
 export function format(pathObject: PathObject): string {
-  if (!isDeno && hasNodePath) {
-    return nodePath!.format(pathObject);
+  if (!isDeno && nodePath) {
+    return nodePath.format(pathObject);
   }
 
   const { dir = "", base = "", name = "", ext = "" } = pathObject;

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

@@ -1,14 +1,10 @@
 import * as dntShim from "../../../../_dnt.shims.js";
-import { hasNodePath, isDeno, nodePath } from "./runtime.js";
+import { isDeno, nodePath } from "./runtime.js";
 
 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;
@@ -18,7 +14,7 @@ function normSep(p: string): string {
 const DRIVE_LETTER = /^[A-Za-z]:\//;
 
 export function resolve(...paths: string[]): string {
-  if (useNodePath(paths)) return nodePath!.resolve(...paths);
+  if (!isDeno && nodePath && !paths.some(hasWindowsLikePath)) return nodePath.resolve(...paths);
 
   let resolvedPath = normSep(dntShim.dntGlobalThis.Deno?.cwd?.() ?? "/");
 
@@ -57,7 +53,7 @@ export function resolve(...paths: string[]): string {
 }
 
 export function isAbsolute(path: string): boolean {
-  if (useNodePath([path]) && nodePath!.isAbsolute(path)) return true;
+  if (!isDeno && nodePath && !hasWindowsLikePath(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;
@@ -65,8 +61,8 @@ export function isAbsolute(path: string): boolean {
 }
 
 export function relative(from: string, to: string): string {
-  if (useNodePath([from, to])) {
-    const relativePath = nodePath!.relative(from, to);
+  if (!isDeno && nodePath && !hasWindowsLikePath(from) && !hasWindowsLikePath(to)) {
+    const relativePath = nodePath.relative(from, to);
     return relativePath || ".";
   }
 
@@ -97,7 +93,7 @@ export function relative(from: string, to: string): string {
 }
 
 export function normalize(path: string): string {
-  if (useNodePath([path])) return nodePath!.normalize(path);
+  if (!isDeno && nodePath && !hasWindowsLikePath(path)) return nodePath.normalize(path);
   if (path === "") return ".";
 
   const p = normSep(path);

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

@@ -14,8 +14,8 @@ if (hasNodeApis) {
     if (nodeRequire) {
       nodePath = nodeRequire("node:path") as NodePathModule;
     }
-  } catch {
-    // ignore
+  } catch (_) {
+    /* expected: node:path require may fail in non-Node runtimes */
   }
 }
 

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

@@ -21,7 +21,8 @@ function getFileURLToPath(): ((url: string | URL) => string) | null {
 
     _fileURLToPath = fileURLToPath;
     return _fileURLToPath;
-  } catch {
+  } catch (_) {
+    /* expected: node:url require may fail in non-Node runtimes */
     return null;
   }
 }

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

@@ -3,11 +3,24 @@ import { isBun as IS_BUN, isDeno as IS_DENO } from "./runtime.js";
 import { dynamicImport } from "./dynamic-import.js";
 
 const nodeProcess = (dntShim.dntGlobalThis as { process?: typeof import("node:process") }).process;
-const hasNodeProcess = !!nodeProcess?.versions?.node;
+type RuntimeProcess = typeof import("node:process");
+
+/**
+ * Detect a real Node/Bun process object.
+ * Browser bundles may inject `window.process = { env: {} }`, which is not enough
+ * to safely call process APIs like cwd(), exit(), or on().
+ */
+export function testHasRuntimeProcess(processLike: unknown): processLike is RuntimeProcess {
+  if (!processLike || typeof processLike !== "object") return false;
+  const versions = (processLike as { versions?: { node?: string } }).versions;
+  return typeof versions?.node === "string" && versions.node.length > 0;
+}
+
+const runtimeProcess = testHasRuntimeProcess(nodeProcess) ? nodeProcess : null;
 
 function isWindowsPlatform(): boolean {
   if (IS_DENO) return dntShim.Deno.build.os === "windows";
-  const platform = nodeProcess?.platform ??
+  const platform = runtimeProcess?.platform ??
     (dntShim.dntGlobalThis as { process?: { platform?: string } }).process?.platform;
   return platform === "win32";
 }
@@ -15,20 +28,20 @@ function isWindowsPlatform(): boolean {
 /** Get command-line arguments (cross-runtime: Deno.args or process.argv). */
 export function getArgs(): string[] {
   if (IS_DENO) return dntShim.Deno.args;
-  if (hasNodeProcess) return nodeProcess!.argv.slice(2);
+  if (runtimeProcess) return runtimeProcess.argv.slice(2);
   return [];
 }
 
 /** Exit the process with an optional code (cross-runtime: Deno.exit or process.exit). */
 export function exit(code?: number): never {
   if (IS_DENO) dntShim.Deno.exit(code);
-  if (hasNodeProcess) nodeProcess!.exit(code);
+  if (runtimeProcess) runtimeProcess.exit(code);
   throw new Error("exit() is not supported in this runtime");
 }
 
 export function cwd(): string {
   if (IS_DENO) return dntShim.Deno.cwd();
-  if (hasNodeProcess) return nodeProcess!.cwd();
+  if (runtimeProcess) return runtimeProcess.cwd();
   throw new Error("cwd() is not supported in this runtime");
 }
 
@@ -37,8 +50,8 @@ export function chdir(directory: string): void {
     dntShim.Deno.chdir(directory);
     return;
   }
-  if (hasNodeProcess) {
-    nodeProcess!.chdir(directory);
+  if (runtimeProcess) {
+    runtimeProcess.chdir(directory);
     return;
   }
   throw new Error("chdir() is not supported in this runtime");
@@ -46,10 +59,20 @@ export function chdir(directory: string): void {
 
 export function env(): Record<string, string> {
   if (IS_DENO) return dntShim.Deno.env.toObject();
-  if (hasNodeProcess) return nodeProcess!.env as Record<string, string>;
+  if (runtimeProcess) return runtimeProcess.env as Record<string, string>;
   return {};
 }
 
+/**
+ * Read a host-level environment variable without consulting any project env overlay.
+ * Use this for framework-owned runtime configuration that should not be shadowed by tenant env.
+ */
+export function getHostEnv(key: string): string | undefined {
+  if (IS_DENO) return dntShim.Deno.env.get(key);
+  if (runtimeProcess) return runtimeProcess.env[key];
+  return undefined;
+}
+
 // Lazy-loaded references to project-env/storage.ts functions.
 // Uses globalThis to avoid circular imports (process.ts is low-level, project-env is high-level).
 // IMPORTANT: Only cache when the real getter is found. If storage.ts hasn't loaded yet,
@@ -95,9 +118,7 @@ export function getEnv(key: string): string | undefined {
   // reading host-level secrets like AWS_SECRET_ACCESS_KEY, DATABASE_URL, etc.
   if (isProjectEnvActiveSafe()) return undefined;
 
-  if (IS_DENO) return dntShim.Deno.env.get(key);
-  if (hasNodeProcess) return nodeProcess!.env[key];
-  return undefined;
+  return getHostEnv(key);
 }
 
 const DEFAULT_ENV_TRUE_VALUES = ["1", "true", "yes"] as const;
@@ -167,8 +188,8 @@ export function setEnv(key: string, value: string): void {
     dntShim.Deno.env.set(key, value);
     return;
   }
-  if (hasNodeProcess) {
-    nodeProcess!.env[key] = value;
+  if (runtimeProcess) {
+    runtimeProcess.env[key] = value;
     return;
   }
   throw new Error("setEnv() is not supported in this runtime");
@@ -179,8 +200,8 @@ export function deleteEnv(key: string): void {
     dntShim.Deno.env.delete(key);
     return;
   }
-  if (hasNodeProcess) {
-    delete nodeProcess!.env[key];
+  if (runtimeProcess) {
+    delete runtimeProcess.env[key];
     return;
   }
   throw new Error("deleteEnv() is not supported in this runtime");
@@ -209,7 +230,7 @@ export function getEnvOverlayStorage(): EnvOverlayStorage | null {
 
 export function pid(): number {
   if (IS_DENO) return dntShim.Deno.pid;
-  if (hasNodeProcess) return nodeProcess!.pid;
+  if (runtimeProcess) return runtimeProcess.pid;
   return 0;
 }
 
@@ -224,9 +245,11 @@ export function memoryUsage(): {
     return { rss, heapTotal, heapUsed, external };
   }
 
-  if (!hasNodeProcess) throw new Error("memoryUsage() is not supported in this runtime");
+  if (!runtimeProcess) {
+    throw new Error("memoryUsage() is not supported in this runtime");
+  }
 
-  const { rss, heapTotal, heapUsed, external } = nodeProcess!.memoryUsage();
+  const { rss, heapTotal, heapUsed, external } = runtimeProcess.memoryUsage();
   return { rss, heapTotal, heapUsed, external: external || 0 };
 }
 
@@ -235,7 +258,7 @@ export function memoryUsage(): {
  */
 export function isInteractive(): boolean {
   if (IS_DENO) return dntShim.Deno.stdin.isTerminal();
-  if (hasNodeProcess) return nodeProcess!.stdin.isTTY ?? false;
+  if (runtimeProcess) return runtimeProcess.stdin.isTTY ?? false;
   return false;
 }
 
@@ -244,7 +267,7 @@ export function isInteractive(): boolean {
  */
 export function isStdoutTTY(): boolean {
   if (IS_DENO) return dntShim.Deno.stdout.isTerminal();
-  if (hasNodeProcess) return nodeProcess!.stdout.isTTY ?? false;
+  if (runtimeProcess) return runtimeProcess.stdout.isTTY ?? false;
   return false;
 }
 
@@ -259,15 +282,16 @@ export function getTerminalSize(): { columns: number; rows: number } {
     try {
       const { columns, rows } = dntShim.Deno.consoleSize();
       return { columns, rows };
-    } catch {
+    } catch (_) {
+      /* expected: Deno.consoleSize() fails when not attached to a terminal */
       return defaultSize;
     }
   }
 
-  if (!hasNodeProcess) return defaultSize;
+  if (!runtimeProcess) return defaultSize;
 
-  const columns = nodeProcess!.stdout?.columns;
-  const rows = nodeProcess!.stdout?.rows;
+  const columns = runtimeProcess.stdout?.columns;
+  const rows = runtimeProcess.stdout?.rows;
   if (columns && rows) return { columns, rows };
 
   return defaultSize;
@@ -281,7 +305,7 @@ export function getRuntimeVersion(): string {
   if ("Bun" in dntShim.dntGlobalThis) {
     return `Bun ${(dntShim.dntGlobalThis as unknown as { Bun: { version: string } }).Bun.version}`;
   }
-  if (hasNodeProcess) return `Node.js ${nodeProcess!.version}`;
+  if (runtimeProcess) return `Node.js ${runtimeProcess.version}`;
   return "unknown";
 }
 
@@ -291,9 +315,9 @@ export function getRuntimeVersion(): string {
  */
 export function getOsType(): string {
   if (IS_DENO) return dntShim.Deno.build.os;
-  if (hasNodeProcess) {
+  if (runtimeProcess) {
     // Node/Bun uses process.platform which returns "win32" for Windows
-    const platform = nodeProcess!.platform;
+    const platform = runtimeProcess.platform;
     return platform === "win32" ? "windows" : platform;
   }
   return "unknown";
@@ -310,7 +334,7 @@ export function onSignal(
     dntShim.Deno.addSignalListener(signal, handler);
     return;
   }
-  if (hasNodeProcess) nodeProcess!.on(signal, handler);
+  if (runtimeProcess) runtimeProcess.on(signal, handler);
 }
 
 /**
@@ -326,6 +350,7 @@ export function onGlobalError(
   onError: (error: Error, type: "uncaughtException" | "unhandledRejection") => boolean | void,
 ): void {
   if (IS_DENO) {
+    // Intentionally permanent: process-level handlers must persist for the entire runtime
     globalThis.addEventListener("error", (event) => {
       const error = event.error instanceof Error ? event.error : new Error(String(event.error));
       if (onError(error, "uncaughtException")) event.preventDefault();
@@ -339,7 +364,7 @@ export function onGlobalError(
     return;
   }
 
-  if (!hasNodeProcess) return;
+  if (!runtimeProcess) return;
 
   const handleNodeGlobalError = (
     error: Error,
@@ -360,14 +385,14 @@ export function onGlobalError(
     // Node/Bun suppress default fatal behavior when a listener is registered.
     // If the callback did not explicitly handle the error, exit to preserve
     // expected fatal semantics for uncaught exceptions and unhandled rejections.
-    nodeProcess!.exit(1);
+    runtimeProcess.exit(1);
   };
 
-  nodeProcess!.on("uncaughtException", (error: Error) => {
+  runtimeProcess.on("uncaughtException", (error: Error) => {
     handleNodeGlobalError(error, "uncaughtException");
   });
 
-  nodeProcess!.on("unhandledRejection", (reason: unknown) => {
+  runtimeProcess.on("unhandledRejection", (reason: unknown) => {
     const error = reason instanceof Error ? reason : new Error(String(reason));
     handleNodeGlobalError(error, "unhandledRejection");
   });
@@ -392,7 +417,7 @@ export function unrefTimer(timerId: ReturnType<typeof dntShim.setInterval>): voi
  */
 export function execPath(): string {
   if (IS_DENO) return dntShim.Deno.execPath();
-  if (hasNodeProcess) return nodeProcess!.execPath;
+  if (runtimeProcess) return runtimeProcess.execPath;
   return "";
 }
 
@@ -405,9 +430,9 @@ export function uptime(): number {
     // Deno.osUptime() returns system uptime in seconds
     return dntShim.Deno.osUptime?.() ?? 0;
   }
-  if (hasNodeProcess) {
+  if (runtimeProcess) {
     // process.uptime() returns process uptime in seconds
-    return nodeProcess!.uptime?.() ?? 0;
+    return runtimeProcess.uptime?.() ?? 0;
   }
   return 0;
 }
@@ -421,8 +446,8 @@ export function getStdout(): { write: (data: string) => void } | null {
     const encoder = new TextEncoder();
     return { write: (data: string) => dntShim.Deno.stdout.writeSync(encoder.encode(data)) };
   }
-  if (hasNodeProcess && nodeProcess!.stdout) {
-    return { write: (data: string) => nodeProcess!.stdout.write(data) };
+  if (runtimeProcess?.stdout) {
+    return { write: (data: string) => runtimeProcess.stdout.write(data) };
   }
   return null;
 }
@@ -442,9 +467,9 @@ export function writeStdout(text: string): void {
 export async function writeStdoutAsync(data: Uint8Array): Promise<number> {
   if (IS_DENO) return await dntShim.Deno.stdout.write(data);
 
-  if (hasNodeProcess && nodeProcess!.stdout) {
+  if (runtimeProcess?.stdout) {
     return await new Promise((resolve, reject) => {
-      nodeProcess!.stdout.write(data, (error) => {
+      runtimeProcess.stdout.write(data, (error) => {
         if (error) reject(error);
         else resolve(data.length);
       });
@@ -476,7 +501,7 @@ export function readStdinByteSync(): number | null {
 
   if (IS_DENO) {
     const n = dntShim.Deno.stdin.readSync(buf);
-    return n ? buf[0]! : null;
+    return n ? buf[0] ?? null : null;
   }
 
   if (IS_BUN) {
@@ -550,15 +575,15 @@ function createProcessTimeout(
       timedOut = true;
       try {
         terminate();
-      } catch {
-        // Best-effort terminate.
+      } catch (_) {
+        /* expected: best-effort terminate may fail if process already exited */
       }
 
       forceKillId = dntShim.setTimeout(() => {
         try {
           forceTerminate();
-        } catch {
-          // Best-effort force terminate.
+        } catch (_) {
+          /* expected: best-effort force terminate may fail if process already exited */
         }
       }, FORCE_KILL_GRACE_MS);
     }, timeoutMs);
@@ -647,7 +672,9 @@ export async function runCommand(
         capture && child.stderr ? readStreamToString(child.stderr) : Promise.resolve(undefined),
       ]);
 
-      if (timeout.hasTimedOut()) return createTimeoutResult(effectiveTimeoutMs!, stdout, stderr);
+      if (timeout.hasTimedOut()) {
+        return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+      }
 
       return {
         success: status.success,
@@ -710,7 +737,9 @@ export async function runCommand(
         capture && proc.stderr ? readStreamToString(proc.stderr) : Promise.resolve(undefined),
       ]);
 
-      if (timeout.hasTimedOut()) return createTimeoutResult(effectiveTimeoutMs!, stdout, stderr);
+      if (timeout.hasTimedOut()) {
+        return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+      }
 
       return { success: code === 0, code, stdout, stderr };
     } finally {
@@ -718,7 +747,7 @@ export async function runCommand(
     }
   }
 
-  if (!hasNodeProcess) return { success: false, code: 1 };
+  if (!runtimeProcess) return { success: false, code: 1 };
 
   const { spawn } = await dynamicImport<typeof import("node:child_process")>("node:child_process");
 
@@ -735,7 +764,7 @@ export async function runCommand(
   return await new Promise((resolve) => {
     const child = spawn(cmd, args, {
       cwd: cmdCwd,
-      env: cmdEnv ? { ...nodeProcess!.env, ...cmdEnv } : undefined,
+      env: cmdEnv ? { ...runtimeProcess.env, ...cmdEnv } : undefined,
       stdio: nodeStdio,
       shell,
     });
@@ -764,7 +793,7 @@ export async function runCommand(
       if (timeout.hasTimedOut()) {
         resolve(
           createTimeoutResult(
-            effectiveTimeoutMs!,
+            effectiveTimeoutMs ?? 0,
             capture ? stdout : undefined,
             capture ? stderr : undefined,
           ),

package/src/src/platform/compat/react-paths.ts

@@ -43,8 +43,8 @@ function resolveReactSpecifier(specifier: string): string | undefined {
       const resolved = require.resolve(specifier);
       return pathToFileURL(resolved).href;
     }
-  } catch {
-    // Resolution failed, return undefined
+  } catch (_) {
+    /* expected: module resolution may fail in some runtimes */
   }
 
   return undefined;

package/src/src/platform/compat/runtime.ts

@@ -42,7 +42,8 @@ function isDenoCompiledBinary(): boolean {
 
   try {
     return testDenoCompiledDetection(dntShim.Deno.execPath());
-  } catch {
+  } catch (_) {
+    /* expected: Deno.execPath() may not be available in all environments */
     return false;
   }
 }

package/src/src/platform/compat/stdin.ts

@@ -116,19 +116,20 @@ export function getStdinReader(): StdinReader {
  * Works in both Deno and Node.js.
  */
 export function waitForKeypress(): Promise<void> {
-  return new Promise((resolve) => {
-    if (isDeno) {
+  if (isDeno) {
+    return (async () => {
       dntShim.Deno.stdin.setRaw(true);
       const reader = dntShim.Deno.stdin.readable.getReader();
-
-      reader.read().then(() => {
+      try {
+        await reader.read();
+      } finally {
         dntShim.Deno.stdin.setRaw(false);
         reader.releaseLock();
-        resolve();
-      });
-      return;
-    }
+      }
+    })();
+  }
 
+  return new Promise((resolve) => {
     const stdin = process?.stdin;
     if (!stdin) {
       resolve();
@@ -256,6 +257,7 @@ export function waitForEnterOrExit(): Promise<boolean> {
     };
 
     const onData = (data: Uint8Array) => {
+      if (data.length === 0) return;
       const key = data[0];
       if (key === CTRL_C) {
         cleanup(false);