@ultimat3/mcp 7.0.0 → 9.0.0

package/CLAUDE.md

@@ -73,6 +73,15 @@ import. The CLI wires it.
   the raw error, zero frames written, the request unanswered and every later request on that buffer
   never processed. Same shape `toolsCall` uses — a framework error keeps its code/cause/fix, anything
   else is `-32603` with no internals.
+- **A declared `pattern` is compiled once per schema NODE, never once per `tools/call`.** A tool's
+  schema is registered at boot and validated on every call, so `new RegExp(pattern)` in `string()`
+  was per-request work over a constant — `@ultimat3/schema`'s `patternTester` already draws the
+  line in the same place for the same contract. The memo is a `WeakMap` keyed on the node, not a
+  `Map` keyed on the pattern string: a process registering tools dynamically would otherwise
+  accumulate one entry per distinct pattern forever with nothing to evict it. An uncompilable
+  pattern caches its `null` verdict too — it is the branch with the highest per-call cost.
+  `compiledPatternCount()` is the test-only probe (not in `index.ts`); a count that climbs once
+  per CALL is the memo gone, which `validate-args.test.ts` asserts over 100 calls.
 - **`format` is NOT in the wire subset**, and `wire.ts` types it `never` so re-adding it does not
   compile. It names a rule whose meaning lives in `@ultimat3/schema` (`uuid`, `email`,
   `iana-time-zone`), and this package cannot check it without a second definition of each that can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/mcp",
-  "version": "7.0.0",
+  "version": "9.0.0",
   "description": "MCP server, dev tools, and the action-to-tool projection — one authz system, two surfaces",
   "license": "MIT",
   "type": "module",
@@ -31,12 +31,12 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/action": "7.0.0",
-    "@ultimat3/core": "7.0.0",
-    "@ultimat3/entity": "7.0.0",
-    "@ultimat3/jobs": "7.0.0",
-    "@ultimat3/policy": "7.0.0",
-    "@ultimat3/query": "7.0.0",
-    "@ultimat3/schema": "7.0.0"
+    "@ultimat3/action": "9.0.0",
+    "@ultimat3/core": "9.0.0",
+    "@ultimat3/entity": "9.0.0",
+    "@ultimat3/jobs": "9.0.0",
+    "@ultimat3/policy": "9.0.0",
+    "@ultimat3/query": "9.0.0",
+    "@ultimat3/schema": "9.0.0"
   }
 }

package/src/validate-args.ts

@@ -136,21 +136,54 @@ function string(schema: JsonSchema, input: unknown, path: string, issues: ArgIss
   if (schema.maxLength !== undefined && input.length > schema.maxLength) {
     issues.push({ path, message: `must be at most ${schema.maxLength} characters` });
   }
-  if (schema.pattern !== undefined) matchesPattern(schema.pattern, input, path, issues);
+  if (schema.pattern !== undefined) matchesPattern(schema, schema.pattern, input, path, issues);
   return input;
 }
 
+/**
+ * Compiled ONCE per schema NODE, never once per call. A tool's schema is registered at boot and
+ * every `tools/call` validates against that same object, so `new RegExp(pattern)` in the hot path
+ * was per-request work over a constant — `@ultimat3/schema`'s `patternTester` already draws the
+ * line in the same place for the same contract.
+ *
+ * Keyed on the NODE rather than on the pattern STRING, and a `WeakMap` rather than a `Map`: a
+ * pattern reaches this file from a tool an app registered, and a process that registers tools
+ * dynamically would otherwise accumulate one entry per distinct pattern string forever, with no
+ * bound and nothing to evict it. Keyed on the node, the entry dies with the schema.
+ *
+ * `null` is a CACHED verdict, not a miss — an uncompilable pattern would otherwise re-enter the
+ * `try` on every call, which is the case with the highest per-call cost.
+ */
+const compiledPatterns = new WeakMap<JsonSchema, RegExp | null>();
+
+/** Test-only probe. A count that climbs once per CALL rather than once per schema is the memo gone. */
+let compilations = 0;
+export const compiledPatternCount = (): number => compilations;
+
 /**
  * A pattern this server cannot COMPILE is refused, not skipped. `tools/list` published it, so an
  * agent has already been told the rule — passing a call the server cannot check is the silent-pass
  * this whole module exists to prevent. Every framework-projected pattern is a `RegExp.source` and
  * compiles; only a hand-written tool can reach the second branch, and that is its author's bug.
  */
-function matchesPattern(pattern: string, input: string, path: string, issues: ArgIssue[]): void {
-  let compiled: RegExp;
-  try {
-    compiled = new RegExp(pattern);
-  } catch {
+function matchesPattern(
+  schema: JsonSchema,
+  pattern: string,
+  input: string,
+  path: string,
+  issues: ArgIssue[],
+): void {
+  let compiled = compiledPatterns.get(schema);
+  if (compiled === undefined) {
+    compilations += 1;
+    try {
+      compiled = new RegExp(pattern);
+    } catch {
+      compiled = null;
+    }
+    compiledPatterns.set(schema, compiled);
+  }
+  if (compiled === null) {
     issues.push({ path, message: `declares a pattern this server cannot compile: ${pattern}` });
     return;
   }