@veryfront/ext-observability-opentelemetry 0.1.1032 → 0.1.1035

package/esm/src/platform/compat/path/resolution.js

@@ -0,0 +1,121 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { isDeno, nodePath } from "./runtime.js";
+function hasWindowsLikePath(path) {
+    return path.includes("\\") || /^[A-Za-z]:/.test(path) || path.startsWith("\\\\");
+}
+/** Normalize backslashes to forward slashes (for Deno on Windows). */
+function normSep(p) {
+    return p.includes("\\") ? p.replace(/\\/g, "/") : p;
+}
+/** Match Windows drive letter prefix like "C:/" */
+const DRIVE_LETTER = /^[A-Za-z]:\//;
+/** Resolve path segments to an absolute path. */
+export function resolve(...paths) {
+    if (!isDeno && nodePath && !paths.some(hasWindowsLikePath))
+        return nodePath.resolve(...paths);
+    let resolvedPath = normSep(dntShim.dntGlobalThis.Deno?.cwd?.() ?? "/");
+    for (const rawPath of paths) {
+        if (!rawPath)
+            continue;
+        const path = normSep(rawPath);
+        if (path.startsWith("/") || DRIVE_LETTER.test(path)) {
+            resolvedPath = path;
+        }
+        else {
+            resolvedPath = `${resolvedPath}/${path}`;
+        }
+    }
+    // Preserve drive letter prefix (e.g. "D:/") if present
+    let prefix = "/";
+    const driveMatch = resolvedPath.match(DRIVE_LETTER);
+    if (driveMatch) {
+        prefix = driveMatch[0]; // e.g. "D:/"
+        resolvedPath = resolvedPath.slice(prefix.length);
+    }
+    else if (resolvedPath.startsWith("/")) {
+        resolvedPath = resolvedPath.slice(1);
+    }
+    const parts = resolvedPath.split("/").filter(Boolean);
+    const resolved = [];
+    for (const part of parts) {
+        if (part === "..") {
+            resolved.pop();
+            continue;
+        }
+        if (part !== ".")
+            resolved.push(part);
+    }
+    return `${prefix}${resolved.join("/")}`;
+}
+export function isAbsolute(path) {
+    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;
+    return /^\\\\[^\\]+\\[^\\]+/.test(path);
+}
+export function relative(from, to) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(from) && !hasWindowsLikePath(to)) {
+        const relativePath = nodePath.relative(from, to);
+        return relativePath || ".";
+    }
+    const resolvedFrom = resolve(from);
+    const resolvedTo = resolve(to);
+    // Strip drive prefix for comparison (both will share the same drive after resolve)
+    const fromDrive = resolvedFrom.match(DRIVE_LETTER);
+    const fromBase = fromDrive ? resolvedFrom.slice(fromDrive[0].length) : resolvedFrom.slice(1);
+    const toDrive = resolvedTo.match(DRIVE_LETTER);
+    const toBase = toDrive ? resolvedTo.slice(toDrive[0].length) : resolvedTo.slice(1);
+    const fromParts = fromBase.split("/").filter(Boolean);
+    const toParts = toBase.split("/").filter(Boolean);
+    let common = 0;
+    const minLen = Math.min(fromParts.length, toParts.length);
+    for (let i = 0; i < minLen; i++) {
+        if (fromParts[i] !== toParts[i])
+            break;
+        common++;
+    }
+    const ups = fromParts.length - common;
+    const result = [...new Array(ups).fill(".."), ...toParts.slice(common)];
+    return result.join("/") || ".";
+}
+export function normalize(path) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(path))
+        return nodePath.normalize(path);
+    if (path === "")
+        return ".";
+    const p = normSep(path);
+    const abs = isAbsolute(p);
+    // Preserve drive letter prefix
+    let prefix = "";
+    const driveMatch = p.match(DRIVE_LETTER);
+    if (driveMatch) {
+        prefix = driveMatch[0];
+    }
+    else if (abs) {
+        prefix = "/";
+    }
+    const pathWithoutPrefix = driveMatch ? p.slice(prefix.length) : abs ? p.slice(1) : p;
+    const parts = pathWithoutPrefix.split("/").filter((s) => s && s !== ".");
+    const normalized = [];
+    for (const part of parts) {
+        if (part !== "..") {
+            normalized.push(part);
+            continue;
+        }
+        const last = normalized[normalized.length - 1];
+        if (normalized.length > 0 && last !== "..") {
+            normalized.pop();
+            continue;
+        }
+        if (!abs)
+            normalized.push("..");
+    }
+    const result = normalized.join("/");
+    if (abs)
+        return result ? `${prefix}${result}` : prefix || "/";
+    return result || ".";
+}

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

