@veryfront/ext-content-mdx 0.1.985

package/esm/src/platform/compat/process/env.d.ts

@@ -0,0 +1,35 @@
+export type EnvOverlayStorage = {
+    getStore: () => unknown;
+    run?: <T>(store: unknown, fn: () => T) => T;
+    enterWith?: (store: unknown) => void;
+};
+/** Read and write process environment variables. */
+export declare function env(): Record<string, string>;
+/**
+ * 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 declare function getHostEnv(key: string): string | undefined;
+/** Read an environment variable from the active project scope. */
+export declare function getEnv(key: string): string | undefined;
+export interface EnvBooleanOptions {
+    trueValues?: readonly string[];
+    falseValues?: readonly string[];
+    trim?: boolean;
+    caseSensitive?: boolean;
+}
+export declare function getEnvString(key: string): string | undefined;
+export declare function getEnvString(key: string, fallback: string): string;
+export declare function getEnvNumber(key: string): number | undefined;
+export declare function getEnvNumber(key: string, fallback: number): number;
+export declare function getEnvBoolean(key: string, fallback?: boolean, options?: EnvBooleanOptions): boolean;
+/** Sets env. */
+export declare function setEnv(key: string, value: string): void;
+/** Delete a process environment variable. */
+export declare function deleteEnv(key: string): void;
+/**
+ * Get an AsyncLocalStorage-based env overlay storage if installed.
+ * This enables per-async-context env isolation (e.g., in tests).
+ */
+export declare function getEnvOverlayStorage(): EnvOverlayStorage | null;
+//# sourceMappingURL=env.d.ts.map

package/esm/src/platform/compat/process/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/env.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACtC,CAAC;AAoBF,oDAAoD;AACpD,wBAAgB,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoB5C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAqB1D;AAqCD,kEAAkE;AAClE,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWtD;AAKD,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAUD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAC9D,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;AAOpE,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAC9D,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;AAUpE,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,UAAQ,EAChB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAmBT;AAED,gBAAgB;AAChB,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAiBvD;AAED,6CAA6C;AAC7C,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAiB3C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,GAAG,IAAI,CAS/D"}

package/esm/src/platform/compat/process/env.js

