@veryfront/ext-observability-opentelemetry 0.1.1032 → 0.1.1035

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"}

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

@@ -0,0 +1,25 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { getDenoRuntime, 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() {
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno)
+        return deno.build.os === "windows";
+    const platform = runtimeProcess?.platform ??
+        dntShim.dntGlobalThis.process?.platform;
+    return platform === "win32";
+}

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

@@ -0,0 +1,5 @@
+export { deleteEnv, env, type EnvBooleanOptions, getEnv, getEnvBoolean, getEnvNumber, getEnvOverlayStorage, getEnvString, getHostEnv, setEnv, } from "./process/env.js";
+export { chdir, cwd, execPath, exit, getArgs, getOsType, getRuntimeVersion, getStdout, getTerminalSize, isInteractive, isStdoutTTY, memoryUsage, onGlobalError, onSignal, pid, promptSync, readStdinByteSync, unrefTimer, uptime, writeStdout, writeStdoutAsync, } from "./process/lifecycle.js";
+export { testHasRuntimeProcess } from "./process/runtime-process.js";
+export { type CommandOptions, type CommandResult, runCommand } from "./process/command.js";
+//# sourceMappingURL=process.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/process.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,GAAG,EACH,KAAK,iBAAiB,EACtB,MAAM,EACN,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,YAAY,EACZ,UAAU,EACV,MAAM,GACP,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,EACL,GAAG,EACH,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,aAAa,EACb,WAAW,EACX,WAAW,EACX,aAAa,EACb,QAAQ,EACR,GAAG,EACH,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,MAAM,EACN,WAAW,EACX,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,4 @@
+export { deleteEnv, env, getEnv, getEnvBoolean, getEnvNumber, getEnvOverlayStorage, getEnvString, getHostEnv, setEnv, } from "./process/env.js";
+export { chdir, cwd, execPath, exit, getArgs, getOsType, getRuntimeVersion, getStdout, getTerminalSize, isInteractive, isStdoutTTY, memoryUsage, onGlobalError, onSignal, pid, promptSync, readStdinByteSync, unrefTimer, uptime, writeStdout, writeStdoutAsync, } from "./process/lifecycle.js";
+export { testHasRuntimeProcess } from "./process/runtime-process.js";
+export { runCommand } from "./process/command.js";

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

@@ -0,0 +1,51 @@
+import * as dntShim from "../../../_dnt.shims.js";
+export declare function getDenoRuntime(): typeof dntShim.Deno | undefined;
+/**
+ * Check if an executable path is a compiled Deno binary.
+ * Detects by binary name: "deno" or "deno.exe" = standard runtime, anything else = compiled.
+ * @internal Exported for testing only.
+ */
+export declare function testDenoCompiledDetection(execPath: string): boolean;
+/** True if running in Bun runtime (check first since Bun has process.versions.node) */
+export declare const isBun: boolean;
+/** True if running in Node.js runtime (has process.versions.node, not Bun, not shimmed Deno) */
+export declare const isNode: boolean;
+/** True if running in real Deno runtime (not dnt shim) */
+export declare const isDeno: boolean;
+/**
+ * True if running in a compiled Deno binary.
+ * Compiled binaries cannot dynamically import HTTP URLs - they must use local file:// paths.
+ * This is evaluated once at module load time.
+ */
+export declare const isDenoCompiled: boolean;
+/** True if running in Cloudflare Workers runtime */
+export declare const isCloudflare: boolean;
+/**
+ * Detect if running in Node.js (vs Deno) at call time.
+ * Use this function instead of the constant when runtime detection needs to happen
+ * at call time (e.g., when bundled with esbuild's __esm lazy initialization pattern).
+ */
+export declare function isNodeRuntime(): boolean;
+/**
+ * Detect if code is executing in a server environment (SSR).
+ *
+ * This function provides consistent SSR detection that works correctly even when
+ * SSR globals stub the window/document objects. It should be used instead of
+ * `typeof window === "undefined"` checks to avoid hydration mismatches.
+ *
+ * Priority:
+ * 1. Check __VERYFRONT_SSR__ flag (set by ssr-globals/index.ts) - most reliable
+ * 2. Check if window is undefined (fallback for non-veryfront environments)
+ *
+ * @returns true if executing on server, false if in browser
+ * @see plans/architecture-audit/006.1-ssr-detection-inconsistencies.md
+ */
+export declare function isServerEnvironment(): boolean;
+/**
+ * Detect if code is executing in a browser environment.
+ * Inverse of isServerEnvironment() - use this instead of `typeof window !== "undefined"`.
+ *
+ * @returns true if executing in browser, false if on server
+ */
+export declare function isBrowserEnvironment(): boolean;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,wBAAwB,CAAC;AAelD,wBAAgB,cAAc,IAAI,OAAO,OAAO,CAAC,IAAI,GAAG,SAAS,CAWhE;AAMD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOnE;AAmBD,uFAAuF;AACvF,eAAO,MAAM,KAAK,EAAE,OAAwB,CAAC;AAE7C,gGAAgG;AAChG,eAAO,MAAM,MAAM,EAAE,OAAoC,CAAC;AAE1D,0DAA0D;AAC1D,eAAO,MAAM,MAAM,EAAE,OAA4C,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,OAA0C,CAAC;AAExE,oDAAoD;AACpD,eAAO,MAAM,YAAY,EAAE,OAAgC,CAAC;AAE5D;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAK7C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C"}

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

