@frontmcp/utils 1.12.0 → 1.12.1

package/browser/escape/escape.mjs

@@ -34,7 +34,32 @@ function safeJsonForScript(value) {
     return '{"error":"Value could not be serialized"}';
   }
 }
+function isControlCharacter(code) {
+  return code <= 31 && code !== 9 || code >= 127 && code <= 159 || code === 8232 || code === 8233;
+}
+var NAMED_CONTROL_ESCAPES = {
+  "\n": "\\n",
+  "\r": "\\r",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\v": "\\v"
+};
+function escapeControlCharacters(value) {
+  if (value === null || value === void 0) return "";
+  const text = typeof value === "string" ? value : String(value);
+  let escaped = "";
+  let copiedUpTo = 0;
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (!isControlCharacter(code)) continue;
+    escaped += text.slice(copiedUpTo, index);
+    escaped += NAMED_CONTROL_ESCAPES[text[index]] ?? `\\u${code.toString(16).padStart(4, "0")}`;
+    copiedUpTo = index + 1;
+  }
+  return copiedUpTo === 0 ? text : escaped + text.slice(copiedUpTo);
+}
 export {
+  escapeControlCharacters,
   escapeHtml,
   escapeHtmlAttr,
   escapeJsString,

package/browser/escape/index.mjs

@@ -1,6 +1,14 @@
 // libs/utils/src/escape/index.ts
-import { escapeHtml, escapeHtmlAttr, escapeJsString, escapeScriptClose, safeJsonForScript } from "./escape.mjs";
+import {
+  escapeHtml,
+  escapeHtmlAttr,
+  escapeJsString,
+  escapeScriptClose,
+  safeJsonForScript,
+  escapeControlCharacters
+} from "./escape.mjs";
 export {
+  escapeControlCharacters,
   escapeHtml,
   escapeHtmlAttr,
   escapeJsString,

package/browser/http/index.mjs

@@ -1,11 +1,15 @@
 // libs/utils/src/http/index.ts
 import { validateBaseUrl } from "./http.mjs";
+import { readBodyWithLimit, readTextWithLimit, ResponseTooLargeError } from "./limited-body.mjs";
 import { buildSetCookie, parseCookies, getCookie, isLocalhost, isSecureRequest } from "./cookie.mjs";
 export {
+  ResponseTooLargeError,
   buildSetCookie,
   getCookie,
   isLocalhost,
   isSecureRequest,
   parseCookies,
+  readBodyWithLimit,
+  readTextWithLimit,
   validateBaseUrl
 };

package/browser/http/limited-body.mjs

@@ -0,0 +1,74 @@
+// libs/utils/src/http/limited-body.ts
+var ResponseTooLargeError = class extends Error {
+  maxBytes;
+  constructor(maxBytes) {
+    super(`Response body exceeds the limit of ${maxBytes} bytes`);
+    this.name = "ResponseTooLargeError";
+    this.maxBytes = maxBytes;
+  }
+};
+function checkLimit(maxBytes) {
+  if (!Number.isFinite(maxBytes) || maxBytes < 0) {
+    throw new RangeError(`maxBytes must be a non-negative finite number, got ${maxBytes}`);
+  }
+}
+function concat(chunks, total) {
+  if (chunks.length === 1) return chunks[0];
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+async function readBodyWithLimit(response, maxBytes) {
+  checkLimit(maxBytes);
+  const declared = response.headers?.get("content-length");
+  if (declared !== null && declared !== void 0 && declared.trim() !== "") {
+    const length = Number(declared);
+    if (Number.isFinite(length) && length > maxBytes) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new ResponseTooLargeError(maxBytes);
+    }
+  }
+  const body = response.body;
+  if (!body) {
+    let bytes;
+    if (typeof response.arrayBuffer === "function") {
+      bytes = new Uint8Array(await response.arrayBuffer());
+    } else if (typeof response.text === "function") {
+      bytes = new TextEncoder().encode(await response.text());
+    } else {
+      bytes = new Uint8Array(0);
+    }
+    if (bytes.byteLength > maxBytes) throw new ResponseTooLargeError(maxBytes);
+    return bytes;
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new ResponseTooLargeError(maxBytes);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return concat(chunks, total);
+}
+async function readTextWithLimit(response, maxBytes) {
+  return new TextDecoder().decode(await readBodyWithLimit(response, maxBytes));
+}
+export {
+  ResponseTooLargeError,
+  readBodyWithLimit,
+  readTextWithLimit
+};

package/browser/index.mjs

@@ -23,7 +23,17 @@ import {
   sep
 } from "./path/index.mjs";
 import { sanitizeToJson, inferMimeType, findNonFiniteNumber, findDroppedKeys } from "./content/index.mjs";
-import { validateBaseUrl, buildSetCookie, parseCookies, getCookie, isLocalhost, isSecureRequest } from "./http/index.mjs";
+import {
+  validateBaseUrl,
+  buildSetCookie,
+  parseCookies,
+  getCookie,
+  isLocalhost,
+  isSecureRequest,
+  readBodyWithLimit,
+  readTextWithLimit,
+  ResponseTooLargeError
+} from "./http/index.mjs";
 import {
   classifyIpAddress,
   expandIpv6,
@@ -94,8 +104,16 @@ import {
   createPipeUpstream
 } from "./stdio-bridge/index.mjs";
 import { redactFields, redactJson } from "./redaction/index.mjs";
-import { escapeHtml, escapeHtmlAttr, escapeJsString, escapeScriptClose, safeJsonForScript } from "./escape/index.mjs";
+import {
+  escapeHtml,
+  escapeHtmlAttr,
+  escapeJsString,
+  escapeScriptClose,
+  safeJsonForScript,
+  escapeControlCharacters
+} from "./escape/index.mjs";
 import { brandClass, isBrandedInstance } from "./class-brand/index.mjs";
+import { registerOptionalModule, requireOptionalModule } from "./optional-module/index.mjs";
 import { safeStringify, canonicalJson } from "./serialization/index.mjs";
 import {
   getCrypto,
@@ -264,6 +282,7 @@ import {
   FileSystemStorageAdapter,
   TypedStorage,
   EncryptedTypedStorage,
+  createGlobMatcher,
   globToRegex,
   matchesPattern,
   validatePattern,
@@ -313,6 +332,7 @@ export {
   PkceError,
   REDOS_THRESHOLDS,
   RedisStorageAdapter,
+  ResponseTooLargeError,
   StorageConfigError,
   StorageConnectionError,
   StorageError,
@@ -357,6 +377,7 @@ export {
   cp,
   createBridgeStateMachine,
   createChangeFeed,
+  createGlobMatcher,
   createHttpUpstream,
   createKeyPersistence,
   createKeyPersistenceWithStorage,
@@ -385,6 +406,7 @@ export {
   ensureDirSync,
   ensureMaxLen,
   entryAvailabilitySchema,
+  escapeControlCharacters,
   escapeGlob,
   escapeHtml,
   escapeHtmlAttr,
@@ -487,17 +509,21 @@ export {
   processTreeSpawnOptions,
   randomBytes,
   randomUUID,
+  readBodyWithLimit,
   readFile,
   readFileBuffer,
   readFileSync,
   readJSON,
+  readTextWithLimit,
   readdir,
   readdirSync,
   realpath,
   reapOrphans,
   redactFields,
   redactJson,
+  registerOptionalModule,
   rename,
+  requireOptionalModule,
   resetRuntimeContext,
   resolveSecretPath,
   rm,

package/browser/optional-module/index.mjs

@@ -0,0 +1,6 @@
+// libs/utils/src/optional-module/index.ts
+import { registerOptionalModule, requireOptionalModule } from "./optional-module.mjs";
+export {
+  registerOptionalModule,
+  requireOptionalModule
+};

package/browser/optional-module/optional-module.mjs

@@ -0,0 +1,18 @@
+// libs/utils/src/optional-module/optional-module.ts
+var BUNDLED_OPTIONAL_MODULES = /* @__PURE__ */ Symbol.for("frontmcp.bundledOptionalModules");
+function bundledOptionalModules() {
+  const registryHost = globalThis;
+  registryHost[BUNDLED_OPTIONAL_MODULES] ??= /* @__PURE__ */ new Map();
+  return registryHost[BUNDLED_OPTIONAL_MODULES];
+}
+function registerOptionalModule(moduleName, moduleExports) {
+  bundledOptionalModules().set(moduleName, moduleExports);
+}
+function requireOptionalModule(moduleName, load) {
+  const registry = bundledOptionalModules();
+  return registry.has(moduleName) ? registry.get(moduleName) : load();
+}
+export {
+  registerOptionalModule,
+  requireOptionalModule
+};

package/browser/redaction/redaction.mjs

@@ -1,5 +1,6 @@
 // libs/utils/src/redaction/redaction.ts
 var REDACTED = "[REDACTED]";
+var TRUNCATED = "[TRUNCATED]";
 function redactFields(obj, fields, maxDepth = 5) {
   if (typeof fields !== "function" && fields.length === 0) return obj;
   return redactRecord(obj, 0, { isSensitive: sensitiveKeyTest(fields), maxDepth, jsonText: false });
@@ -14,23 +15,24 @@ function sensitiveKeyTest(fields) {
 }
 function redactValue(value, depth, options) {
   if (typeof value === "string") return options.jsonText ? redactJsonText(value, depth, options) : value;
-  if (Array.isArray(value)) return value.map((item) => redactValue(item, depth, options));
+  const isList = Array.isArray(value);
+  if ((isList || isPlainObject(value)) && depth >= options.maxDepth) return TRUNCATED;
+  if (isList) return value.map((item) => redactValue(item, depth + 1, options));
   if (isPlainObject(value)) return redactRecord(value, depth, options);
   return value;
 }
 function redactRecord(obj, depth, options) {
-  if (depth >= options.maxDepth) return obj;
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
     result[key] = options.isSensitive(key) ? REDACTED : redactValue(value, depth + 1, options);
   }
   return result;
 }
-var AUTH_SCHEME_CREDENTIAL = /\b(Bearer|Basic)([ \t]+)(?=[\w.~+/-]*[\d.~+/_-])[\w.~+/-]{8,}=*/gi;
+var AUTH_SCHEME_CREDENTIAL = /\b(Bearer|Basic)([ \t]+)(?:(?=[\w.~+/-]*[\d.~+/_-])[\w.~+/-]{8,}|[A-Za-z]{20,})=*/gi;
 var JWT = /(?<![\w-])eyJ[\w-]+(?:\.[\w-]*){2,4}/g;
 var URL_CREDENTIALS = /(?<![a-z\d+.-])([a-z][a-z\d+.-]*:\/\/)[^\s/?#@]+@/gi;
 var VALUE_NAME = /(?:^|[?&#;,{("'\s])(["']?)([A-Za-z_][\w.-]*)\1[ \t]*[:=][ \t]*/g;
-var NAMED_VALUE = /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|[^\s"'&#;?,)}]+/y;
+var NAMED_VALUE = /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|(?:(?:Bearer|Basic)[ \t]+)?[^\s"'&#;?,)}]+/iy;
 function redactNamedValues(text, isSensitive) {
   let redacted = "";
   let copiedUpTo = 0;

package/browser/stdio-bridge/sse-frames.mjs

@@ -4,6 +4,7 @@ async function relaySseFrames(body, deliver, log, maxEventChars = MAX_EVENT_CHAR
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  let searchedUpTo = 0;
   let eventData = [];
   let eventChars = 0;
   async function deliverEvent() {
@@ -24,7 +25,7 @@ async function relaySseFrames(body, deliver, log, maxEventChars = MAX_EVENT_CHAR
       return;
     }
     buffer += decoder.decode(value, { stream: true });
-    let newline = buffer.indexOf("\n");
+    let newline = buffer.indexOf("\n", searchedUpTo);
     while (newline >= 0) {
       const line = buffer.slice(0, newline).trim();
       buffer = buffer.slice(newline + 1);
@@ -37,6 +38,7 @@ async function relaySseFrames(body, deliver, log, maxEventChars = MAX_EVENT_CHAR
         eventChars += data.length + 1;
       }
     }
+    searchedUpTo = buffer.length;
     if (eventChars + buffer.length > maxEventChars) {
       await reader.cancel();
       throw new Error(`an SSE event is larger than ${maxEventChars} characters`);

package/browser/stdio-bridge/stdio-framer.mjs

@@ -3,13 +3,15 @@ import { makeDevError } from "./errors.mjs";
 function createStdioFramer(options) {
   const { input, output, log, onFrame, onClose } = options;
   let buffer = "";
+  let searchedUpTo = 0;
   let paused = false;
   let drainResolvers = [];
   function flushBuffer() {
     let nl;
-    while ((nl = buffer.indexOf("\n")) >= 0) {
+    while ((nl = buffer.indexOf("\n", searchedUpTo)) >= 0) {
       const raw = buffer.slice(0, nl).replace(/\r$/, "");
       buffer = buffer.slice(nl + 1);
+      searchedUpTo = 0;
       if (raw.length === 0) continue;
       let parsed;
       try {
@@ -30,6 +32,7 @@ function createStdioFramer(options) {
         });
       });
     }
+    searchedUpTo = buffer.length;
   }
   let closed = false;
   function onInputClosed() {

package/browser/storage/adapters/filesystem.mjs

@@ -1,8 +1,8 @@
 // libs/utils/src/storage/adapters/filesystem.ts
 import { bytesToHex, randomBytes } from "../../crypto/index.mjs";
-import { ensureDir, fileExists, mkdir, readdir, readJSON, rename, unlink, writeFile } from "../../fs/index.mjs";
+import { fileExists, mkdir, readdir, readJSON, rename, unlink, writeFile } from "../../fs/index.mjs";
 import { StorageOperationError } from "../errors.mjs";
-import { globToRegex } from "../utils/pattern.mjs";
+import { createGlobMatcher } from "../utils/pattern.mjs";
 import { BaseStorageAdapter } from "./base.mjs";
 var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   backendName = "filesystem";
@@ -10,6 +10,8 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   extension;
   dirMode;
   fileMode;
+  /** The last update queued for each key, so a counter's read and write never interleave with another update. */
+  keyUpdates = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
     this.baseDir = options.baseDir;
@@ -22,11 +24,7 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   // ============================================
   async connect() {
     if (this.connected) return;
-    await ensureDir(this.baseDir);
-    try {
-      await mkdir(this.baseDir, { recursive: true, mode: this.dirMode });
-    } catch {
-    }
+    await mkdir(this.baseDir, { recursive: true, mode: this.dirMode });
     this.connected = true;
   }
   async disconnect() {
@@ -104,6 +102,10 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   // ============================================
   async expire(key, ttlSeconds) {
     this.ensureConnected();
+    return this.updateInTurn(key, () => this.expireNow(key, ttlSeconds));
+  }
+  /** Set the expiry of `key` from its current entry; run only through {@link updateInTurn}. */
+  async expireNow(key, ttlSeconds) {
     const filePath = this.keyToPath(key);
     const entry = await this.readEntry(filePath);
     if (!entry || this.isExpired(entry)) {
@@ -132,14 +134,14 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   // ============================================
   async keys(pattern = "*") {
     this.ensureConnected();
-    const regex = globToRegex(pattern);
+    const matches = createGlobMatcher(pattern);
     const result = [];
     try {
       const files = await readdir(this.baseDir);
       for (const file of files) {
         if (!file.endsWith(this.extension)) continue;
         const key = this.pathToKey(file);
-        if (!regex.test(key)) continue;
+        if (!matches(key)) continue;
         const filePath = this.keyToPath(key);
         const entry = await this.readEntry(filePath);
         if (entry && !this.isExpired(entry)) {
@@ -168,6 +170,10 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   }
   async incrBy(key, amount) {
     this.ensureConnected();
+    return this.updateInTurn(key, () => this.incrByNow(key, amount));
+  }
+  /** Add `amount` to the counter at `key`; run only through {@link updateInTurn}. */
+  async incrByNow(key, amount) {
     const filePath = this.keyToPath(key);
     const entry = await this.readEntry(filePath);
     let currentValue = 0;
@@ -189,6 +195,22 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
   // ============================================
   // Internal Helpers
   // ============================================
+  /**
+   * Run `update` once the updates of `key` queued before it in this process have finished, so two updates of
+   * one key never read the same entry. Processes that share a directory are not coordinated.
+   */
+  updateInTurn(key, update) {
+    const result = (this.keyUpdates.get(key) ?? Promise.resolve()).then(update);
+    const settled = result.then(
+      () => void 0,
+      () => void 0
+    );
+    this.keyUpdates.set(key, settled);
+    void settled.then(() => {
+      if (this.keyUpdates.get(key) === settled) this.keyUpdates.delete(key);
+    });
+    return result;
+  }
   /**
    * Convert a storage key to a file path.
    * Sanitizes the key to be filesystem-safe.

package/browser/storage/adapters/memory.mjs

@@ -1,7 +1,7 @@
 // libs/utils/src/storage/adapters/memory.ts
 import { EventEmitter } from "../../event-emitter/browser-event-emitter.mjs";
 import { StorageOperationError } from "../errors.mjs";
-import { globToRegex } from "../utils/pattern.mjs";
+import { createGlobMatcher } from "../utils/pattern.mjs";
 import { expiresAtToTTL, isExpired, ttlToExpiresAt, validateTTL } from "../utils/ttl.mjs";
 import { BaseStorageAdapter } from "./base.mjs";
 var DEFAULT_SWEEP_INTERVAL_SECONDS = 60;
@@ -12,8 +12,8 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
   emitter = new EventEmitter();
   sweepInterval;
   options;
-  // LRU tracking (simple linked list via insertion order in Map)
-  accessOrder = [];
+  // LRU tracking: a Set keeps insertion order, and adding a key again moves it to the end
+  accessOrder = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     super();
     this.options = {
@@ -39,7 +39,7 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
     this.stopSweeper();
     this.clearAllTimeouts();
     this.store.clear();
-    this.accessOrder = [];
+    this.accessOrder.clear();
     this.emitter.removeAllListeners();
     this.connected = false;
   }
@@ -83,11 +83,7 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
         }
       }
     }
-    if (this.options.maxEntries > 0 && !this.store.has(key)) {
-      while (this.store.size >= this.options.maxEntries) {
-        this.evictOldest();
-      }
-    }
+    this.makeRoomFor(key);
     this.store.set(key, entry);
     this.touchLRU(key);
   }
@@ -165,14 +161,14 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
   // ============================================
   async keys(pattern = "*") {
     this.ensureConnected();
-    const regex = globToRegex(pattern);
+    const matches = createGlobMatcher(pattern);
     const result = [];
     for (const [key, entry] of this.store) {
       if (isExpired(entry.expiresAt)) {
         this.deleteEntry(key);
         continue;
       }
-      if (regex.test(key)) {
+      if (matches(key)) {
         result.push(key);
       }
     }
@@ -213,6 +209,7 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
         }
       }
     }
+    this.makeRoomFor(key);
     this.store.set(key, newEntry);
     this.touchLRU(key);
     return newValue;
@@ -274,31 +271,33 @@ var MemoryStorageAdapter = class extends BaseStorageAdapter {
    */
   touchLRU(key) {
     if (this.options.maxEntries <= 0) return;
-    const idx = this.accessOrder.indexOf(key);
-    if (idx !== -1) {
-      this.accessOrder.splice(idx, 1);
-    }
-    this.accessOrder.push(key);
+    this.accessOrder.delete(key);
+    this.accessOrder.add(key);
   }
   /**
    * Remove key from LRU tracking.
    */
   removeLRU(key) {
-    if (this.options.maxEntries <= 0) return;
-    const idx = this.accessOrder.indexOf(key);
-    if (idx !== -1) {
-      this.accessOrder.splice(idx, 1);
+    this.accessOrder.delete(key);
+  }
+  /**
+   * Evict least recently used entries until a new key fits within maxEntries.
+   */
+  makeRoomFor(key) {
+    if (this.options.maxEntries <= 0 || this.store.has(key)) return;
+    while (this.store.size >= this.options.maxEntries) {
+      if (!this.evictOldest()) return;
     }
   }
   /**
-   * Evict oldest entry (LRU).
+   * Evict the least recently used entry. Returns false when no entry is left to evict.
    */
   evictOldest() {
-    if (this.accessOrder.length === 0) return;
-    const oldestKey = this.accessOrder.shift();
-    if (oldestKey) {
-      this.deleteEntry(oldestKey);
-    }
+    const oldest = this.accessOrder.values().next();
+    if (oldest.done) return false;
+    this.accessOrder.delete(oldest.value);
+    this.deleteEntry(oldest.value);
+    return true;
   }
   /**
    * Start background sweeper.

package/browser/storage/factory.mjs

@@ -12,6 +12,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 import { z } from "@frontmcp/lazy-zod";
 import { getEnv, isProduction } from "../env/browser-env.mjs";
 import { getRuntimeContext } from "../env/browser-runtime-context.mjs";
+import { requireOptionalModule } from "../optional-module/index.mjs";
 import { MemoryStorageAdapter } from "./adapters/memory.mjs";
 import { StorageConfigError } from "./errors.mjs";
 import { createNamespacedStorage, createRootStorage } from "./namespace.mjs";
@@ -32,7 +33,7 @@ function parseSqliteOptions(options) {
 }
 function loadSqliteStorage() {
   try {
-    return __require(SQLITE_STORAGE_PACKAGE);
+    return requireOptionalModule(SQLITE_STORAGE_PACKAGE, () => __require(SQLITE_STORAGE_PACKAGE));
   } catch (error) {
     const missing = error.code === "MODULE_NOT_FOUND";
     if (!missing || !String(error.message).includes(SQLITE_STORAGE_PACKAGE)) throw error;

package/browser/storage/index.mjs

@@ -35,7 +35,7 @@ import {
   LocalStorageAdapter,
   IndexedDBStorageAdapter
 } from "./adapters/index.mjs";
-import { globToRegex, matchesPattern, validatePattern, escapeGlob } from "./utils/pattern.mjs";
+import { createGlobMatcher, globToRegex, matchesPattern, validatePattern, escapeGlob } from "./utils/pattern.mjs";
 import {
   MAX_TTL_SECONDS,
   validateTTL,
@@ -74,6 +74,7 @@ export {
   attachRedisErrorListener,
   buildPrefix,
   createChangeFeed,
+  createGlobMatcher,
   createMemoryStorage,
   createNamespacedStorage,
   createRedisClient,

package/browser/storage/utils/index.mjs

@@ -1,5 +1,5 @@
 // libs/utils/src/storage/utils/index.ts
-import { globToRegex, matchesPattern, validatePattern, escapeGlob } from "./pattern.mjs";
+import { createGlobMatcher, globToRegex, matchesPattern, validatePattern, escapeGlob } from "./pattern.mjs";
 import {
   MAX_TTL_SECONDS,
   validateTTL,
@@ -11,6 +11,7 @@ import {
 } from "./ttl.mjs";
 export {
   MAX_TTL_SECONDS,
+  createGlobMatcher,
   escapeGlob,
   expiresAtToTTL,
   globToRegex,