@@ -0,0 +1,194 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { getDenoRuntime, isDeno as IS_DENO } from "../runtime.js";
+import { runtimeProcess } from "./runtime-process.js";
+function getEnvOverlayStore() {
+    const storage = getEnvOverlayStorage();
+    const store = storage?.getStore();
+    return store instanceof Map ? store : null;
+}
+function getOverlayEnvValue(store, key) {
+    if (!store?.has(key)) {
+        return { hasValue: false, value: undefined };
+    }
+    const value = store.get(key);
+    return { hasValue: true, value: value ?? undefined };
+}
+/** Read and write process environment variables. */
+export function env() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    const base = deno
+        ? deno.env.toObject()
+        : runtimeProcess
+            ? { ...runtimeProcess.env }
+            : {};
+    const overlay = getEnvOverlayStore();
+    if (!overlay)
+        return base;
+    for (const [key, value] of overlay.entries()) {
+        if (value === null) {
+            delete base[key];
+            continue;
+        }
+        base[key] = value;
+    }
+    return base;
+}
+/**
+ * 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) {
+    const overlayResult = getOverlayEnvValue(getEnvOverlayStore(), key);
+    if (overlayResult.hasValue) {
+        return overlayResult.value;
+    }
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        try {
+            return deno.env.get(key);
+        }
+        catch {
+            // Under a tightened env permission allowlist (project isolation workers),
+            // reading a non-allowlisted variable throws NotCapable. Treat it as absent
+            // to match the prior `env: true` behavior where reads never threw, so
+            // optional-variable lookups degrade to undefined instead of crashing the
+            // request.
+            return undefined;
+        }
+    }
+    if (runtimeProcess)
+        return runtimeProcess.env[key];
+    return undefined;
+}
+// Lazy-loaded references to project-env/storage.ts functions.
+// Uses globalThis to avoid circular imports (process compat is low-level, project-env is high-level).
+// IMPORTANT: Only cache when the real getter is found. If storage.ts hasn't loaded yet,
+// re-check globalThis on every call to avoid permanently caching the fallback.
+let _getProjectEnv = null;
+let _isProjectEnvActive = null;
+function getProjectEnvSafe(key) {
+    if (_getProjectEnv === null) {
+        const mod = dntShim.dntGlobalThis.__vfProjectEnvGetter;
+        if (mod) {
+            _getProjectEnv = mod;
+        }
+        else {
+            return undefined;
+        }
+    }
+    return _getProjectEnv(key);
+}
+function isProjectEnvActiveSafe() {
+    if (_isProjectEnvActive === null) {
+        const mod = dntShim.dntGlobalThis.__vfProjectEnvActiveChecker;
+        if (mod) {
+            _isProjectEnvActive = mod;
+        }
+        else {
+            return false;
+        }
+    }
+    return _isProjectEnvActive();
+}
+/** Read an environment variable from the active project scope. */
+export function getEnv(key) {
+    // Check per-request project env overlay first (AsyncLocalStorage)
+    const projectValue = getProjectEnvSafe(key);
+    if (projectValue !== undefined)
+        return projectValue;
+    // When a project env overlay is active (remote project request), do NOT
+    // fall through to host process env. This prevents remote projects from
+    // reading host-level secrets like AWS_SECRET_ACCESS_KEY, DATABASE_URL, etc.
+    if (isProjectEnvActiveSafe())
+        return undefined;
+    return getHostEnv(key);
+}
+const DEFAULT_ENV_TRUE_VALUES = ["1", "true", "yes"];
+const DEFAULT_ENV_FALSE_VALUES = ["0", "false", "no"];
+function normalizeEnvToken(value, options) {
+    const normalized = options.trim ? value.trim() : value;
+    return options.caseSensitive ? normalized : normalized.toLowerCase();
+}
+export function getEnvString(key, fallback) {
+    const value = getEnv(key);
+    if (value === undefined)
+        return fallback;
+    return value;
+}
+export function getEnvNumber(key, fallback) {
+    const value = getEnvString(key);
+    if (value === undefined)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed))
+        return fallback ?? Number.NaN;
+    return parsed;
+}
+export function getEnvBoolean(key, fallback = false, options = {}) {
+    const value = getEnvString(key);
+    if (value === undefined)
+        return fallback;
+    const trim = options.trim ?? true;
+    const caseSensitive = options.caseSensitive ?? false;
+    const normalized = normalizeEnvToken(value, { trim, caseSensitive });
+    const trueValues = options.trueValues ?? DEFAULT_ENV_TRUE_VALUES;
+    for (const trueValue of trueValues) {
+        if (normalized === normalizeEnvToken(trueValue, { trim, caseSensitive }))
+            return true;
+    }
+    const falseValues = options.falseValues ?? DEFAULT_ENV_FALSE_VALUES;
+    for (const falseValue of falseValues) {
+        if (normalized === normalizeEnvToken(falseValue, { trim, caseSensitive }))
+            return false;
+    }
+    return fallback;
+}
+/** Sets env. */
+export function setEnv(key, value) {
+    const overlay = getEnvOverlayStore();
+    if (overlay) {
+        overlay.set(key, value);
+        return;
+    }
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        deno.env.set(key, value);
+        return;
+    }
+    if (runtimeProcess) {
+        runtimeProcess.env[key] = value;
+        return;
+    }
+    throw new Error("setEnv() is not supported in this runtime");
+}
+/** Delete a process environment variable. */
+export function deleteEnv(key) {
+    const overlay = getEnvOverlayStore();
+    if (overlay) {
+        overlay.set(key, null);
+        return;
+    }
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        deno.env.delete(key);
+        return;
+    }
+    if (runtimeProcess) {
+        delete runtimeProcess.env[key];
+        return;
+    }
+    throw new Error("deleteEnv() is not supported in this runtime");
+}
+/**
+ * Get an AsyncLocalStorage-based env overlay storage if installed.
+ * This enables per-async-context env isolation (e.g., in tests).
+ */
+export function getEnvOverlayStorage() {
+    const globalAny = dntShim.dntGlobalThis;
+    const overlay = globalAny["__vfTestDenoEnvOverlay"] ??
+        globalAny["__vfTestEnvOverlay"];
+    const storage = overlay?.storage;
+    if (!storage || typeof storage.getStore !== "function")
+        return null;
+    return storage;
+}

package/esm/src/platform/compat/process/lifecycle.d.ts

