@frontmcp/utils 1.8.6 → 1.9.0

package/env/browser-env.d.ts

@@ -7,6 +7,7 @@
 export declare function getEnv(_key: string): string | undefined;
 export declare function getEnv(_key: string, defaultValue: string): string;
 export declare function getCwd(): string;
+export declare function getNodeEnv(): string | undefined;
 export declare function isProduction(): boolean;
 export declare function isDevelopment(): boolean;
 export declare function getEnvFlag(_key: string): boolean;

package/env/browser-env.js

@@ -23,6 +23,7 @@ __export(browser_env_exports, {
   getCwd: () => getCwd,
   getEnv: () => getEnv,
   getEnvFlag: () => getEnvFlag,
+  getNodeEnv: () => getNodeEnv,
   isDebug: () => isDebug,
   isDevelopment: () => isDevelopment,
   isEdgeRuntime: () => isEdgeRuntime,
@@ -55,6 +56,9 @@ function getEnv(_key, defaultValue) {
 function getCwd() {
   return "/";
 }
+function getNodeEnv() {
+  return void 0;
+}
 function isProduction() {
   return false;
 }
@@ -83,6 +87,7 @@ function supportsAnsi() {
   getCwd,
   getEnv,
   getEnvFlag,
+  getNodeEnv,
   isDebug,
   isDevelopment,
   isEdgeRuntime,

package/env/browser-runtime-context.d.ts

@@ -18,7 +18,7 @@ export interface RuntimeContext {
     target: string;
     env: string;
 }
-export type Surface = 'mcp' | 'cli' | 'http-trigger' | 'job' | 'agent';
+export type Surface = 'mcp' | 'cli' | 'http-trigger' | 'job' | 'agent' | 'webmcp';
 export interface CallContext {
     surface?: Surface;
 }
@@ -47,6 +47,7 @@ export declare const entryAvailabilitySchema: import("@frontmcp/lazy-zod").ZodOb
         "http-trigger": "http-trigger";
         job: "job";
         agent: "agent";
+        webmcp: "webmcp";
     }>>>;
     env: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
 }, import("zod/v4/core").$strict>;

package/env/browser-runtime-context.js

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/utils/src/env/browser-runtime-context.ts
+var browser_runtime_context_exports = {};
+__export(browser_runtime_context_exports, {
+  checkEntryAvailability: () => checkEntryAvailability,
+  detectRuntimeContext: () => detectRuntimeContext,
+  entryAvailabilitySchema: () => entryAvailabilitySchema,
+  getRuntimeContext: () => getRuntimeContext,
+  isEntryAvailable: () => isEntryAvailable,
+  resetRuntimeContext: () => resetRuntimeContext
+});
+module.exports = __toCommonJS(browser_runtime_context_exports);
+var import_lazy_zod = require("@frontmcp/lazy-zod");
+var entryAvailabilitySchema = import_lazy_zod.z.object({
+  os: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  platform: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  runtime: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  deployment: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  provider: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  target: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  surface: import_lazy_zod.z.array(import_lazy_zod.z.enum(["mcp", "cli", "http-trigger", "job", "agent", "webmcp"])).optional(),
+  env: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional()
+}).strict();
+var PROCESS_AXES = [
+  { key: "os", ctxKey: "os" },
+  { key: "platform", ctxKey: "platform" },
+  { key: "runtime", ctxKey: "runtime" },
+  { key: "deployment", ctxKey: "deployment" },
+  { key: "provider", ctxKey: "provider" },
+  { key: "target", ctxKey: "target" },
+  { key: "env", ctxKey: "env" }
+];
+function isEntryAvailable(availability, ctx, callCtx) {
+  if (!availability) return true;
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0) return false;
+    if (!allowed.includes(ctx[ctxKey])) return false;
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) return false;
+    if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) return false;
+  }
+  return true;
+}
+function checkEntryAvailability(availability, ctx, callCtx) {
+  if (!availability) return { available: true, missingAxes: [] };
+  const missing = [];
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0 || !allowed.includes(ctx[ctxKey])) missing.push(key);
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) missing.push("surface");
+    else if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) missing.push("surface");
+  }
+  return { available: missing.length === 0, missingAxes: missing };
+}
+function detectRuntimeContext() {
+  return {
+    os: "browser",
+    platform: "browser",
+    runtime: "browser",
+    deployment: "standalone",
+    provider: "bare",
+    target: "browser",
+    env: "production"
+  };
+}
+var browserContext = detectRuntimeContext();
+function getRuntimeContext() {
+  return browserContext;
+}
+function resetRuntimeContext() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkEntryAvailability,
+  detectRuntimeContext,
+  entryAvailabilitySchema,
+  getRuntimeContext,
+  isEntryAvailable,
+  resetRuntimeContext
+});

