@frontmcp/utils 1.8.2 → 1.8.4

package/async-context/browser-async-context.d.ts

@@ -1,12 +1,30 @@
+export { AsyncContextOverlapError } from './overlap-error';
+export type AsyncContextMode = 'native' | 'serialized';
+export declare function getAsyncContextMode(): AsyncContextMode;
 /**
- * Browser polyfill for AsyncLocalStorage.
- *
- * Uses a simple stack-based approach, which is safe in single-threaded
- * browser environments. Does not support `enterWith()` or `disable()`
- * (neither is used in the FrontMCP codebase).
+ * Run one top-level request. With native `AsyncContext` it only calls `fn`. Without it, the request
+ * waits for its turn, runs with its own stacks, and keeps the turn until `fn` settles and every
+ * store it opened has unwound, so work it left running cannot read the next request's context.
  */
+export declare function runRequestExclusive<R>(fn: () => R | Promise<R>): Promise<R>;
+/**
+ * Await something the running request waits on from outside, such as its client's answer to an
+ * elicitation. Without native `AsyncContext` the request steps aside while it waits, so the client
+ * can call the server before answering, and takes its turn back afterwards. Outside a request, or
+ * with native `AsyncContext`, it only awaits.
+ */
+export declare function awaitOutsideRequest<T>(promise: PromiseLike<T>): Promise<T>;
 export declare class AsyncLocalStorage<T> {
-    private stack;
+    private readonly native?;
+    private readonly stacks;
+    constructor();
     run<R>(store: T, callback: (...args: unknown[]) => R, ...args: unknown[]): R;
     getStore(): T | undefined;
+    /**
+     * Remove `frame` from its request's stack. Returns false when it was not the innermost frame: a
+     * later run of this storage in the same request was still open, so the two overlapped and reads
+     * in between may have seen the other run's store.
+     */
+    private leave;
+    private overlapError;
 }

package/async-context/browser-async-context.js

@@ -20,30 +20,195 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // libs/utils/src/async-context/browser-async-context.ts
 var browser_async_context_exports = {};
 __export(browser_async_context_exports, {
-  AsyncLocalStorage: () => AsyncLocalStorage
+  AsyncContextOverlapError: () => AsyncContextOverlapError,
+  AsyncLocalStorage: () => AsyncLocalStorage,
+  awaitOutsideRequest: () => awaitOutsideRequest,
+  getAsyncContextMode: () => getAsyncContextMode,
+  runRequestExclusive: () => runRequestExclusive
 });
 module.exports = __toCommonJS(browser_async_context_exports);