@@ -0,0 +1,8 @@
+import type { NodePathModule } from "./types.js";
+export declare const isDeno: boolean;
+declare let nodePath: NodePathModule | null;
+export { nodePath };
+export declare const sep: string;
+export declare const delimiter: string;
+export declare const hasNodePath: boolean;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAKjD,eAAO,MAAM,MAAM,SAAsC,CAAC;AAE1D,QAAA,IAAI,QAAQ,EAAE,cAAc,GAAG,IAAW,CAAC;AAa3C,OAAO,EAAE,QAAQ,EAAE,CAAC;AAEpB,eAAO,MAAM,GAAG,QAAuB,CAAC;AACxC,eAAO,MAAM,SAAS,QAA6B,CAAC;AACpD,eAAO,MAAM,WAAW,SAAoB,CAAC"}

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

@@ -0,0 +1,20 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+const globalProcess = dntShim.dntGlobalThis.process;
+const hasNodeApis = !!globalProcess?.versions?.node || "Bun" in dntShim.dntGlobalThis;
+export const isDeno = typeof dntShim.Deno !== "undefined";
+let nodePath = null;
+if (hasNodeApis) {
+    try {
+        const nodeRequire = typeof require !== "undefined" ? require : null;
+        if (nodeRequire) {
+            nodePath = nodeRequire("node:path");
+        }
+    }
+    catch (_) {
+        /* expected: node:path require may fail in non-Node runtimes */
+    }
+}
+export { nodePath };
+export const sep = nodePath?.sep ?? "/";
+export const delimiter = nodePath?.delimiter ?? ":";
+export const hasNodePath = nodePath !== null;

package/esm/src/platform/compat/path/types.d.ts

