@wrongstack/primitives 0.316.2 → 0.317.2

package/dist/index.js

@@ -12,28 +12,41 @@ var DANGEROUS_PATTERNS = [
   /\(\?<?[!=][^)]*[+*][^)]*\)/
 ];
 function hasAmbiguousQuantifiedAlternation(pattern) {
+  let outerInClass = false;
   for (let i = 0; i < pattern.length; i++) {
-    if (pattern[i] !== "(") continue;
-    if (i > 0 && pattern[i - 1] === "\\") continue;
+    const ch = pattern[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (outerInClass) {
+      if (ch === "]") outerInClass = false;
+      continue;
+    }
+    if (ch === "[") {
+      outerInClass = true;
+      continue;
+    }
+    if (ch !== "(") continue;
     let depth = 0;
     let inClass = false;
     let j = i;
     for (; j < pattern.length; j++) {
-      const ch = pattern[j];
-      if (ch === "\\") {
+      const ch2 = pattern[j];
+      if (ch2 === "\\") {
         j++;
         continue;
       }
       if (inClass) {
-        if (ch === "]") inClass = false;
+        if (ch2 === "]") inClass = false;
         continue;
       }
-      if (ch === "[") {
+      if (ch2 === "[") {
         inClass = true;
         continue;
       }
-      if (ch === "(") depth++;
-      else if (ch === ")") {
+      if (ch2 === "(") depth++;
+      else if (ch2 === ")") {
         depth--;
         if (depth === 0) break;
       }
@@ -48,30 +61,30 @@ function hasAmbiguousQuantifiedAlternation(pattern) {
     let d = 0;
     let cls = false;
     for (let k = 0; k < inner.length; k++) {
-      const ch = inner[k];
-      if (ch === "\\") {
-        current += ch + (inner[k + 1] ?? "");
+      const ch2 = inner[k];
+      if (ch2 === "\\") {
+        current += ch2 + (inner[k + 1] ?? "");
         k++;
         continue;
       }
       if (cls) {
-        if (ch === "]") cls = false;
-        current += ch;
+        if (ch2 === "]") cls = false;
+        current += ch2;
         continue;
       }
-      if (ch === "[") {
+      if (ch2 === "[") {
         cls = true;
-        current += ch;
+        current += ch2;
         continue;
       }
-      if (ch === "(") d++;
-      if (ch === ")") d--;
-      if (ch === "|" && d === 0) {
+      if (ch2 === "(") d++;
+      if (ch2 === ")") d--;
+      if (ch2 === "|" && d === 0) {
         branches.push(current);
         current = "";
         continue;
       }
-      current += ch;
+      current += ch2;
     }
     branches.push(current);
     if (branches.length < 2) continue;
@@ -86,10 +99,30 @@ function hasAmbiguousQuantifiedAlternation(pattern) {
   }
   return false;
 }
-function compileUserRegex(pattern, flags) {
+var COMPILED_CACHE = /* @__PURE__ */ new Map();
+var CACHE_MAX_SIZE = 500;
+function compileUserRegex(pattern, flags = "") {
   if (typeof pattern !== "string") {
     return { ok: false, reason: "pattern must be a string" };
   }
+  const cacheKey = `${flags}\0${pattern}`;
+  const cached = COMPILED_CACHE.get(cacheKey);
+  if (cached !== void 0) {
+    return cached.ok ? { ok: true, regex: new RegExp(pattern, flags) } : cached;
+  }
+  if (COMPILED_CACHE.size >= CACHE_MAX_SIZE) {
+    let evicted = 0;
+    const target = Math.floor(CACHE_MAX_SIZE / 4);
+    for (const key of COMPILED_CACHE.keys()) {
+      COMPILED_CACHE.delete(key);
+      if (++evicted >= target) break;
+    }
+  }
+  const result = compileUncached(pattern, flags);
+  COMPILED_CACHE.set(cacheKey, result);
+  return result.ok ? { ok: true, regex: new RegExp(pattern, flags) } : result;
+}
+function compileUncached(pattern, flags) {
   if (pattern.length === 0) {
     return { ok: false, reason: "pattern is empty" };
   }
@@ -144,7 +177,7 @@ function systemSessionId(actor) {
   return `${SYSTEM_SESSION_PREFIX}${actor}`;
 }
 function isSystemSessionId(sessionId) {
-  return sessionId.startsWith(SYSTEM_SESSION_PREFIX);
+  return typeof sessionId === "string" && sessionId.startsWith(SYSTEM_SESSION_PREFIX);
 }
 
 // src/time.ts

package/dist/regex-guard.d.ts

@@ -30,7 +30,7 @@ export interface CompileFail {
     reason: string;
 }
 export type CompileUserRegexResult = CompileResult | CompileFail;
-export declare function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail;
+export declare function compileUserRegex(pattern: string, flags?: string): CompileResult | CompileFail;
 /**
  * Maximum subject length handed to a user-supplied regex before matching.
  * A linear-time pattern over a multi-megabyte line is still a stall; tools

package/dist/session-id.d.ts

@@ -25,5 +25,5 @@ export declare const SYSTEM_SESSION_PREFIX: 'system:';
  */
 export declare function systemSessionId(actor: string): string;
 /** Whether this id names a daemon rather than a user session. */
-export declare function isSystemSessionId(sessionId: string): boolean;
+export declare function isSystemSessionId(sessionId: string | null | undefined): boolean;
 //# sourceMappingURL=session-id.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/primitives",
-  "version": "0.316.2",
+  "version": "0.317.2",
   "license": "MIT",
   "description": "Dependency-leaf primitives shared across WrongStack packages (regex guard, slugs, timestamps).",
   "repository": {