@@ -0,0 +1,101 @@
+import * as dntShim from "../../../_dnt.shims.js";
+function hasNodeProcess() {
+    const global = dntShim.dntGlobalThis;
+    return global.process?.versions?.node != null && !global.process?.versions?.deno;
+}
+function hasBunGlobal() {
+    return dntShim.dntGlobalThis.Bun != null;
+}
+export function getDenoRuntime() {
+    const deno = Reflect.get(dntShim.dntGlobalThis, "Deno");
+    if (deno &&
+        typeof deno.version === "object" &&
+        typeof deno.build === "object" &&
+        typeof deno.build.os === "string") {
+        return deno;
+    }
+    return undefined;
+}
+function hasRealDeno() {
+    return getDenoRuntime() != null;
+}
+/**
+ * Check if an executable path is a compiled Deno binary.
+ * Detects by binary name: "deno" or "deno.exe" = standard runtime, anything else = compiled.
+ * @internal Exported for testing only.
+ */
+export function testDenoCompiledDetection(execPath) {
+    if (!execPath)
+        return false;
+    const binaryName = execPath.split(/[/\\]/).pop()?.toLowerCase();
+    if (!binaryName)
+        return false;
+    return binaryName !== "deno" && binaryName !== "deno.exe";
+}
+/** Compiled Deno binaries cannot dynamically import HTTP URLs at runtime. */
+function isDenoCompiledBinary() {
+    const deno = getDenoRuntime();
+    if (!deno)
+        return false;
+    try {
+        return testDenoCompiledDetection(deno.execPath());
+    }
+    catch (_) {
+        /* expected: Deno.execPath() may not be available in all environments */
+        return false;
+    }
+}
+function hasCloudflareGlobals() {
+    return "caches" in dntShim.dntGlobalThis && "WebSocketPair" in dntShim.dntGlobalThis;
+}
+/** True if running in Bun runtime (check first since Bun has process.versions.node) */
+export const isBun = hasBunGlobal();
+/** True if running in Node.js runtime (has process.versions.node, not Bun, not shimmed Deno) */
+export const isNode = !isBun && hasNodeProcess();
+/** True if running in real Deno runtime (not dnt shim) */
+export const isDeno = !isNode && !isBun && hasRealDeno();
+/**
+ * True if running in a compiled Deno binary.
+ * Compiled binaries cannot dynamically import HTTP URLs - they must use local file:// paths.
+ * This is evaluated once at module load time.
+ */
+export const isDenoCompiled = isDeno && isDenoCompiledBinary();
+/** True if running in Cloudflare Workers runtime */
+export const isCloudflare = hasCloudflareGlobals();
+/**
+ * Detect if running in Node.js (vs Deno) at call time.
+ * Use this function instead of the constant when runtime detection needs to happen
+ * at call time (e.g., when bundled with esbuild's __esm lazy initialization pattern).
+ */
+export function isNodeRuntime() {
+    return !hasBunGlobal() && hasNodeProcess();
+}
+/**
+ * Detect if code is executing in a server environment (SSR).
+ *
+ * This function provides consistent SSR detection that works correctly even when
+ * SSR globals stub the window/document objects. It should be used instead of
+ * `typeof window === "undefined"` checks to avoid hydration mismatches.
+ *
+ * Priority:
+ * 1. Check __VERYFRONT_SSR__ flag (set by ssr-globals/index.ts) - most reliable
+ * 2. Check if window is undefined (fallback for non-veryfront environments)
+ *
+ * @returns true if executing on server, false if in browser
+ * @see plans/architecture-audit/006.1-ssr-detection-inconsistencies.md
+ */
+export function isServerEnvironment() {
+    const ssrFlag = dntShim.dntGlobalThis.__VERYFRONT_SSR__;
+    if (ssrFlag === true)
+        return true;
+    return typeof dntShim.dntGlobalThis === "undefined";
+}
+/**
+ * Detect if code is executing in a browser environment.
+ * Inverse of isServerEnvironment() - use this instead of `typeof window !== "undefined"`.
+ *
+ * @returns true if executing in browser, false if on server
+ */
+export function isBrowserEnvironment() {
+    return !isServerEnvironment();
+}