package/env/index.d.ts

@@ -1,4 +1,4 @@
-export { getEnv, getCwd, isProduction, isDevelopment, getEnvFlag, isDebug, setEnv, isEdgeRuntime, isServerless, supportsAnsi, } from '#env';
+export { getEnv, getCwd, getNodeEnv, isProduction, isDevelopment, getEnvFlag, isDebug, setEnv, isEdgeRuntime, isServerless, supportsAnsi, } from '#env';
 export { getRuntimeContext, resetRuntimeContext, detectRuntimeContext, isEntryAvailable, checkEntryAvailability, entryAvailabilitySchema, } from '#runtime-context';
 export type { RuntimeContext, EntryAvailability, Surface, CallContext } from '#runtime-context';
 export { detectProvider, resetProviderCacheForTesting } from './provider';

package/env/node-env.d.ts

@@ -4,6 +4,17 @@
 export declare function getEnv(key: string): string | undefined;
 export declare function getEnv(key: string, defaultValue: string): string;
 export declare function getCwd(): string;
+/**
+ * The NODE_ENV this process runs with.
+ *
+ * Bundlers replace `process.env.NODE_ENV` with a literal when they build —
+ * `wrangler dev` with `"development"`, `wrangler deploy` with `"production"` —
+ * so a value the deployment sets at run time (a Cloudflare Worker's
+ * `[vars] NODE_ENV`) was never seen (#680). The live value is read first,
+ * through a key no bundler folds; the build-time value only fills in when the
+ * runtime sets none.
+ */
+export declare function getNodeEnv(): string | undefined;
 export declare function isProduction(): boolean;
 export declare function isDevelopment(): boolean;
 export declare function getEnvFlag(key: string): boolean;

package/env/node-env.js