+
+// libs/utils/src/async-context/overlap-error.ts
+var AsyncContextOverlapError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AsyncContextOverlapError";
+  }
+};
+
+// libs/utils/src/async-context/browser-async-context.ts
+var nativeAsyncContext = (() => {
+  const candidate = globalThis.AsyncContext;
+  return typeof candidate?.Variable === "function" ? candidate : void 0;
+})();
+function getAsyncContextMode() {
+  return nativeAsyncContext ? "native" : "serialized";
+}
+var SLOW_TURN_WARNING_MS = 1e4;
+var RequestSlot = class {
+  /** Frames of every storage that are still running in this request. */
+  live = 0;
+  /** Storages whose runs overlapped in this request; they refuse to answer until they unwind. */
+  tainted = /* @__PURE__ */ new Set();
+  idleWaiters = [];
+  enter() {
+    this.live++;
+  }
+  leave() {
+    this.live--;
+    if (this.live === 0) {
+      for (const resolve of this.idleWaiters.splice(0)) resolve();
+    }
+  }
+  /** Resolves once no frame of this request is running any more. */
+  idle() {
+    return this.live === 0 ? Promise.resolve() : new Promise((resolve) => this.idleWaiters.push(resolve));
+  }
+};
+var ROOT = new RequestSlot();
+var active = ROOT;
+var owner;
+var turnQueue = [];
+var slowTurnWarned = false;
+var overlapReported = false;
+function takeTurn(slot) {
+  if (!owner) {
+    owner = slot;
+    active = slot;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      if (slowTurnWarned) return;
+      slowTurnWarned = true;
+      console.warn(
+        "[frontmcp] A request has waited more than 10s for another one to finish. This runtime has no AsyncContext, so FrontMCP runs requests one at a time to keep their contexts apart. A tool that calls its own server through a client (instead of this.scope flows) waits for itself."
+      );
+    }, SLOW_TURN_WARNING_MS);
+    timer.unref?.();
+    turnQueue.push({
+      slot,
+      start: () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  });
+}
+function passTurn(slot) {
+  if (owner !== slot) return;
+  const next = turnQueue.shift();
+  if (next) {
+    owner = next.slot;
+    active = next.slot;
+    next.start();
+  } else {
+    owner = void 0;
+    active = ROOT;
+  }
+}
+async function runRequestExclusive(fn) {
+  if (nativeAsyncContext) return fn();
+  const slot = new RequestSlot();
+  await takeTurn(slot);
+  try {
+    return await fn();
+  } finally {
+    await slot.idle();
+    passTurn(slot);
+  }
+}
+async function awaitOutsideRequest(promise) {
+  if (nativeAsyncContext) return promise;
+  const slot = owner;
+  if (!slot || active !== slot) return promise;
+  passTurn(slot);
+  try {
+    return await promise;
+  } finally {
+    await takeTurn(slot);
+  }
+}
 var AsyncLocalStorage = class {
-  stack = [];
+  native;
+  stacks = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    if (nativeAsyncContext) this.native = new nativeAsyncContext.Variable();
+  }
   run(store, callback, ...args) {
-    this.stack.push(store);
+    if (this.native) return this.native.run(store, callback, ...args);
+    const slot = active;
+    let stack = this.stacks.get(slot);
+    if (!stack) {
+      stack = [];
+      this.stacks.set(slot, stack);
+    }
+    const frame = { store };
+    stack.push(frame);
+    slot.enter();
+    let result;
     try {
-      const result = callback(...args);
-      if (result instanceof Promise) {
-        return result.finally(() => this.stack.pop());
-      }
-      this.stack.pop();
-      return result;
-    } catch (err) {
-      this.stack.pop();
-      throw err;
+      result = callback(...args);
+    } catch (error) {
+      this.leave(slot, frame);
+      throw error;
     }
+    if (result instanceof Promise) {
+      return result.then(
+        (value) => {
+          if (!this.leave(slot, frame)) throw this.overlapError();
+          return value;
+        },
+        (error) => {
+          this.leave(slot, frame);
+          throw error;
+        }
+      );
+    }
+    this.leave(slot, frame);
+    return result;
   }
   getStore() {
-    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : void 0;
+    if (this.native) return this.native.get();
+    const slot = active;
+    if (slot.tainted.has(this)) throw this.overlapError();
+    const stack = this.stacks.get(slot);
+    return stack && stack.length > 0 ? stack[stack.length - 1].store : void 0;
+  }
+  /**
+   * Remove `frame` from its request's stack. Returns false when it was not the innermost frame: a
+   * later run of this storage in the same request was still open, so the two overlapped and reads
+   * in between may have seen the other run's store.
+   */
+  leave(slot, frame) {
+    const stack = this.stacks.get(slot) ?? [];
+    const index = stack.lastIndexOf(frame);
+    const innermost = index === stack.length - 1;
+    if (index !== -1) stack.splice(index, 1);
+    if (!innermost) {
+      slot.tainted.add(this);
+      if (!overlapReported) {
+        overlapReported = true;
+        console.error(
+          "[frontmcp] Two concurrent runs of one async context overlapped inside a request. This runtime has no AsyncContext, so the context of each cannot be told apart; reads fail for the rest of that request instead of returning the wrong value."
+        );
+      }
+    }
+    if (stack.length === 0) slot.tainted.delete(this);
+    slot.leave();
+    return innermost;
+  }
+  overlapError() {
+    return new AsyncContextOverlapError(
+      "Concurrent runs of an async context overlapped in one request, and this runtime has no AsyncContext to tell them apart. Run the calls one after another, or use a runtime with AsyncContext."
+    );
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AsyncLocalStorage
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
 });

package/async-context/index.d.ts

@@ -1 +1 @@
-export { AsyncLocalStorage } from '#async-context';
+export { AsyncContextOverlapError, AsyncLocalStorage, awaitOutsideRequest, getAsyncContextMode, runRequestExclusive, type AsyncContextMode, } from '#async-context';

