veryfront 0.1.215 → 0.1.217

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

@@ -0,0 +1,175 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { 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 };
+}
+export function env() {
+    const base = IS_DENO
+        ? dntShim.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;
+    }
+    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 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();
+}
+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;
+}
+export function setEnv(key, value) {
+    const overlay = getEnvOverlayStore();
+    if (overlay) {
+        overlay.set(key, value);
+        return;
+    }
+    if (IS_DENO) {
+        dntShim.Deno.env.set(key, value);
+        return;
+    }
+    if (runtimeProcess) {
+        runtimeProcess.env[key] = value;
+        return;
+    }
+    throw new Error("setEnv() is not supported in this runtime");
+}
+export function deleteEnv(key) {
+    const overlay = getEnvOverlayStore();
+    if (overlay) {
+        overlay.set(key, null);
+        return;
+    }
+    if (IS_DENO) {
+        dntShim.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,98 @@
+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;
+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,CAIlC;AAED,yFAAyF;AACzF,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAIzC;AAED,wBAAgB,GAAG,IAAI,MAAM,CAI5B;AAED,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAU7C;AAED,wBAAgB,GAAG,IAAI,MAAM,CAI5B;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,CAYA;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAIvC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAIrC;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAoBnE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAO1C;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAQlC;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,IAAI,GAClB,IAAI,CAMN;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,CAShF;AAED;;GAEG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CAIjC;AAED;;;GAGG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAU/B;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAAG,IAAI,CAUpE;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,CAcxE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG1D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAsBjD"}

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

@@ -0,0 +1,305 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { 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() {
+    if (IS_DENO)
+        return dntShim.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) {
+    if (IS_DENO)
+        dntShim.Deno.exit(code);
+    if (runtimeProcess)
+        runtimeProcess.exit(code);
+    throw new Error("exit() is not supported in this runtime");
+}
+export function cwd() {
+    if (IS_DENO)
+        return dntShim.Deno.cwd();
+    if (runtimeProcess)
+        return runtimeProcess.cwd();
+    throw new Error("cwd() is not supported in this runtime");
+}
+export function chdir(directory) {
+    if (IS_DENO) {
+        dntShim.Deno.chdir(directory);
+        return;
+    }
+    if (runtimeProcess) {
+        runtimeProcess.chdir(directory);
+        return;
+    }
+    throw new Error("chdir() is not supported in this runtime");
+}
+export function pid() {
+    if (IS_DENO)
+        return dntShim.Deno.pid;
+    if (runtimeProcess)
+        return runtimeProcess.pid;
+    return 0;
+}
+export function memoryUsage() {
+    if (IS_DENO) {
+        const { rss, heapTotal, heapUsed, external } = dntShim.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() {
+    if (IS_DENO)
+        return dntShim.Deno.stdin.isTerminal();
+    if (runtimeProcess)
+        return runtimeProcess.stdin.isTTY ?? false;
+    return false;
+}
+/**
+ * Check if stdout is a TTY (terminal)
+ */
+export function isStdoutTTY() {
+    if (IS_DENO)
+        return dntShim.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 };
+    if (IS_DENO) {
+        try {
+            const { columns, rows } = dntShim.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() {
+    if (IS_DENO)
+        return `Deno ${dntShim.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() {
+    if (IS_DENO)
+        return dntShim.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) {
+    if (IS_DENO) {
+        dntShim.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) {
+    if (IS_DENO && typeof dntShim.Deno.unrefTimer === "function") {
+        dntShim.Deno.unrefTimer(timerId);
+        return;
+    }
+    if (timerId && typeof timerId === "object" && "unref" in timerId) {
+        timerId.unref();
+    }
+}
+/**
+ * Get the executable path of the current runtime
+ */
+export function execPath() {
+    if (IS_DENO)
+        return dntShim.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() {
+    if (IS_DENO) {
+        // Deno.osUptime() returns system uptime in seconds
+        return dntShim.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() {
+    if (IS_DENO) {
+        const encoder = new TextEncoder();
+        return { write: (data) => dntShim.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) {
+    if (IS_DENO)
+        return await dntShim.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);
+    if (IS_DENO) {
+        const n = dntShim.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,CAK3C"}

package/esm/src/platform/compat/process/runtime-process.js

@@ -0,0 +1,24 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { isDeno as IS_DENO } from "../runtime.js";
+const nodeProcess = dntShim.dntGlobalThis.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) {
+    if (!processLike || typeof processLike !== "object")
+        return false;
+    const versions = processLike.versions;
+    return typeof versions?.node === "string" && versions.node.length > 0;
+}
+export const runtimeProcess = testHasRuntimeProcess(nodeProcess)
+    ? nodeProcess
+    : null;
+export function isWindowsPlatform() {
+    if (IS_DENO)
+        return dntShim.Deno.build.os === "windows";
+    const platform = runtimeProcess?.platform ??
+        dntShim.dntGlobalThis.process?.platform;
+    return platform === "win32";
+}