@@ -23,6 +23,7 @@ __export(node_env_exports, {
   getCwd: () => getCwd,
   getEnv: () => getEnv,
   getEnvFlag: () => getEnvFlag,
+  getNodeEnv: () => getNodeEnv,
   isDebug: () => isDebug,
   isDevelopment: () => isDevelopment,
   isEdgeRuntime: () => isEdgeRuntime,
@@ -55,11 +56,15 @@ function getEnv(key, defaultValue) {
 function getCwd() {
   return process.cwd();
 }
+var NODE_ENV_KEY = "NODE_ENV";
+function getNodeEnv() {
+  return process.env[NODE_ENV_KEY] || process.env["NODE_ENV"] || void 0;
+}
 function isProduction() {
-  return process.env["NODE_ENV"] === "production";
+  return getNodeEnv() === "production";
 }
 function isDevelopment() {
-  return process.env["NODE_ENV"] === "development";
+  return getNodeEnv() === "development";
 }
 function getEnvFlag(key) {
   const v = process.env[key];
@@ -91,6 +96,7 @@ function supportsAnsi() {
   getCwd,
   getEnv,
   getEnvFlag,
+  getNodeEnv,
   isDebug,
   isDevelopment,
   isEdgeRuntime,

package/env/runtime-context.d.ts

@@ -12,11 +12,11 @@
  *   - `os` as the new name for `platform` (alias preserved for back-compat)
  *   - `provider` (vercel / lambda / cloudflare / netlify / docker / bare / …)
  *   - `target` (the build output produced by `frontmcp build --target <x>`)
- *   - `surface` (per-call axis: mcp / cli / agent / job / http-trigger)
+ *   - `surface` (per-call axis: mcp / cli / agent / job / http-trigger / webmcp)
  */
 /**
  * Snapshot of the current runtime environment. Detected once and cached
- * for the lifetime of the process.
+ * for the lifetime of the process (`env` is read live from `NODE_ENV`).
  */
 export interface RuntimeContext {
     /** OS platform: 'darwin', 'linux', 'win32', etc. (issue #417: renamed from platform) */
@@ -39,7 +39,7 @@ export interface RuntimeContext {
  * Set by transport adapters / agent dispatchers / job runners on the
  * outgoing `ctx` so registry filtering can fork on call origin.
  */
-export type Surface = 'mcp' | 'cli' | 'http-trigger' | 'job' | 'agent';
+export type Surface = 'mcp' | 'cli' | 'http-trigger' | 'job' | 'agent' | 'webmcp';
 /** Call-context wrapper threaded through `findTool` for per-call filtering. */
 export interface CallContext {
     surface?: Surface;
@@ -82,7 +82,7 @@ export interface EntryAvailability {
     provider?: string[];
     /** Build-target constraint (issue #417). */
     target?: string[];
-    /** Surface constraint (issue #417): 'mcp', 'cli', 'agent', 'job', 'http-trigger'. */
+    /** Surface constraint (issue #417): 'mcp', 'cli', 'agent', 'job', 'http-trigger', 'webmcp'. */
     surface?: Surface[];
     /** Environment constraint: 'production', 'development', 'test', etc. */
     env?: string[];
@@ -103,6 +103,7 @@ export declare const entryAvailabilitySchema: import("@frontmcp/lazy-zod").ZodOb
         "http-trigger": "http-trigger";
         job: "job";
         agent: "agent";
+        webmcp: "webmcp";
     }>>>;
     env: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
 }, import("zod/v4/core").$strict>;
@@ -134,7 +135,13 @@ export declare function checkEntryAvailability(availability: EntryAvailability |
 export declare function detectRuntimeContext(): RuntimeContext;
 /**
  * Get the current runtime context (lazy singleton).
- * The context is detected on first call and cached for the process lifetime.
+ * The context is detected on first call and cached for the process lifetime,
+ * except `env`, which always reflects the live `NODE_ENV`. A Cloudflare Worker's
+ * `[vars]` reach `process.env` on the first request, after module evaluation has
+ * already read this context, so a frozen `env` would report `development` in a
+ * production deployment. It is read through `getNodeEnv()`, so a bundler's
+ * build-time `process.env.NODE_ENV` (`wrangler dev` inlines `development`) does
+ * not hide the value the deployment sets.
  */
 export declare function getRuntimeContext(): RuntimeContext;
 /**

package/env/runtime-context.js

@@ -0,0 +1,192 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/utils/src/env/runtime-context.ts
+var runtime_context_exports = {};
+__export(runtime_context_exports, {
+  checkEntryAvailability: () => checkEntryAvailability,
+  detectRuntimeContext: () => detectRuntimeContext,
+  entryAvailabilitySchema: () => entryAvailabilitySchema,
+  getRuntimeContext: () => getRuntimeContext,
+  isEntryAvailable: () => isEntryAvailable,
+  resetRuntimeContext: () => resetRuntimeContext
+});
+module.exports = __toCommonJS(runtime_context_exports);
+var import_lazy_zod = require("@frontmcp/lazy-zod");
+var import_env = require("#env");
+
+// libs/utils/src/env/build-target.ts
+var cached;
+function getBuildTarget() {
+  if (cached) return cached;
+  cached = resolveBuildTarget();
+  return cached;
+}
+function resolveBuildTarget() {
+  const globalAny = globalThis;
+  const fromGlobal = globalAny.FRONTMCP_BUILD_TARGET;
+  if (typeof fromGlobal === "string" && isKnownTarget(fromGlobal)) return fromGlobal;
+  const fromEnv = typeof process !== "undefined" ? process.env?.["FRONTMCP_BUILD_TARGET"] : void 0;
+  if (typeof fromEnv === "string" && isKnownTarget(fromEnv)) return fromEnv;
+  return "unknown";
+}
+function isKnownTarget(value) {
+  return value === "unknown" || value === "node" || value === "distributed" || value === "cli" || value === "vercel" || value === "lambda" || value === "cloudflare" || value === "browser" || value === "sdk" || value === "mcpb";
+}
+
+// libs/utils/src/env/provider.ts
+var cached2;
+function detectProvider() {
+  if (cached2) return cached2;
+  cached2 = detectProviderUncached();
+  return cached2;
+}
+function detectProviderUncached() {
+  const explicit = process.env["FRONTMCP_PROVIDER"];
+  if (explicit && isKnownProvider(explicit)) return explicit;
+  if (process.env["VERCEL"]) return "vercel";
+  if (process.env["AWS_LAMBDA_FUNCTION_NAME"]) return "lambda";
+  if (process.env["CF_PAGES"]) return "cloudflare";
+  if (process.env["NETLIFY"]) return "netlify";
+  if (process.env["AZURE_FUNCTIONS_ENVIRONMENT"]) return "azure";
+  if (process.env["K_SERVICE"]) return "gcp";
+  if (process.env["FLY_APP_NAME"]) return "fly";
+  if (process.env["RENDER"]) return "render";
+  if (process.env["RAILWAY_ENVIRONMENT"]) return "railway";
+  try {
+    const nodeFs = require("node:fs");
+    if (nodeFs.existsSync("/.dockerenv")) return "docker";
+  } catch {
+  }
+  return "bare";
+}
+function isKnownProvider(value) {
+  return value === "bare" || value === "docker" || value === "vercel" || value === "lambda" || value === "cloudflare" || value === "netlify" || value === "azure" || value === "gcp" || value === "fly" || value === "render" || value === "railway";
+}
+
+// libs/utils/src/env/runtime-context.ts
+var entryAvailabilitySchema = import_lazy_zod.z.object({
+  os: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  platform: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  runtime: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  deployment: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  provider: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  target: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional(),
+  surface: import_lazy_zod.z.array(import_lazy_zod.z.enum(["mcp", "cli", "http-trigger", "job", "agent", "webmcp"])).optional(),
+  env: import_lazy_zod.z.array(import_lazy_zod.z.string().min(1)).optional()
+}).strict();
+var PROCESS_AXES = [
+  // `os` and `platform` both compare against the same RuntimeContext value
+  // — keeping `platform` as a deprecated alias lets pre-#417 metadata
+  // continue to match without any code change.
+  { key: "os", ctxKey: "os" },
+  { key: "platform", ctxKey: "platform" },
+  { key: "runtime", ctxKey: "runtime" },
+  { key: "deployment", ctxKey: "deployment" },
+  { key: "provider", ctxKey: "provider" },
+  { key: "target", ctxKey: "target" },
+  { key: "env", ctxKey: "env" }
+];
+function isEntryAvailable(availability, ctx, callCtx) {
+  if (!availability) return true;
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0) return false;
+    if (!allowed.includes(ctx[ctxKey])) return false;
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) return false;
+    if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkEntryAvailability(availability, ctx, callCtx) {
+  if (!availability) return { available: true, missingAxes: [] };
+  const missing = [];
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0 || !allowed.includes(ctx[ctxKey])) {
+      missing.push(key);
+    }
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) {
+      missing.push("surface");
+    } else if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) {
+      missing.push("surface");
+    }
+  }
+  return { available: missing.length === 0, missingAxes: missing };
+}
+function detectRuntime() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) return "bun";
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) return "deno";
+  if ((0, import_env.isEdgeRuntime)()) return "edge";
+  return "node";
+}
+function detectDeployment(runtime) {
+  const explicit = process.env["FRONTMCP_DEPLOYMENT_MODE"];
+  if (explicit === "distributed") return "distributed";
+  if (explicit === "serverless") return "serverless";
+  if (runtime === "browser") return "browser";
+  if ((0, import_env.isServerless)()) return "serverless";
+  return "standalone";
+}
+function detectRuntimeContext() {
+  const runtime = detectRuntime();
+  const os = process.platform;
+  return {
+    os,
+    platform: os,
+    runtime,
+    deployment: detectDeployment(runtime),
+    provider: detectProvider(),
+    target: getBuildTarget(),
+    env: (0, import_env.getNodeEnv)() || "development"
+  };
+}
+var cached3;
+function getRuntimeContext() {
+  if (!cached3) {
+    const detected = detectRuntimeContext();
+    Object.defineProperty(detected, "env", {
+      get: () => (0, import_env.getNodeEnv)() || "development",
+      enumerable: true,
+      configurable: true
+    });
+    cached3 = detected;
+  }
+  return cached3;
+}
+function resetRuntimeContext() {
+  cached3 = void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkEntryAvailability,
+  detectRuntimeContext,
+  entryAvailabilitySchema,
+  getRuntimeContext,
+  isEntryAvailable,
+  resetRuntimeContext
+});

package/esm/async-context/browser-async-context.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/async-context/overlap-error.ts
 var AsyncContextOverlapError = class extends Error {
   constructor(message) {

package/esm/async-context/node-async-context.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/async-context/node-async-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 

package/esm/crypto/browser.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/crypto/browser.ts
 import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
 import { hmac } from "@noble/hashes/hmac.js";

package/esm/crypto/node.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/crypto/node.ts
 import crypto from "node:crypto";
 

package/esm/env/browser-env.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/env/edge-scope.ts
 function hasEdgeGlobalScope() {
   if (typeof globalThis === "undefined") return false;
@@ -22,6 +23,9 @@ function getEnv(_key, defaultValue) {
 function getCwd() {
   return "/";
 }
+function getNodeEnv() {
+  return void 0;
+}
 function isProduction() {
   return false;
 }
@@ -49,6 +53,7 @@ export {
   getCwd,
   getEnv,
   getEnvFlag,
+  getNodeEnv,
   isDebug,
   isDevelopment,
   isEdgeRuntime,

package/esm/env/browser-runtime-context.mjs

@@ -0,0 +1,77 @@
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
+// libs/utils/src/env/browser-runtime-context.ts
+import { z } from "@frontmcp/lazy-zod";
+var entryAvailabilitySchema = z.object({
+  os: z.array(z.string().min(1)).optional(),
+  platform: z.array(z.string().min(1)).optional(),
+  runtime: z.array(z.string().min(1)).optional(),
+  deployment: z.array(z.string().min(1)).optional(),
+  provider: z.array(z.string().min(1)).optional(),
+  target: z.array(z.string().min(1)).optional(),
+  surface: z.array(z.enum(["mcp", "cli", "http-trigger", "job", "agent", "webmcp"])).optional(),
+  env: z.array(z.string().min(1)).optional()
+}).strict();
+var PROCESS_AXES = [
+  { key: "os", ctxKey: "os" },
+  { key: "platform", ctxKey: "platform" },
+  { key: "runtime", ctxKey: "runtime" },
+  { key: "deployment", ctxKey: "deployment" },
+  { key: "provider", ctxKey: "provider" },
+  { key: "target", ctxKey: "target" },
+  { key: "env", ctxKey: "env" }
+];
+function isEntryAvailable(availability, ctx, callCtx) {
+  if (!availability) return true;
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0) return false;
+    if (!allowed.includes(ctx[ctxKey])) return false;
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) return false;
+    if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) return false;
+  }
+  return true;
+}
+function checkEntryAvailability(availability, ctx, callCtx) {
+  if (!availability) return { available: true, missingAxes: [] };
+  const missing = [];
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0 || !allowed.includes(ctx[ctxKey])) missing.push(key);
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) missing.push("surface");
+    else if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) missing.push("surface");
+  }
+  return { available: missing.length === 0, missingAxes: missing };
+}
+function detectRuntimeContext() {
+  return {
+    os: "browser",
+    platform: "browser",
+    runtime: "browser",
+    deployment: "standalone",
+    provider: "bare",
+    target: "browser",
+    env: "production"
+  };
+}
+var browserContext = detectRuntimeContext();
+function getRuntimeContext() {
+  return browserContext;
+}
+function resetRuntimeContext() {
+}
+export {
+  checkEntryAvailability,
+  detectRuntimeContext,
+  entryAvailabilitySchema,
+  getRuntimeContext,
+  isEntryAvailable,
+  resetRuntimeContext
+};

package/esm/env/node-env.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/env/edge-scope.ts
 function hasEdgeGlobalScope() {
   if (typeof globalThis === "undefined") return false;
@@ -22,11 +23,15 @@ function getEnv(key, defaultValue) {
 function getCwd() {
   return process.cwd();
 }
+var NODE_ENV_KEY = "NODE_ENV";
+function getNodeEnv() {
+  return process.env[NODE_ENV_KEY] || process.env["NODE_ENV"] || void 0;
+}
 function isProduction() {
-  return process.env["NODE_ENV"] === "production";
+  return getNodeEnv() === "production";
 }
 function isDevelopment() {
-  return process.env["NODE_ENV"] === "development";
+  return getNodeEnv() === "development";
 }
 function getEnvFlag(key) {
   const v = process.env[key];
@@ -57,6 +62,7 @@ export {
   getCwd,
   getEnv,
   getEnvFlag,
+  getNodeEnv,
   isDebug,
   isDevelopment,
   isEdgeRuntime,