@frontmcp/utils 1.8.7 → 1.9.1-rc.1

package/esm/index.mjs

@@ -1,4 +1,4 @@
-const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
 const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
 // __frontmcpCreateRequire
 var __defProp = Object.defineProperty;
@@ -595,9 +595,9 @@ function createSecretData(options) {
 }
 async function getOrCreateSecret(options) {
   const cacheKey = resolveSecretPath(options);
-  const cached4 = secretCache.get(cacheKey);
-  if (cached4) {
-    return cached4;
+  const cached = secretCache.get(cacheKey);
+  if (cached) {
+    return cached;
   }
   const existing = generationPromises.get(cacheKey);
   if (existing) {
@@ -834,8 +834,8 @@ var init_key_persistence = __esm({
        */
       async get(kid) {
         if (this.enableCache) {
-          const cached4 = this.cache.get(kid);
-          if (cached4) return cached4;
+          const cached = this.cache.get(kid);
+          if (cached) return cached;
         }
         const raw = await this.storage.get(kid);
         if (!raw) return null;
@@ -1086,6 +1086,75 @@ var init_errors = __esm({
   }
 });
 
+// libs/utils/src/storage/utils/pattern.ts
+function globToRegex(pattern) {
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new StoragePatternError(
+      pattern.substring(0, 50) + "...",
+      `Pattern exceeds maximum length of ${MAX_PATTERN_LENGTH} characters`
+    );
+  }
+  const wildcardCount = (pattern.match(/[*?]/g) || []).length;
+  if (wildcardCount > MAX_WILDCARDS) {
+    throw new StoragePatternError(pattern, `Pattern has too many wildcards (max: ${MAX_WILDCARDS})`);
+  }
+  if (pattern === "" || pattern === "*") {
+    return /^.*$/;
+  }
+  let regexStr = "^";
+  let prevChar = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    switch (char) {
+      case "*":
+        if (prevChar !== "*") {
+          regexStr += ".*";
+        }
+        break;
+      case "?":
+        regexStr += ".";
+        break;
+      default:
+        regexStr += char.replace(REGEX_SPECIAL_CHARS, "\\$&");
+    }
+    prevChar = char;
+  }
+  regexStr += "$";
+  try {
+    return new RegExp(regexStr);
+  } catch {
+    throw new StoragePatternError(pattern, "Failed to compile pattern to regex");
+  }
+}
+function matchesPattern(key, pattern) {
+  const regex = globToRegex(pattern);
+  return regex.test(key);
+}
+function validatePattern(pattern) {
+  try {
+    globToRegex(pattern);
+    return { valid: true };
+  } catch (e) {
+    return {
+      valid: false,
+      error: e instanceof Error ? e.message : "Invalid pattern"
+    };
+  }
+}
+function escapeGlob(literal) {
+  return literal.replace(/[*?\\]/g, "\\$&");
+}
+var MAX_PATTERN_LENGTH, MAX_WILDCARDS, REGEX_SPECIAL_CHARS;
+var init_pattern = __esm({
+  "libs/utils/src/storage/utils/pattern.ts"() {
+    "use strict";
+    init_errors();
+    MAX_PATTERN_LENGTH = 500;
+    MAX_WILDCARDS = 20;
+    REGEX_SPECIAL_CHARS = /[.+^${}()|[\]\\]/g;
+  }
+});
+
 // libs/utils/src/storage/utils/ttl.ts
 function validateTTL(ttlSeconds) {
   if (typeof ttlSeconds !== "number") {
@@ -1200,6 +1269,17 @@ var init_base = __esm({
         const matchedKeys = await this.keys(pattern);
         return matchedKeys.length;
       }
+      /**
+       * Default: not supported, since a read followed by a delete is not atomic.
+       * Override in adapters whose backend can compare and delete in one step.
+       */
+      async deleteIfEquals(_key, _expectedValue) {
+        throw new StorageNotSupportedError(
+          "deleteIfEquals",
+          this.backendName,
+          "Use the memory, Redis, Upstash or Vercel KV adapter for an atomic compare-and-delete."
+        );
+      }
       // ============================================
       // Pub/Sub (default: not supported)
       // ============================================
@@ -1248,85 +1328,16 @@ var init_base = __esm({
   }
 });
 
-// libs/utils/src/storage/utils/pattern.ts
-function globToRegex(pattern) {
-  if (pattern.length > MAX_PATTERN_LENGTH) {
-    throw new StoragePatternError(
-      pattern.substring(0, 50) + "...",
-      `Pattern exceeds maximum length of ${MAX_PATTERN_LENGTH} characters`
-    );
-  }
-  const wildcardCount = (pattern.match(/[*?]/g) || []).length;
-  if (wildcardCount > MAX_WILDCARDS) {
-    throw new StoragePatternError(pattern, `Pattern has too many wildcards (max: ${MAX_WILDCARDS})`);
-  }
-  if (pattern === "" || pattern === "*") {
-    return /^.*$/;
-  }
-  let regexStr = "^";
-  let prevChar = "";
-  for (let i = 0; i < pattern.length; i++) {
-    const char = pattern[i];
-    switch (char) {
-      case "*":
-        if (prevChar !== "*") {
-          regexStr += ".*";
-        }
-        break;
-      case "?":
-        regexStr += ".";
-        break;
-      default:
-        regexStr += char.replace(REGEX_SPECIAL_CHARS, "\\$&");
-    }
-    prevChar = char;
-  }
-  regexStr += "$";
-  try {
-    return new RegExp(regexStr);
-  } catch {
-    throw new StoragePatternError(pattern, "Failed to compile pattern to regex");
-  }
-}
-function matchesPattern(key, pattern) {
-  const regex = globToRegex(pattern);
-  return regex.test(key);
-}
-function validatePattern(pattern) {
-  try {
-    globToRegex(pattern);
-    return { valid: true };
-  } catch (e) {
-    return {
-      valid: false,
-      error: e instanceof Error ? e.message : "Invalid pattern"
-    };
-  }
-}
-function escapeGlob(literal) {
-  return literal.replace(/[*?\\]/g, "\\$&");
-}
-var MAX_PATTERN_LENGTH, MAX_WILDCARDS, REGEX_SPECIAL_CHARS;
-var init_pattern = __esm({
-  "libs/utils/src/storage/utils/pattern.ts"() {
-    "use strict";
-    init_errors();
-    MAX_PATTERN_LENGTH = 500;
-    MAX_WILDCARDS = 20;
-    REGEX_SPECIAL_CHARS = /[.+^${}()|[\]\\]/g;
-  }
-});
-
 // libs/utils/src/storage/adapters/memory.ts
 import { EventEmitter } from "#event-emitter";
 var DEFAULT_SWEEP_INTERVAL_SECONDS, MAX_TIMEOUT_MS, MemoryStorageAdapter;
 var init_memory = __esm({
   "libs/utils/src/storage/adapters/memory.ts"() {
     "use strict";
-    init_base();
     init_errors();
     init_pattern();
     init_ttl();
+    init_base();
     DEFAULT_SWEEP_INTERVAL_SECONDS = 60;
     MAX_TIMEOUT_MS = 2147483647;
     MemoryStorageAdapter = class extends BaseStorageAdapter {
@@ -1418,6 +1429,12 @@ var init_memory = __esm({
         this.ensureConnected();
         return this.deleteEntry(key);
       }
+      async deleteIfEquals(key, expectedValue) {
+        this.ensureConnected();
+        const entry = this.store.get(key);
+        if (!entry || isExpired(entry.expiresAt) || entry.value !== expectedValue) return false;
+        return this.deleteEntry(key);
+      }
       async exists(key) {
         this.ensureConnected();
         const entry = this.store.get(key);
@@ -3006,6 +3023,15 @@ var init_utils = __esm({
   }
 });
 
+// libs/utils/src/storage/utils/compare-and-delete.ts
+var COMPARE_AND_DELETE_SCRIPT;
+var init_compare_and_delete = __esm({
+  "libs/utils/src/storage/utils/compare-and-delete.ts"() {
+    "use strict";
+    COMPARE_AND_DELETE_SCRIPT = `if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) end return 0`;
+  }
+});
+
 // libs/utils/src/storage/adapters/redis.ts
 var redis_exports = {};
 __export(redis_exports, {
@@ -3049,6 +3075,7 @@ var init_redis = __esm({
     init_errors();
     init_redis_error_listener();
     init_utils();
+    init_compare_and_delete();
     init_base();
     RedisStorageAdapter = class extends BaseStorageAdapter {
       backendName = "redis";
@@ -3203,6 +3230,15 @@ var init_redis = __esm({
         const result = await this.getConnectedClient().del(this.prefixKey(key));
         return result > 0;
       }
+      async deleteIfEquals(key, expectedValue) {
+        const deleted = await this.getConnectedClient().eval(
+          COMPARE_AND_DELETE_SCRIPT,
+          1,
+          this.prefixKey(key),
+          expectedValue
+        );
+        return deleted === 1;
+      }
       async exists(key) {
         const result = await this.getConnectedClient().exists(this.prefixKey(key));
         return result > 0;
@@ -3411,9 +3447,12 @@ var vercel_kv_exports = {};
 __export(vercel_kv_exports, {
   VercelKvStorageAdapter: () => VercelKvStorageAdapter
 });
-function getVercelKv() {
+async function loadVercelKv() {
   try {
-    return __require("@vercel/kv");
+    const mod = await import("@vercel/kv");
+    const resolved = typeof mod.createClient === "function" ? mod : mod.default;
+    if (!resolved || typeof resolved.createClient !== "function") throw new Error("createClient missing");
+    return resolved;
   } catch {
     throw new Error("@vercel/kv is required for Vercel KV storage adapter. Install it with: npm install @vercel/kv");
   }
@@ -3422,9 +3461,10 @@ var VercelKvStorageAdapter;
 var init_vercel_kv = __esm({
   "libs/utils/src/storage/adapters/vercel-kv.ts"() {
     "use strict";
-    init_base();
     init_errors();
+    init_compare_and_delete();
     init_ttl();
+    init_base();
     VercelKvStorageAdapter = class extends BaseStorageAdapter {
       backendName = "vercel-kv";
       client;
@@ -3449,17 +3489,13 @@ var init_vercel_kv = __esm({
       async connect() {
         if (this.connected) return;
         try {
-          const { createClient, kv } = getVercelKv();
-          if (this.options.url === process.env["KV_REST_API_URL"]) {
-            this.client = kv;
-          } else {
-            const url = this.options.url;
-            const token = this.options.token;
-            if (!url || !token) {
-              throw new StorageConfigError("vercel-kv", "URL and token are required");
-            }
-            this.client = createClient({ url, token });
+          const { createClient } = await loadVercelKv();
+          const url = this.options.url;
+          const token = this.options.token;
+          if (!url || !token) {
+            throw new StorageConfigError("vercel-kv", "URL and token are required");
           }
+          this.client = createClient({ url, token, cache: void 0, automaticDeserialization: false });
           await this.client.exists("__healthcheck__");
           this.connected = true;
         } catch (e) {
@@ -3500,8 +3536,7 @@ var init_vercel_kv = __esm({
       // Core Operations
       // ============================================
       async get(key) {
-        const result = await this.getConnectedClient().get(this.prefixKey(key));
-        return result;
+        return this.getConnectedClient().get(this.prefixKey(key));
       }
       async doSet(key, value, options) {
         const client = this.getConnectedClient();
@@ -3521,6 +3556,14 @@ var init_vercel_kv = __esm({
         const result = await this.getConnectedClient().del(this.prefixKey(key));
         return result > 0;
       }
+      async deleteIfEquals(key, expectedValue) {
+        const deleted = await this.getConnectedClient().eval(
+          COMPARE_AND_DELETE_SCRIPT,
+          [this.prefixKey(key)],
+          [expectedValue]
+        );
+        return deleted === 1;
+      }
       async exists(key) {
         const result = await this.getConnectedClient().exists(this.prefixKey(key));
         return result > 0;
@@ -3638,9 +3681,10 @@ var PUBSUB_POLL_INTERVAL_MS, UpstashStorageAdapter;
 var init_upstash = __esm({
   "libs/utils/src/storage/adapters/upstash.ts"() {
     "use strict";
-    init_base();
     init_errors();
+    init_compare_and_delete();
     init_ttl();
+    init_base();
     PUBSUB_POLL_INTERVAL_MS = 100;
     UpstashStorageAdapter = class extends BaseStorageAdapter {
       backendName = "upstash";
@@ -3677,7 +3721,7 @@ var init_upstash = __esm({
           if (!url || !token) {
             throw new StorageConfigError("upstash", "URL and token are required");
           }
-          this.client = new Redis({ url, token });
+          this.client = new Redis({ url, token, automaticDeserialization: false });
           await this.client.exists("__healthcheck__");
           this.connected = true;
         } catch (e) {
@@ -3724,8 +3768,7 @@ var init_upstash = __esm({
       // Core Operations
       // ============================================
       async get(key) {
-        const result = await this.getConnectedClient().get(this.prefixKey(key));
-        return result;
+        return this.getConnectedClient().get(this.prefixKey(key));
       }
       async doSet(key, value, options) {
         const client = this.getConnectedClient();
@@ -3745,6 +3788,14 @@ var init_upstash = __esm({
         const result = await this.getConnectedClient().del(this.prefixKey(key));
         return result > 0;
       }
+      async deleteIfEquals(key, expectedValue) {
+        const deleted = await this.getConnectedClient().eval(
+          COMPARE_AND_DELETE_SCRIPT,
+          [this.prefixKey(key)],
+          [expectedValue]
+        );
+        return deleted === 1;
+      }
       async exists(key) {
         const result = await this.getConnectedClient().exists(this.prefixKey(key));
         return result > 0;
@@ -3934,7 +3985,9 @@ var init_cloudflare_kv = __esm({
       constructor(options) {
         super();
         if (!options?.namespace) {
-          throw new Error("CloudflareKvStorageAdapter: a bound KV `namespace` is required (resolve it from the Worker `env`).");
+          throw new Error(
+            "CloudflareKvStorageAdapter: a bound KV `namespace` is required (resolve it from the Worker `env`)."
+          );
         }
         this.kv = options.namespace;
         this.keyPrefix = options.keyPrefix ?? "";
@@ -4028,6 +4081,13 @@ var init_cloudflare_kv = __esm({
           "Cloudflare KV has no atomic increment (a get+put is racy under eventual consistency). Use a Durable Object for atomic counters."
         );
       }
+      async deleteIfEquals(_key, _expectedValue) {
+        throw new StorageNotSupportedError(
+          "deleteIfEquals",
+          this.backendName,
+          "Cloudflare KV has no compare-and-set; use a Durable Object for an atomic compare-and-delete."
+        );
+      }
       // ── Pub/Sub (unsupported) ────────────────────────────────────────────────
       getPubSubSuggestion() {
         return "Cloudflare KV does not support pub/sub. Use a Durable Object (or Queues) for fan-out.";
@@ -4456,9 +4516,17 @@ function joinPath(...parts) {
   return cleaned.length ? `/${cleaned.join("/")}` : "";
 }
 
-// libs/utils/src/path/node-path.ts
-import { resolve, join, basename, dirname, extname, isAbsolute, sep } from "path";
-import { pathToFileURL } from "url";
+// libs/utils/src/path/index.ts
+import {
+  resolve,
+  join,
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  pathToFileURL,
+  sep
+} from "#path";
 
 // libs/utils/src/content/content.ts
 function sanitizeToJson(value) {
@@ -4885,175 +4953,30 @@ import { EventEmitter as EventEmitter2 } from "#event-emitter";
 import {
   getEnv as getEnv2,
   getCwd as getCwd2,
+  getNodeEnv,
   isProduction,
   isDevelopment,
   getEnvFlag,
   isDebug,
   setEnv,
-  isEdgeRuntime as isEdgeRuntime2,
-  isServerless as isServerless2,
+  isEdgeRuntime,
+  isServerless,
   supportsAnsi
 } from "#env";
-
-// libs/utils/src/env/runtime-context.ts
-import { z as z3 } from "@frontmcp/lazy-zod";
-import { isEdgeRuntime, isServerless } from "#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 = z3.object({
-  os: z3.array(z3.string().min(1)).optional(),
-  platform: z3.array(z3.string().min(1)).optional(),
-  runtime: z3.array(z3.string().min(1)).optional(),
-  deployment: z3.array(z3.string().min(1)).optional(),
-  provider: z3.array(z3.string().min(1)).optional(),
-  target: z3.array(z3.string().min(1)).optional(),
-  surface: z3.array(z3.enum(["mcp", "cli", "http-trigger", "job", "agent"])).optional(),
-  env: z3.array(z3.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 (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 (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: process.env["NODE_ENV"] || "development"
-  };
-}
-var cached3;
-function getRuntimeContext() {
-  if (!cached3) {
-    const detected = detectRuntimeContext();
-    Object.defineProperty(detected, "env", {
-      get: () => process.env["NODE_ENV"] || "development",
-      enumerable: true,
-      configurable: true
-    });
-    cached3 = detected;
-  }
-  return cached3;
-}
-function resetRuntimeContext() {
-  cached3 = void 0;
-}
+import {
+  getRuntimeContext,
+  resetRuntimeContext,
+  detectRuntimeContext,
+  isEntryAvailable,
+  checkEntryAvailability,
+  entryAvailabilitySchema
+} from "#runtime-context";
 
 // libs/utils/src/storage/factory.ts
 init_errors();
 
 // libs/utils/src/storage/namespace.ts
+init_errors();
 var NAMESPACE_SEPARATOR = ":";
 function buildPrefix(name, id) {
   if (id) {
@@ -5185,6 +5108,12 @@ var NamespacedStorageImpl = class _NamespacedStorageImpl {
   async incrBy(key, amount) {
     return this.adapter.incrBy(this.prefixKey(key), amount);
   }
+  async deleteIfEquals(key, expectedValue) {
+    if (!this.adapter.deleteIfEquals) {
+      throw new StorageNotSupportedError("deleteIfEquals", "this storage adapter");
+    }
+    return this.adapter.deleteIfEquals(this.prefixKey(key), expectedValue);
+  }
   // ============================================
   // Pub/Sub (with channel prefixing)
   // ============================================
@@ -6070,6 +5999,7 @@ export {
   getEnv2 as getEnv,
   getEnvFlag,
   getMachineId,
+  getNodeEnv,
   getOrCreateSecret,
   getRuntimeContext,
   getSpawnFn,
@@ -6085,7 +6015,7 @@ export {
   isDebug,
   isDevelopment,
   isDirEmpty,
-  isEdgeRuntime2 as isEdgeRuntime,
+  isEdgeRuntime,
   isEntryAvailable,
   isExpired,
   isInputLengthSafe,
@@ -6099,7 +6029,7 @@ export {
   isSecretKeyData,
   isSecretPersistenceEnabled,
   isSecureRequest,
-  isServerless2 as isServerless,
+  isServerless,
   isSignedData,
   isUriTemplate,
   isValidCodeChallenge,

package/esm/path/browser-path.mjs

@@ -0,0 +1,50 @@
+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/path/browser-path.ts
+function notAvailable(name) {
+  throw new Error(`path.${name}() is not available in browser environments`);
+}
+function resolve(..._segments) {
+  return notAvailable("resolve");
+}
+function join(..._segments) {
+  return notAvailable("join");
+}
+function basename(p, ext) {
+  const trimmed = p.replace(/[/\\]+$/, "");
+  const lastSep = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  let base = lastSep >= 0 ? trimmed.slice(lastSep + 1) : trimmed;
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, -ext.length);
+  }
+  return base;
+}
+function dirname(_p) {
+  return notAvailable("dirname");
+}
+function extname(p) {
+  const base = basename(p);
+  const dotIndex = base.lastIndexOf(".");
+  return dotIndex > 0 ? base.slice(dotIndex) : "";
+}
+function isAbsolute(p) {
+  if (!p) return false;
+  if (p.startsWith("/") || p.startsWith("\\")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(p)) return true;
+  return false;
+}
+function pathToFileURL(_p) {
+  return notAvailable("pathToFileURL");
+}
+var sep = "/";
+export {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  pathToFileURL,
+  resolve,
+  sep
+};