@frontmcp/utils 1.8.6 → 1.9.0

package/index.js

@@ -596,9 +596,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) {
@@ -836,8 +836,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;
@@ -1088,6 +1088,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") {
@@ -1202,6 +1271,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)
       // ============================================
@@ -1250,85 +1330,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
 var import_event_emitter, DEFAULT_SWEEP_INTERVAL_SECONDS, MAX_TIMEOUT_MS, MemoryStorageAdapter;
 var init_memory = __esm({
   "libs/utils/src/storage/adapters/memory.ts"() {
     "use strict";
     import_event_emitter = require("#event-emitter");
-    init_base();
     init_errors();
     init_pattern();
     init_ttl();
+    init_base();
     DEFAULT_SWEEP_INTERVAL_SECONDS = 60;
     MAX_TIMEOUT_MS = 2147483647;
     MemoryStorageAdapter = class extends BaseStorageAdapter {
@@ -1420,6 +1431,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);
@@ -2965,6 +2982,41 @@ var init_crypto = __esm({
   }
 });
 
+// libs/utils/src/storage/redis-error-listener.ts
+function attachRedisErrorListener(client, options = {}) {
+  const label = options.label ?? "redis";
+  const intervalMs = options.intervalMs ?? DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS;
+  let lastLoggedAt = 0;
+  let suppressed = 0;
+  const listener = (error) => {
+    const now = Date.now();
+    if (lastLoggedAt !== 0 && now - lastLoggedAt < intervalMs) {
+      suppressed++;
+      return;
+    }
+    const extra = suppressed > 0 ? ` (${suppressed} similar error(s) suppressed)` : "";
+    suppressed = 0;
+    lastLoggedAt = now;
+    const message = `[${label}] Redis connection error: ${error?.message ?? String(error)}${extra}`;
+    if (options.logger) {
+      options.logger.warn(message);
+    } else {
+      console.warn(message);
+    }
+  };
+  client.on("error", listener);
+  return () => {
+    client.removeListener("error", listener);
+  };
+}
+var DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS;
+var init_redis_error_listener = __esm({
+  "libs/utils/src/storage/redis-error-listener.ts"() {
+    "use strict";
+    DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS = 3e4;
+  }
+});
+
 // libs/utils/src/storage/utils/index.ts
 var init_utils = __esm({
   "libs/utils/src/storage/utils/index.ts"() {
@@ -2973,10 +3025,20 @@ 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, {
-  RedisStorageAdapter: () => RedisStorageAdapter
+  RedisStorageAdapter: () => RedisStorageAdapter,
+  createRedisClient: () => createRedisClient
 });
 function getRedisClass() {
   try {
@@ -2994,12 +3056,28 @@ function getRedisClass() {
     });
   }
 }
+function createRedisClient(options) {
+  const RedisClass = getRedisClass();
+  const baseOptions = { lazyConnect: false, maxRetriesPerRequest: 3 };
+  const client = options.url ? new RedisClass(options.url, baseOptions) : new RedisClass({
+    ...baseOptions,
+    host: options.host ?? "localhost",
+    port: options.port ?? 6379,
+    password: options.password,
+    db: options.db ?? 0,
+    tls: options.tls ? {} : void 0
+  });
+  attachRedisErrorListener(client, { label: options.label ?? "redis", logger: options.logger });
+  return client;
+}
 var RedisStorageAdapter;
 var init_redis = __esm({
   "libs/utils/src/storage/adapters/redis.ts"() {
     "use strict";
     init_errors();
+    init_redis_error_listener();
     init_utils();
+    init_compare_and_delete();
     init_base();
     RedisStorageAdapter = class extends BaseStorageAdapter {
       backendName = "redis";
@@ -3007,6 +3085,7 @@ var init_redis = __esm({
       subscriber;
       options;
       ownsClient;
+      detachErrorListener;
       connecting;
       keyPrefix;
       subscriptionHandlers = /* @__PURE__ */ new Map();
@@ -3063,7 +3142,10 @@ var init_redis = __esm({
           await client.ping();
           this.client = client;
           this.connected = true;
-          if (this.ownsClient) client.removeListener("error", recordSocketError);
+          if (this.ownsClient) {
+            client.removeListener("error", recordSocketError);
+            this.detachErrorListener = attachRedisErrorListener(client, { label: "RedisStorage" });
+          }
         } catch (e) {
           if (this.ownsClient && client) {
             try {
@@ -3084,6 +3166,8 @@ var init_redis = __esm({
         if (this.ownsClient && this.client) {
           await this.client.quit();
         }
+        this.detachErrorListener?.();
+        this.detachErrorListener = void 0;
         this.client = void 0;
         this.connected = false;
         this.subscriptionHandlers.clear();
@@ -3148,6 +3232,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;
@@ -3311,6 +3404,7 @@ var init_redis = __esm({
         } else {
           throw new StorageConfigError("redis", "Cannot create subscriber without url, config, or client");
         }
+        attachRedisErrorListener(subscriber, { label: "RedisStorage:subscriber" });
         subscriber.on("message", (channel, message) => {
           const handlers = this.subscriptionHandlers.get(channel);
           if (handlers) {
@@ -3355,9 +3449,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");
   }
@@ -3366,9 +3463,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;
@@ -3393,17 +3491,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 });
           await this.client.exists("__healthcheck__");
           this.connected = true;
         } catch (e) {
@@ -3465,6 +3559,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;
@@ -3582,9 +3684,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";
@@ -3689,6 +3792,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;
@@ -3878,7 +3989,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 ?? "";
@@ -3972,6 +4085,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.";
@@ -4007,6 +4127,7 @@ __export(index_exports, {
   BaseStorageAdapter: () => BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH: () => DEFAULT_CODE_VERIFIER_LENGTH,
   DEFAULT_MAX_INPUT_LENGTH: () => DEFAULT_MAX_INPUT_LENGTH,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS: () => DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
   EncryptedBlobError: () => EncryptedBlobError,
   EncryptedStorageError: () => EncryptedStorageError,
   EncryptedTypedStorage: () => EncryptedTypedStorage,
@@ -4039,16 +4160,17 @@ __export(index_exports, {
   assertNode: () => assertNode,
   asymmetricAlgSchema: () => asymmetricAlgSchema,
   asymmetricKeyDataSchema: () => asymmetricKeyDataSchema,
+  attachRedisErrorListener: () => attachRedisErrorListener,
   awaitOutsideRequest: () => import_async_context.awaitOutsideRequest,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
   base64urlDecode: () => base64urlDecode,
   base64urlEncode: () => base64urlEncode,
-  basename: () => import_path.basename,
+  basename: () => import_path2.basename,
   buildPrefix: () => buildPrefix,
   buildSetCookie: () => buildSetCookie,
   bytesToHex: () => bytesToHex,
-  checkEntryAvailability: () => checkEntryAvailability,
+  checkEntryAvailability: () => import_runtime_context.checkEntryAvailability,
   classifyIpAddress: () => classifyIpAddress,
   clearCachedSecret: () => clearCachedSecret,
   collapseChar: () => collapseChar,
@@ -4059,6 +4181,7 @@ __export(index_exports, {
   createKeyPersistenceWithStorage: () => createKeyPersistenceWithStorage,
   createMemoryStorage: () => createMemoryStorage,
   createNamespacedStorage: () => createNamespacedStorage,
+  createRedisClient: () => createRedisClient,
   createRootStorage: () => createRootStorage,
   createSafeRegExp: () => createSafeRegExp,
   createSecretData: () => createSecretData,
@@ -4068,15 +4191,15 @@ __export(index_exports, {
   deleteSecret: () => deleteSecret,
   deserializeAndDecrypt: () => deserializeAndDecrypt,
   deserializeBlob: () => deserializeBlob,
-  detectRuntimeContext: () => detectRuntimeContext,
-  dirname: () => import_path.dirname,
+  detectRuntimeContext: () => import_runtime_context.detectRuntimeContext,
+  dirname: () => import_path2.dirname,
   encryptAesGcm: () => encryptAesGcm,
   encryptAndSerialize: () => encryptAndSerialize,
   encryptValue: () => encryptValue,
   ensureDir: () => ensureDir,
   ensureDirSync: () => ensureDirSync,
   ensureMaxLen: () => ensureMaxLen,
-  entryAvailabilitySchema: () => entryAvailabilitySchema,
+  entryAvailabilitySchema: () => import_runtime_context.entryAvailabilitySchema,
   escapeGlob: () => escapeGlob,
   escapeHtml: () => escapeHtml,
   escapeHtmlAttr: () => escapeHtmlAttr,
@@ -4086,7 +4209,7 @@ __export(index_exports, {
   expandTemplate: () => expandTemplate,
   expandUriTemplate: () => expandUriTemplate,
   expiresAtToTTL: () => expiresAtToTTL,
-  extname: () => import_path.extname,
+  extname: () => import_path2.extname,
   extractBracedParams: () => extractBracedParams,
   extractEmbeddedIpv4: () => extractEmbeddedIpv4,
   extractTemplateParams: () => extractTemplateParams,
@@ -4101,13 +4224,14 @@ __export(index_exports, {
   getAsyncContextMode: () => import_async_context.getAsyncContextMode,
   getCookie: () => getCookie,
   getCrypto: () => getCrypto,
-  getCwd: () => import_env3.getCwd,
+  getCwd: () => import_env2.getCwd,
   getDetectedStorageType: () => getDetectedStorageType,
-  getEnv: () => import_env3.getEnv,
-  getEnvFlag: () => import_env3.getEnvFlag,
+  getEnv: () => import_env2.getEnv,
+  getEnvFlag: () => import_env2.getEnvFlag,
   getMachineId: () => getMachineId,
+  getNodeEnv: () => import_env2.getNodeEnv,
   getOrCreateSecret: () => getOrCreateSecret,
-  getRuntimeContext: () => getRuntimeContext,
+  getRuntimeContext: () => import_runtime_context.getRuntimeContext,
   getSpawnFn: () => getSpawnFn,
   globToRegex: () => globToRegex,
   hasTemplatePlaceholders: () => hasTemplatePlaceholders,
@@ -4115,27 +4239,27 @@ __export(index_exports, {
   hmacSha256: () => hmacSha256,
   idFromString: () => idFromString,
   inferMimeType: () => inferMimeType,
-  isAbsolute: () => import_path.isAbsolute,
+  isAbsolute: () => import_path2.isAbsolute,
   isAsymmetricKeyData: () => isAsymmetricKeyData,
   isBrowser: () => isBrowser,
-  isDebug: () => import_env3.isDebug,
-  isDevelopment: () => import_env3.isDevelopment,
+  isDebug: () => import_env2.isDebug,
+  isDevelopment: () => import_env2.isDevelopment,
   isDirEmpty: () => isDirEmpty,
-  isEdgeRuntime: () => import_env3.isEdgeRuntime,
-  isEntryAvailable: () => isEntryAvailable,
+  isEdgeRuntime: () => import_env2.isEdgeRuntime,
+  isEntryAvailable: () => import_runtime_context.isEntryAvailable,
   isExpired: () => isExpired,
   isInputLengthSafe: () => isInputLengthSafe,
   isLocalhost: () => isLocalhost,
   isNode: () => isNode,
   isPatternSafe: () => isPatternSafe,
-  isProduction: () => import_env3.isProduction,
+  isProduction: () => import_env2.isProduction,
   isRedirectResponse: () => isRedirectResponse,
   isRsaPssAlg: () => isRsaPssAlg,
   isSecretCached: () => isSecretCached,
   isSecretKeyData: () => isSecretKeyData,
   isSecretPersistenceEnabled: () => isSecretPersistenceEnabled,
   isSecureRequest: () => isSecureRequest,
-  isServerless: () => import_env3.isServerless,
+  isServerless: () => import_env2.isServerless,
   isSignedData: () => isSignedData,
   isUriTemplate: () => isUriTemplate,
   isValidCodeChallenge: () => isValidCodeChallenge,
@@ -4156,9 +4280,9 @@ __export(index_exports, {
   parseKeyData: () => parseKeyData,
   parseSecretData: () => parseSecretData,
   parseUriTemplate: () => parseUriTemplate,
-  pathJoin: () => import_path.join,
-  pathResolve: () => import_path.resolve,
-  pathToFileURL: () => import_url.pathToFileURL,
+  pathJoin: () => import_path2.join,
+  pathResolve: () => import_path2.resolve,
+  pathToFileURL: () => import_path2.pathToFileURL,
   pemToPublicJwk: () => pemToPublicJwk2,
   processPlatformToolCalls: () => processPlatformToolCalls,
   randomBytes: () => randomBytes,
@@ -4171,7 +4295,7 @@ __export(index_exports, {
   readdirSync: () => readdirSync,
   realpath: () => realpath,
   rename: () => rename,
-  resetRuntimeContext: () => resetRuntimeContext,
+  resetRuntimeContext: () => import_runtime_context.resetRuntimeContext,
   resolveSecretPath: () => resolveSecretPath,
   rm: () => rm,
   rsaSignBase64Url: () => rsaSignBase64Url2,
@@ -4189,10 +4313,10 @@ __export(index_exports, {
   saveSecret: () => saveSecret,
   secretDataSchema: () => secretDataSchema,
   secretKeyDataSchema: () => secretKeyDataSchema,
-  sep: () => import_path.sep,
+  sep: () => import_path2.sep,
   sepFor: () => sepFor,
   serializeBlob: () => serializeBlob,
-  setEnv: () => import_env3.setEnv,
+  setEnv: () => import_env2.setEnv,
   setMachineIdOverride: () => setMachineIdOverride,
   sha256: () => sha256,
   sha256Base64url: () => sha256Base64url,
@@ -4201,7 +4325,7 @@ __export(index_exports, {
   signData: () => signData,
   splitWords: () => splitWords,
   stat: () => stat,
-  supportsAnsi: () => import_env3.supportsAnsi,
+  supportsAnsi: () => import_env2.supportsAnsi,
   symlink: () => symlink,
   timingSafeEqual: () => timingSafeEqual,
   toCase: () => toCase,
@@ -4631,9 +4755,8 @@ function joinPath(...parts) {
   return cleaned.length ? `/${cleaned.join("/")}` : "";
 }
 
-// libs/utils/src/path/node-path.ts
-var import_path = require("path");
-var import_url = require("url");
+// libs/utils/src/path/index.ts
+var import_path2 = require("#path");
 
 // libs/utils/src/content/content.ts
 function sanitizeToJson(value) {
@@ -5051,161 +5174,14 @@ var import_async_context = require("#async-context");
 var import_event_emitter2 = require("#event-emitter");
 
 // libs/utils/src/env/index.ts
-var import_env3 = require("#env");
-
-// libs/utils/src/env/runtime-context.ts
-var import_lazy_zod3 = require("@frontmcp/lazy-zod");
 var import_env2 = 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_zod3.z.object({
-  os: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1)).optional(),
-  platform: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1)).optional(),
-  runtime: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1)).optional(),
-  deployment: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1)).optional(),
-  provider: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1)).optional(),
-  target: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1)).optional(),
-  surface: import_lazy_zod3.z.array(import_lazy_zod3.z.enum(["mcp", "cli", "http-trigger", "job", "agent"])).optional(),
-  env: import_lazy_zod3.z.array(import_lazy_zod3.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_env2.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_env2.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) {
-    cached3 = detectRuntimeContext();
-  }
-  return cached3;
-}
-function resetRuntimeContext() {
-  cached3 = void 0;
-}
+var import_runtime_context = require("#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) {
@@ -5337,6 +5313,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)
   // ============================================
@@ -5365,15 +5347,15 @@ function createNamespacedStorage(adapter, prefix) {
 
 // libs/utils/src/storage/factory.ts
 init_memory();
-var import_env4 = require("#env");
+var import_env3 = require("#env");
 function detectStorageType() {
-  if ((0, import_env4.getEnv)("UPSTASH_REDIS_REST_URL") && (0, import_env4.getEnv)("UPSTASH_REDIS_REST_TOKEN")) {
+  if ((0, import_env3.getEnv)("UPSTASH_REDIS_REST_URL") && (0, import_env3.getEnv)("UPSTASH_REDIS_REST_TOKEN")) {
     return "upstash";
   }
-  if ((0, import_env4.getEnv)("KV_REST_API_URL") && (0, import_env4.getEnv)("KV_REST_API_TOKEN")) {
+  if ((0, import_env3.getEnv)("KV_REST_API_URL") && (0, import_env3.getEnv)("KV_REST_API_TOKEN")) {
     return "vercel-kv";
   }
-  if ((0, import_env4.getEnv)("REDIS_URL") || (0, import_env4.getEnv)("REDIS_HOST")) {
+  if ((0, import_env3.getEnv)("REDIS_URL") || (0, import_env3.getEnv)("REDIS_HOST")) {
     return "redis";
   }
   return "memory";
@@ -5413,10 +5395,10 @@ async function createAdapter(type, config) {
 }
 async function createStorage(config = {}) {
   let type = config.type ?? "auto";
-  const fallback = config.fallback ?? ((0, import_env4.isProduction)() ? "error" : "memory");
+  const fallback = config.fallback ?? ((0, import_env3.isProduction)() ? "error" : "memory");
   if (type === "auto") {
     type = detectStorageType();
-    if (type === "memory" && (0, import_env4.isProduction)()) {
+    if (type === "memory" && (0, import_env3.isProduction)()) {
       console.warn(
         "[storage] Warning: No distributed storage backend detected in production. Using in-memory storage. Set REDIS_URL, UPSTASH_REDIS_REST_URL, or KV_REST_API_URL."
       );
@@ -5465,6 +5447,7 @@ function getDetectedStorageType() {
 }
 
 // libs/utils/src/storage/index.ts
+init_redis_error_listener();
 init_errors();
 
 // libs/utils/src/storage/typed-storage.ts
@@ -6120,6 +6103,7 @@ function setMachineIdOverride(id) {
   BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH,
   DEFAULT_MAX_INPUT_LENGTH,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
   EncryptedBlobError,
   EncryptedStorageError,
   EncryptedTypedStorage,
@@ -6152,6 +6136,7 @@ function setMachineIdOverride(id) {
   assertNode,
   asymmetricAlgSchema,
   asymmetricKeyDataSchema,
+  attachRedisErrorListener,
   awaitOutsideRequest,
   base64Decode,
   base64Encode,
@@ -6172,6 +6157,7 @@ function setMachineIdOverride(id) {
   createKeyPersistenceWithStorage,
   createMemoryStorage,
   createNamespacedStorage,
+  createRedisClient,
   createRootStorage,
   createSafeRegExp,
   createSecretData,
@@ -6219,6 +6205,7 @@ function setMachineIdOverride(id) {
   getEnv,
   getEnvFlag,
   getMachineId,
+  getNodeEnv,
   getOrCreateSecret,
   getRuntimeContext,
   getSpawnFn,