package/async-context/node-async-context.d.ts

@@ -1 +1,12 @@
 export { AsyncLocalStorage } from 'node:async_hooks';
+export { AsyncContextOverlapError } from './overlap-error';
+/** How the runtime keeps async context apart: Node and Workers propagate it natively. */
+export type AsyncContextMode = 'native' | 'serialized';
+export declare function getAsyncContextMode(): AsyncContextMode;
+/**
+ * Run one top-level request. Node propagates `AsyncLocalStorage` across awaits, so requests may
+ * overlap freely and this only calls `fn`.
+ */
+export declare function runRequestExclusive<R>(fn: () => R | Promise<R>): Promise<R>;
+/** Await something a request waits on from outside (a client's answer). A pass-through on Node. */
+export declare function awaitOutsideRequest<T>(promise: PromiseLike<T>): Promise<T>;

package/async-context/node-async-context.js

@@ -20,11 +20,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // libs/utils/src/async-context/node-async-context.ts
 var node_async_context_exports = {};
 __export(node_async_context_exports, {
-  AsyncLocalStorage: () => import_node_async_hooks.AsyncLocalStorage
+  AsyncContextOverlapError: () => AsyncContextOverlapError,
+  AsyncLocalStorage: () => import_node_async_hooks.AsyncLocalStorage,
+  awaitOutsideRequest: () => awaitOutsideRequest,
+  getAsyncContextMode: () => getAsyncContextMode,
+  runRequestExclusive: () => runRequestExclusive
 });
 module.exports = __toCommonJS(node_async_context_exports);
 var import_node_async_hooks = require("node:async_hooks");
+
+// libs/utils/src/async-context/overlap-error.ts
+var AsyncContextOverlapError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AsyncContextOverlapError";
+  }
+};
+
+// libs/utils/src/async-context/node-async-context.ts
+function getAsyncContextMode() {
+  return "native";
+}
+async function runRequestExclusive(fn) {
+  return fn();
+}
+async function awaitOutsideRequest(promise) {
+  return promise;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AsyncLocalStorage
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
 });

package/async-context/overlap-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Thrown by the browser `AsyncLocalStorage` when two concurrent runs of one storage in the same
+ * request overlapped. Without a runtime-provided async context the storage cannot tell which of them
+ * a later read belongs to, so it refuses to answer instead of returning the other run's value.
+ */
+export declare class AsyncContextOverlapError extends Error {
+    constructor(message: string);
+}

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

@@ -1,26 +1,185 @@
 import { createRequire as __frontmcpCreateRequire } from 'module';
 const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+// libs/utils/src/async-context/overlap-error.ts
+var AsyncContextOverlapError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AsyncContextOverlapError";
+  }
+};
+
 // libs/utils/src/async-context/browser-async-context.ts