@@ -0,0 +1,99 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+/** Get command-line arguments (cross-runtime: Deno.args or process.argv). */
+export declare function getArgs(): string[];
+/** Exit the process with an optional code (cross-runtime: Deno.exit or process.exit). */
+export declare function exit(code?: number): never;
+/** Return the current working directory. */
+export declare function cwd(): string;
+export declare function chdir(directory: string): void;
+export declare function pid(): number;
+export declare function memoryUsage(): {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+};
+/**
+ * Check if stdin is a TTY (terminal)
+ */
+export declare function isInteractive(): boolean;
+/**
+ * Check if stdout is a TTY (terminal)
+ */
+export declare function isStdoutTTY(): boolean;
+/**
+ * Get terminal size (columns and rows)
+ * Returns default fallback values if terminal size cannot be determined
+ */
+export declare function getTerminalSize(): {
+    columns: number;
+    rows: number;
+};
+/**
+ * Get runtime version string
+ */
+export declare function getRuntimeVersion(): string;
+/**
+ * Get the operating system type
+ * Returns: "darwin" (macOS), "linux", "windows", or the raw platform string
+ */
+export declare function getOsType(): string;
+/**
+ * Register a signal handler (SIGINT, SIGTERM) for graceful shutdown
+ */
+export declare function onSignal(signal: "SIGINT" | "SIGTERM", handler: () => void): void;
+/**
+ * Register global error handlers for uncaught exceptions and unhandled promise rejections.
+ * These handlers prevent the process from crashing due to application code errors.
+ *
+ * IMPORTANT: These handlers should be registered early in the application lifecycle
+ * to catch errors that escape try/catch blocks.
+ *
+ * @param onError - Callback invoked with the error. Return true to prevent process exit.
+ */
+export declare function onGlobalError(onError: (error: Error, type: "uncaughtException" | "unhandledRejection") => boolean | void): void;
+/**
+ * Unreference a timer to prevent it from keeping the process alive
+ */
+export declare function unrefTimer(timerId: ReturnType<typeof dntShim.setInterval>): void;
+/**
+ * Get the executable path of the current runtime
+ */
+export declare function execPath(): string;
+/**
+ * Get process uptime in seconds
+ * Returns OS uptime on Deno, process uptime on Node.js
+ */
+export declare function uptime(): number;
+/**
+ * Get stdout stream for writing
+ * Returns null if not available (e.g., in browser/workers)
+ */
+export declare function getStdout(): {
+    write: (data: string) => void;
+} | null;
+/**
+ * Write text directly to stdout (sync)
+ * No-op if stdout is not available
+ */
+export declare function writeStdout(text: string): void;
+/**
+ * Write data to stdout asynchronously
+ * Returns a promise that resolves when the write is complete
+ */
+export declare function writeStdoutAsync(data: Uint8Array): Promise<number>;
+/**
+ * Synchronous prompt function that works across Deno and Bun.
+ * Displays a message and reads user input from stdin.
+ *
+ * Note: This relies on globalThis.prompt which is available in Deno and Bun.
+ * Returns null in environments where prompt is not available (e.g., Node.js ESM).
+ */
+export declare function promptSync(message?: string): string | null;
+/**
+ * Read a single byte from stdin synchronously.
+ * Requires raw mode to be enabled for character-by-character reading.
+ * Returns null on EOF or if stdin is not available.
+ */
+export declare function readStdinByteSync(): number | null;
+//# sourceMappingURL=lifecycle.d.ts.map

package/esm/src/platform/compat/process/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AAIrD,6EAA6E;AAC7E,wBAAgB,OAAO,IAAI,MAAM,EAAE,CAKlC;AAED,yFAAyF;AACzF,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAKzC;AAED,4CAA4C;AAC5C,wBAAgB,GAAG,IAAI,MAAM,CAK5B;AAED,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAW7C;AAED,wBAAgB,GAAG,IAAI,MAAM,CAK5B;AAED,wBAAgB,WAAW,IAAI;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAaA;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAKvC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAKrC;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAqBnE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAQ1C;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,CASlC;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,IAAI,GAClB,IAAI,CAON;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,mBAAmB,GAAG,oBAAoB,KAAK,OAAO,GAAG,IAAI,GAC1F,IAAI,CAiDN;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,CAahF;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAKjC;AAED;;;GAGG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAW/B;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAAG,IAAI,CAWpE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAexE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG1D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAuBjD"}

package/esm/src/platform/compat/process/lifecycle.js