@@ -0,0 +1,22 @@
+export interface PathObject {
+    root?: string;
+    dir?: string;
+    base?: string;
+    ext?: string;
+    name?: string;
+}
+export interface NodePathModule {
+    sep: string;
+    delimiter: string;
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+    dirname(path: string): string;
+    basename(path: string, ext?: string): string;
+    extname(path: string): string;
+    isAbsolute(path: string): boolean;
+    relative(from: string, to: string): string;
+    normalize(path: string): string;
+    parse(path: string): PathObject;
+    format(pathObject: PathObject): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/src/platform/compat/path/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACjC,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACpC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAChC,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;CACxC"}

package/esm/src/platform/compat/path/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+export interface CommandResult {
+    success: boolean;
+    code: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface CommandOptions {
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    /** Capture stdout/stderr to return in result */
+    capture?: boolean;
+    /** Inherit stdio from parent process (shows output in terminal) */
+    inherit?: boolean;
+    /** Use shell to run the command (needed for .cmd files on Windows) */
+    shell?: boolean;
+    /** Kill the command if it exceeds this duration (milliseconds) */
+    timeoutMs?: number;
+}
+/**
+ * Run a command and return the result.
+ * Works across Deno, Node.js, and Bun.
+ *
+ * @param cmd - Command to run
+ * @param options - Command options
+ * @param options.capture - Capture stdout/stderr to return in result
+ * @param options.inherit - Inherit stdio from parent (shows output in terminal)
+ * @param options.shell - Use shell to run command (needed for .cmd on Windows)
+ */
+export declare function runCommand(cmd: string, options?: CommandOptions): Promise<CommandResult>;
+//# sourceMappingURL=command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/command.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA6ED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAuLxB"}

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

@@ -0,0 +1,194 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { dynamicImport } from "../dynamic-import.js";
+import { getDenoRuntime, isBun as IS_BUN, isDeno as IS_DENO } from "../runtime.js";
+import { isWindowsPlatform, runtimeProcess } from "./runtime-process.js";
+const COMMAND_TIMEOUT_EXIT_CODE = 124;
+const FORCE_KILL_GRACE_MS = 250;
+function createTimeoutResult(timeoutMs, stdout, stderr) {
+    return {
+        success: false,
+        code: COMMAND_TIMEOUT_EXIT_CODE,
+        stdout,
+        stderr: `${stderr ?? ""}\nCommand timed out after ${timeoutMs}ms`.trim(),
+    };
+}
+function createProcessTimeout(timeoutMs, terminate, forceTerminate) {
+    let timedOut = false;
+    let timeoutId;
+    let forceKillId;
+    if (timeoutMs && timeoutMs > 0) {
+        timeoutId = dntShim.setTimeout(() => {
+            timedOut = true;
+            try {
+                terminate();
+            }
+            catch (_) {
+                /* expected: best-effort terminate may fail if process already exited */
+            }
+            forceKillId = dntShim.setTimeout(() => {
+                try {
+                    forceTerminate();
+                }
+                catch (_) {
+                    /* expected: best-effort force terminate may fail if process already exited */
+                }
+            }, FORCE_KILL_GRACE_MS);
+        }, timeoutMs);
+    }
+    return {
+        hasTimedOut: () => timedOut,
+        clear: () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (forceKillId)
+                clearTimeout(forceKillId);
+        },
+    };
+}
+async function readStreamToString(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value)
+            chunks.push(value);
+    }
+    const total = chunks.reduce((acc, c) => acc + c.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return new TextDecoder().decode(merged);
+}
+/**
+ * Run a command and return the result.
+ * Works across Deno, Node.js, and Bun.
+ *
+ * @param cmd - Command to run
+ * @param options - Command options
+ * @param options.capture - Capture stdout/stderr to return in result
+ * @param options.inherit - Inherit stdio from parent (shows output in terminal)
+ * @param options.shell - Use shell to run command (needed for .cmd on Windows)
+ */
+export async function runCommand(cmd, options = {}) {
+    const { args = [], cwd: cmdCwd, env: cmdEnv, capture = false, inherit = false, shell = false, timeoutMs, } = options;
+    const effectiveTimeoutMs = timeoutMs && timeoutMs > 0 ? Math.floor(timeoutMs) : undefined;
+    // Determine stdio mode: inherit > capture > null
+    const stdioMode = inherit ? "inherit" : capture ? "piped" : "null";
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        const command = new deno.Command(cmd, {
+            args,
+            cwd: cmdCwd,
+            env: cmdEnv,
+            stdin: inherit ? "inherit" : "null",
+            stdout: stdioMode,
+            stderr: stdioMode,
+        });
+        const child = command.spawn();
+        const timeout = createProcessTimeout(effectiveTimeoutMs, () => child.kill("SIGTERM"), () => child.kill("SIGKILL"));
+        try {
+            const [status, stdout, stderr] = await Promise.all([
+                child.status,
+                capture && child.stdout ? readStreamToString(child.stdout) : Promise.resolve(undefined),
+                capture && child.stderr ? readStreamToString(child.stderr) : Promise.resolve(undefined),
+            ]);
+            if (timeout.hasTimedOut()) {
+                return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+            }
+            return {
+                success: status.success,
+                code: status.code,
+                stdout,
+                stderr,
+            };
+        }
+        finally {
+            timeout.clear();
+        }
+    }
+    if (IS_BUN) {
+        const bunGlobal = dntShim.dntGlobalThis;
+        const bunStdio = inherit ? "inherit" : capture ? "pipe" : "ignore";
+        const isWindows = isWindowsPlatform();
+        const bunCmd = shell
+            ? args.length === 0
+                ? isWindows ? ["cmd", "/c", cmd] : ["sh", "-c", cmd]
+                : isWindows
+                    ? ["cmd", "/c", cmd, ...args]
+                    : ["sh", "-c", 'exec "$@"', "sh", cmd, ...args]
+            : [cmd, ...args];
+        const proc = bunGlobal.Bun.spawn({
+            cmd: bunCmd,
+            cwd: cmdCwd,
+            env: cmdEnv,
+            stdout: bunStdio,
+            stderr: bunStdio,
+        });
+        const timeout = createProcessTimeout(effectiveTimeoutMs, () => proc.kill?.("SIGTERM"), () => proc.kill?.("SIGKILL"));
+        try {
+            const [code, stdout, stderr] = await Promise.all([
+                proc.exited,
+                capture && proc.stdout ? readStreamToString(proc.stdout) : Promise.resolve(undefined),
+                capture && proc.stderr ? readStreamToString(proc.stderr) : Promise.resolve(undefined),
+            ]);
+            if (timeout.hasTimedOut()) {
+                return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+            }
+            return { success: code === 0, code, stdout, stderr };
+        }
+        finally {
+            timeout.clear();
+        }
+    }
+    if (!runtimeProcess)
+        return { success: false, code: 1 };
+    const process = runtimeProcess;
+    const { spawn } = await dynamicImport("node:child_process");
+    const nodeStdio = inherit
+        ? ["inherit", "inherit", "inherit"]
+        : capture
+            ? ["ignore", "pipe", "pipe"]
+            : ["ignore", "ignore", "ignore"];
+    return await new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd: cmdCwd,
+            env: cmdEnv ? { ...process.env, ...cmdEnv } : undefined,
+            stdio: nodeStdio,
+            shell,
+        });
+        let stdout = "";
+        let stderr = "";
+        const decoder = new TextDecoder();
+        const timeout = createProcessTimeout(effectiveTimeoutMs, () => child.kill("SIGTERM"), () => child.kill("SIGKILL"));
+        if (capture) {
+            child.stdout?.on("data", (data) => {
+                stdout += decoder.decode(data);
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += decoder.decode(data);
+            });
+        }
+        child.on("close", (code) => {
+            timeout.clear();
+            if (timeout.hasTimedOut()) {
+                resolve(createTimeoutResult(effectiveTimeoutMs ?? 0, capture ? stdout : undefined, capture ? stderr : undefined));
+                return;
+            }
+            resolve({
+                success: code === 0,
+                code: code ?? 1,
+                stdout: capture ? stdout : undefined,
+                stderr: capture ? stderr : undefined,
+            });
+        });
+        child.on("error", () => {
+            timeout.clear();
+            resolve({ success: false, code: 1 });
+        });
+    });
+}

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;
+}