+var nativeAsyncContext = (() => {
+  const candidate = globalThis.AsyncContext;
+  return typeof candidate?.Variable === "function" ? candidate : void 0;
+})();
+function getAsyncContextMode() {
+  return nativeAsyncContext ? "native" : "serialized";
+}
+var SLOW_TURN_WARNING_MS = 1e4;
+var RequestSlot = class {
+  /** Frames of every storage that are still running in this request. */
+  live = 0;
+  /** Storages whose runs overlapped in this request; they refuse to answer until they unwind. */
+  tainted = /* @__PURE__ */ new Set();
+  idleWaiters = [];
+  enter() {
+    this.live++;
+  }
+  leave() {
+    this.live--;
+    if (this.live === 0) {
+      for (const resolve of this.idleWaiters.splice(0)) resolve();
+    }
+  }
+  /** Resolves once no frame of this request is running any more. */
+  idle() {
+    return this.live === 0 ? Promise.resolve() : new Promise((resolve) => this.idleWaiters.push(resolve));
+  }
+};
+var ROOT = new RequestSlot();
+var active = ROOT;
+var owner;
+var turnQueue = [];
+var slowTurnWarned = false;
+var overlapReported = false;
+function takeTurn(slot) {
+  if (!owner) {
+    owner = slot;
+    active = slot;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      if (slowTurnWarned) return;
+      slowTurnWarned = true;
+      console.warn(
+        "[frontmcp] A request has waited more than 10s for another one to finish. This runtime has no AsyncContext, so FrontMCP runs requests one at a time to keep their contexts apart. A tool that calls its own server through a client (instead of this.scope flows) waits for itself."
+      );
+    }, SLOW_TURN_WARNING_MS);
+    timer.unref?.();
+    turnQueue.push({
+      slot,
+      start: () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  });
+}
+function passTurn(slot) {
+  if (owner !== slot) return;
+  const next = turnQueue.shift();
+  if (next) {
+    owner = next.slot;
+    active = next.slot;
+    next.start();
+  } else {
+    owner = void 0;
+    active = ROOT;
+  }
+}
+async function runRequestExclusive(fn) {
+  if (nativeAsyncContext) return fn();
+  const slot = new RequestSlot();
+  await takeTurn(slot);
+  try {
+    return await fn();
+  } finally {
+    await slot.idle();
+    passTurn(slot);
+  }
+}
+async function awaitOutsideRequest(promise) {
+  if (nativeAsyncContext) return promise;
+  const slot = owner;
+  if (!slot || active !== slot) return promise;
+  passTurn(slot);
+  try {
+    return await promise;
+  } finally {
+    await takeTurn(slot);
+  }
+}
 var AsyncLocalStorage = class {
-  stack = [];
+  native;
+  stacks = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    if (nativeAsyncContext) this.native = new nativeAsyncContext.Variable();
+  }
   run(store, callback, ...args) {
-    this.stack.push(store);
+    if (this.native) return this.native.run(store, callback, ...args);
+    const slot = active;
+    let stack = this.stacks.get(slot);
+    if (!stack) {
+      stack = [];
+      this.stacks.set(slot, stack);
+    }
+    const frame = { store };
+    stack.push(frame);
+    slot.enter();
+    let result;
     try {
-      const result = callback(...args);
-      if (result instanceof Promise) {
-        return result.finally(() => this.stack.pop());
-      }
-      this.stack.pop();
-      return result;
-    } catch (err) {
-      this.stack.pop();
-      throw err;
+      result = callback(...args);
+    } catch (error) {
+      this.leave(slot, frame);
+      throw error;
     }
+    if (result instanceof Promise) {
+      return result.then(
+        (value) => {
+          if (!this.leave(slot, frame)) throw this.overlapError();
+          return value;
+        },
+        (error) => {
+          this.leave(slot, frame);
+          throw error;
+        }
+      );
+    }
+    this.leave(slot, frame);
+    return result;
   }
   getStore() {
-    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : void 0;
+    if (this.native) return this.native.get();
+    const slot = active;
+    if (slot.tainted.has(this)) throw this.overlapError();
+    const stack = this.stacks.get(slot);
+    return stack && stack.length > 0 ? stack[stack.length - 1].store : void 0;
+  }
+  /**
+   * Remove `frame` from its request's stack. Returns false when it was not the innermost frame: a
+   * later run of this storage in the same request was still open, so the two overlapped and reads
+   * in between may have seen the other run's store.
+   */
+  leave(slot, frame) {
+    const stack = this.stacks.get(slot) ?? [];
+    const index = stack.lastIndexOf(frame);
+    const innermost = index === stack.length - 1;
+    if (index !== -1) stack.splice(index, 1);
+    if (!innermost) {
+      slot.tainted.add(this);
+      if (!overlapReported) {
+        overlapReported = true;
+        console.error(
+          "[frontmcp] Two concurrent runs of one async context overlapped inside a request. This runtime has no AsyncContext, so the context of each cannot be told apart; reads fail for the rest of that request instead of returning the wrong value."
+        );
+      }
+    }
+    if (stack.length === 0) slot.tainted.delete(this);
+    slot.leave();
+    return innermost;
+  }
+  overlapError() {
+    return new AsyncContextOverlapError(
+      "Concurrent runs of an async context overlapped in one request, and this runtime has no AsyncContext to tell them apart. Run the calls one after another, or use a runtime with AsyncContext."
+    );
   }
 };
 export {
-  AsyncLocalStorage
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
 };

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