@@ -0,0 +1,327 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { getDenoRuntime, isBun as IS_BUN, isDeno as IS_DENO } from "../runtime.js";
+import { runtimeProcess } from "./runtime-process.js";
+/** Get command-line arguments (cross-runtime: Deno.args or process.argv). */
+export function getArgs() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.args;
+    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) {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        deno.exit(code);
+    if (runtimeProcess)
+        runtimeProcess.exit(code);
+    throw new Error("exit() is not supported in this runtime");
+}
+/** Return the current working directory. */
+export function cwd() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.cwd();
+    if (runtimeProcess)
+        return runtimeProcess.cwd();
+    throw new Error("cwd() is not supported in this runtime");
+}
+export function chdir(directory) {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        deno.chdir(directory);
+        return;
+    }
+    if (runtimeProcess) {
+        runtimeProcess.chdir(directory);
+        return;
+    }
+    throw new Error("chdir() is not supported in this runtime");
+}
+export function pid() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.pid;
+    if (runtimeProcess)
+        return runtimeProcess.pid;
+    return 0;
+}
+export function memoryUsage() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        const { rss, heapTotal, heapUsed, external } = deno.memoryUsage();
+        return { rss, heapTotal, heapUsed, external };
+    }
+    if (!runtimeProcess) {
+        throw new Error("memoryUsage() is not supported in this runtime");
+    }
+    const { rss, heapTotal, heapUsed, external } = runtimeProcess.memoryUsage();
+    return { rss, heapTotal, heapUsed, external: external || 0 };
+}
+/**
+ * Check if stdin is a TTY (terminal)
+ */
+export function isInteractive() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.stdin.isTerminal();
+    if (runtimeProcess)
+        return runtimeProcess.stdin.isTTY ?? false;
+    return false;
+}
+/**
+ * Check if stdout is a TTY (terminal)
+ */
+export function isStdoutTTY() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.stdout.isTerminal();
+    if (runtimeProcess)
+        return runtimeProcess.stdout.isTTY ?? false;
+    return false;
+}
+/**
+ * Get terminal size (columns and rows)
+ * Returns default fallback values if terminal size cannot be determined
+ */
+export function getTerminalSize() {
+    const defaultSize = { columns: 80, rows: 24 };
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        try {
+            const { columns, rows } = deno.consoleSize();
+            return { columns, rows };
+        }
+        catch (_) {
+            /* expected: Deno.consoleSize() fails when not attached to a terminal */
+            return defaultSize;
+        }
+    }
+    if (!runtimeProcess)
+        return defaultSize;
+    const columns = runtimeProcess.stdout?.columns;
+    const rows = runtimeProcess.stdout?.rows;
+    if (columns && rows)
+        return { columns, rows };
+    return defaultSize;
+}
+/**
+ * Get runtime version string
+ */
+export function getRuntimeVersion() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return `Deno ${deno.version.deno}`;
+    if ("Bun" in dntShim.dntGlobalThis) {
+        return `Bun ${dntShim.dntGlobalThis.Bun.version}`;
+    }
+    if (runtimeProcess)
+        return `Node.js ${runtimeProcess.version}`;
+    return "unknown";
+}
+/**
+ * Get the operating system type
+ * Returns: "darwin" (macOS), "linux", "windows", or the raw platform string
+ */
+export function getOsType() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.build.os;
+    if (runtimeProcess) {
+        // Node/Bun uses process.platform which returns "win32" for Windows
+        const platform = runtimeProcess.platform;
+        return platform === "win32" ? "windows" : platform;
+    }
+    return "unknown";
+}
+/**
+ * Register a signal handler (SIGINT, SIGTERM) for graceful shutdown
+ */
+export function onSignal(signal, handler) {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        deno.addSignalListener(signal, handler);
+        return;
+    }
+    if (runtimeProcess)
+        runtimeProcess.on(signal, handler);
+}
+/**
+ * Register global error handlers for uncaught exceptions and unhandled promise rejections.
+ * These handlers prevent the process from crashing due to application code errors.
+ *
+ * IMPORTANT: These handlers should be registered early in the application lifecycle
+ * to catch errors that escape try/catch blocks.
+ *
+ * @param onError - Callback invoked with the error. Return true to prevent process exit.
+ */
+export function onGlobalError(onError) {
+    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();
+        });
+        globalThis.addEventListener("unhandledrejection", (event) => {
+            const error = event.reason instanceof Error ? event.reason : new Error(String(event.reason));
+            if (onError(error, "unhandledRejection"))
+                event.preventDefault();
+        });
+        return;
+    }
+    if (!runtimeProcess)
+        return;
+    const process = runtimeProcess;
+    const handleNodeGlobalError = (error, type) => {
+        let shouldPreventExit = false;
+        try {
+            shouldPreventExit = onError(error, type) === true;
+        }
+        catch (handlerError) {
+            const handlerException = handlerError instanceof Error
+                ? handlerError
+                : new Error(String(handlerError));
+            console.error("Global error handler threw while processing", type, handlerException);
+        }
+        if (shouldPreventExit)
+            return;
+        // 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.
+        process.exit(1);
+    };
+    runtimeProcess.on("uncaughtException", (error) => {
+        handleNodeGlobalError(error, "uncaughtException");
+    });
+    runtimeProcess.on("unhandledRejection", (reason) => {
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        handleNodeGlobalError(error, "unhandledRejection");
+    });
+}
+/**
+ * Unreference a timer to prevent it from keeping the process alive
+ */
+export function unrefTimer(timerId) {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno && typeof deno.unrefTimer === "function" && typeof timerId === "number") {
+        deno.unrefTimer(timerId);
+        return;
+    }
+    if (timerId && typeof timerId === "object") {
+        const unref = timerId.unref;
+        if (typeof unref === "function") {
+            unref.call(timerId);
+        }
+    }
+}
+/**
+ * Get the executable path of the current runtime
+ */
+export function execPath() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.execPath();
+    if (runtimeProcess)
+        return runtimeProcess.execPath;
+    return "";
+}
+/**
+ * Get process uptime in seconds
+ * Returns OS uptime on Deno, process uptime on Node.js
+ */
+export function uptime() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        // Deno.osUptime() returns system uptime in seconds
+        return deno.osUptime?.() ?? 0;
+    }
+    if (runtimeProcess) {
+        // process.uptime() returns process uptime in seconds
+        return runtimeProcess.uptime?.() ?? 0;
+    }
+    return 0;
+}
+/**
+ * Get stdout stream for writing
+ * Returns null if not available (e.g., in browser/workers)
+ */
+export function getStdout() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        const encoder = new TextEncoder();
+        return { write: (data) => deno.stdout.writeSync(encoder.encode(data)) };
+    }
+    const stdout = runtimeProcess?.stdout;
+    if (stdout) {
+        return { write: (data) => stdout.write(data) };
+    }
+    return null;
+}
+/**
+ * Write text directly to stdout (sync)
+ * No-op if stdout is not available
+ */
+export function writeStdout(text) {
+    getStdout()?.write(text);
+}
+/**
+ * Write data to stdout asynchronously
+ * Returns a promise that resolves when the write is complete
+ */
+export async function writeStdoutAsync(data) {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return await deno.stdout.write(data);
+    const stdout = runtimeProcess?.stdout;
+    if (stdout) {
+        return await new Promise((resolve, reject) => {
+            stdout.write(data, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(data.length);
+            });
+        });
+    }
+    return 0;
+}
+/**
+ * Synchronous prompt function that works across Deno and Bun.
+ * Displays a message and reads user input from stdin.
+ *
+ * Note: This relies on globalThis.prompt which is available in Deno and Bun.
+ * Returns null in environments where prompt is not available (e.g., Node.js ESM).
+ */
+export function promptSync(message) {
+    if (typeof globalThis.prompt !== "function")
+        return null;
+    return globalThis.prompt(message ?? "") ?? null;
+}
+/**
+ * Read a single byte from stdin synchronously.
+ * Requires raw mode to be enabled for character-by-character reading.
+ * Returns null on EOF or if stdin is not available.
+ */
+export function readStdinByteSync() {
+    const buf = new Uint8Array(1);
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        const n = deno.stdin.readSync(buf);
+        return n ? buf[0] ?? null : null;
+    }
+    if (IS_BUN) {
+        // Bun: read one byte from the file descriptor directly
+        const BunGlobal = dntShim.dntGlobalThis
+            .Bun;
+        const chunk = BunGlobal?.stdin?.read?.(1);
+        if (chunk && chunk.length > 0) {
+            const first = chunk.at(0);
+            return first ?? null;
+        }
+        return null;
+    }
+    return null;
+}

package/esm/src/platform/compat/process/runtime-process.d.ts

@@ -0,0 +1,10 @@
+export 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 declare function testHasRuntimeProcess(processLike: unknown): processLike is RuntimeProcess;
+export declare const runtimeProcess: RuntimeProcess | null;
+export declare function isWindowsPlatform(): boolean;
+//# sourceMappingURL=runtime-process.d.ts.map

package/esm/src/platform/compat/process/runtime-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-process.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/runtime-process.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG,cAAc,cAAc,CAAC,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,OAAO,GAAG,WAAW,IAAI,cAAc,CAIzF;AAED,eAAO,MAAM,cAAc,EAAE,cAAc,GAAG,IAEtC,CAAC;AAET,wBAAgB,iBAAiB,IAAI,OAAO,CAM3C"}