@@ -2,6 +2,29 @@ import { createRequire as __frontmcpCreateRequire } from 'module';
 const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
 // libs/utils/src/async-context/node-async-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
+
+// libs/utils/src/async-context/overlap-error.ts
+var AsyncContextOverlapError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AsyncContextOverlapError";
+  }
+};
+
+// libs/utils/src/async-context/node-async-context.ts
+function getAsyncContextMode() {
+  return "native";
+}
+async function runRequestExclusive(fn) {
+  return fn();
+}
+async function awaitOutsideRequest(promise) {
+  return promise;
+}
 export {
-  AsyncLocalStorage
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
 };

package/esm/index.mjs

@@ -4786,7 +4786,13 @@ function safeStringify(value, space) {
 init_crypto();
 
 // libs/utils/src/async-context/index.ts
-import { AsyncLocalStorage } from "#async-context";
+import {
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
+} from "#async-context";
 
 // libs/utils/src/event-emitter/index.ts
 import { EventEmitter as EventEmitter2 } from "#event-emitter";
@@ -5866,6 +5872,7 @@ function setMachineIdOverride(id) {
   machineIdOverride = id;
 }
 export {
+  AsyncContextOverlapError,
   AsyncLocalStorage,
   BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH,
@@ -5902,6 +5909,7 @@ export {
   assertNode,
   asymmetricAlgSchema,
   asymmetricKeyDataSchema,
+  awaitOutsideRequest,
   base64Decode,
   base64Encode,
   base64urlDecode,
@@ -5960,6 +5968,7 @@ export {
   generatePkcePair,
   generateRsaKeyPair2 as generateRsaKeyPair,
   generateSecret,
+  getAsyncContextMode,
   getCookie,
   getCrypto,
   getCwd2 as getCwd,
@@ -6039,6 +6048,7 @@ export {
   rsaVerify2 as rsaVerify,
   rsaVerifySync2 as rsaVerifySync,
   runCmd,
+  runRequestExclusive,
   safeExec,
   safeJsonForScript,
   safeMatch,

package/index.d.ts

@@ -21,7 +21,7 @@ export { escapeHtml, escapeHtmlAttr, escapeJsString, escapeScriptClose, safeJson
 export { safeStringify } from './serialization';
 export { getCrypto, rsaVerify, rsaVerifySync, pemToPublicJwk, generateRsaKeyPair, rsaSignBase64Url, type RsaJwk, type RsaKeyPair, jwtAlgToNodeAlg, isRsaPssAlg, randomUUID, randomBytes, sha256, sha256Hex, sha256Base64url, hmacSha256, hkdfSha256, encryptAesGcm, decryptAesGcm, timingSafeEqual, bytesToHex, base64urlEncode, base64urlDecode, base64Encode, base64Decode, isNode, isBrowser, assertNode, EncryptedBlobError, encryptValue, decryptValue, tryDecryptValue, serializeBlob, deserializeBlob, tryDeserializeBlob, isValidEncryptedBlob, encryptAndSerialize, deserializeAndDecrypt, tryDeserializeAndDecrypt, generateCodeVerifier, generateCodeChallenge, verifyCodeChallenge, generatePkcePair, isValidCodeVerifier, isValidCodeChallenge, MIN_CODE_VERIFIER_LENGTH, MAX_CODE_VERIFIER_LENGTH, DEFAULT_CODE_VERIFIER_LENGTH, PkceError, type PkcePair, type SecretData, type SecretPersistenceOptions, type SecretValidationResult, secretDataSchema, validateSecretData, parseSecretData, isSecretPersistenceEnabled, resolveSecretPath, loadSecret, saveSecret, deleteSecret, generateSecret, createSecretData, getOrCreateSecret, clearCachedSecret, isSecretCached, type SignedData, type HmacSigningConfig, signData, verifyData, isSignedData, verifyOrParseData, type BaseKeyData, type SecretKeyData, type AsymmetricKeyData, type AnyKeyData, type KeyPersistenceOptions, type CreateKeyPersistenceOptions, type CreateSecretOptions, type CreateAsymmetricOptions, type KeyValidationResult, asymmetricAlgSchema, secretKeyDataSchema, asymmetricKeyDataSchema, anyKeyDataSchema, validateKeyData, parseKeyData, isSecretKeyData, isAsymmetricKeyData, KeyPersistence, createKeyPersistence, createKeyPersistenceWithStorage, } from './crypto';
 export type { CryptoProvider, EncBlob, EncryptedBlob } from './crypto';
-export { AsyncLocalStorage } from './async-context';
+export { AsyncContextOverlapError, AsyncLocalStorage, awaitOutsideRequest, getAsyncContextMode, runRequestExclusive, type AsyncContextMode, } from './async-context';
 export { EventEmitter } from './event-emitter';
 export { getEnv, getCwd, isProduction, isDevelopment, getEnvFlag, isDebug, setEnv, isEdgeRuntime, isServerless, supportsAnsi, getRuntimeContext, resetRuntimeContext, detectRuntimeContext, isEntryAvailable, checkEntryAvailability, entryAvailabilitySchema, } from './env';
 export type { RuntimeContext, EntryAvailability } from './env';

package/index.js

@@ -3977,6 +3977,7 @@ var init_cloudflare_kv = __esm({
 // libs/utils/src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AsyncContextOverlapError: () => import_async_context.AsyncContextOverlapError,
   AsyncLocalStorage: () => import_async_context.AsyncLocalStorage,
   BaseStorageAdapter: () => BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH: () => DEFAULT_CODE_VERIFIER_LENGTH,
@@ -4013,6 +4014,7 @@ __export(index_exports, {
   assertNode: () => assertNode,
   asymmetricAlgSchema: () => asymmetricAlgSchema,
   asymmetricKeyDataSchema: () => asymmetricKeyDataSchema,
+  awaitOutsideRequest: () => import_async_context.awaitOutsideRequest,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
   base64urlDecode: () => base64urlDecode,
@@ -4071,6 +4073,7 @@ __export(index_exports, {
   generatePkcePair: () => generatePkcePair,
   generateRsaKeyPair: () => generateRsaKeyPair2,
   generateSecret: () => generateSecret,
+  getAsyncContextMode: () => import_async_context.getAsyncContextMode,
   getCookie: () => getCookie,
   getCrypto: () => getCrypto,
   getCwd: () => import_env3.getCwd,
@@ -4150,6 +4153,7 @@ __export(index_exports, {
   rsaVerify: () => rsaVerify2,
   rsaVerifySync: () => rsaVerifySync2,
   runCmd: () => runCmd,
+  runRequestExclusive: () => import_async_context.runRequestExclusive,
   safeExec: () => safeExec,
   safeJsonForScript: () => safeJsonForScript,
   safeMatch: () => safeMatch,
@@ -6086,6 +6090,7 @@ function setMachineIdOverride(id) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AsyncContextOverlapError,
   AsyncLocalStorage,
   BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH,
@@ -6122,6 +6127,7 @@ function setMachineIdOverride(id) {
   assertNode,
   asymmetricAlgSchema,
   asymmetricKeyDataSchema,
+  awaitOutsideRequest,
   base64Decode,
   base64Encode,
   base64urlDecode,
@@ -6180,6 +6186,7 @@ function setMachineIdOverride(id) {
   generatePkcePair,
   generateRsaKeyPair,
   generateSecret,
+  getAsyncContextMode,
   getCookie,
   getCrypto,
   getCwd,
@@ -6259,6 +6266,7 @@ function setMachineIdOverride(id) {
   rsaVerify,
   rsaVerifySync,
   runCmd,
+  runRequestExclusive,
   safeExec,
   safeJsonForScript,
   safeMatch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/utils",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Shared utility functions for FrontMCP - string manipulation, URI handling, path utilities, and more",
   "author": "AgentFront <info@agentfront.dev>",
   "license": "Apache-2.0",
@@ -27,12 +27,12 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@enclave-vm/ast": "^2.15.2",
+    "@enclave-vm/ast": "^2.15.3",
     "@noble/ciphers": "^2.1.1",
     "@noble/hashes": "^2.0.1"
   },
   "peerDependencies": {
-    "@frontmcp/lazy-zod": "1.8.2",
+    "@frontmcp/lazy-zod": "1.8.4",
     "@vercel/kv": "^2.0.0 || ^3.0.0",
     "ioredis": "^5.0.0"
   },