@fungi.computer/truffle 0.5.0 → 0.6.0

package/dist/internal/private-workerd-sandbox-worker.mjs

@@ -20658,6 +20658,94 @@ function date4(params) {
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// ../../packages/forage/dist/normalization.js
+var jsonValueSchema = external_exports.json();
+function isJsonObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function compareCodeUnits(left, right) {
+  if (left === right)
+    return 0;
+  const length = Math.min(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = left.charCodeAt(index) - right.charCodeAt(index);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.length - right.length;
+}
+function normalizeQuery(query) {
+  return query.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_./:-]/g, " ").toLowerCase().trim();
+}
+function tokenize(text) {
+  return text.split(/[^a-zA-Z0-9]+/).filter((token) => token.length > 0);
+}
+var stopwords = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "for",
+  "to",
+  "of",
+  "that",
+  "this",
+  "with",
+  "in",
+  "on"
+]);
+function isStopword(token) {
+  return stopwords.has(token);
+}
+function stemVariants(token) {
+  const variants = [];
+  const add2 = (variant) => {
+    if (variant !== token && variant.length >= 3 && !variants.includes(variant)) {
+      variants.push(variant);
+    }
+  };
+  if (token.endsWith("ing") && token.length > 4)
+    add2(token.slice(0, -3));
+  if (token.endsWith("ed") && token.length > 3)
+    add2(token.slice(0, -2));
+  if (token.endsWith("ation") && token.length > 6) {
+    add2(`${token.slice(0, -3)}e`);
+  }
+  if (token.endsWith("ies") && token.length > 4) {
+    add2(token.slice(0, -3));
+    add2(`${token.slice(0, -3)}y`);
+  }
+  if (token.endsWith("es") && token.length > 3)
+    add2(token.slice(0, -2));
+  if (token.endsWith("s") && !token.endsWith("ss") && token.length > 3) {
+    add2(token.slice(0, -1));
+  }
+  return variants;
+}
+function hashString64(value) {
+  let word0 = 8997;
+  let word1 = 33826;
+  let word2 = 40164;
+  let word3 = 52210;
+  for (let index = 0; index < value.length; index += 1) {
+    const low = word0 ^ value.charCodeAt(index);
+    const product0 = low * 435;
+    const product1 = word1 * 435 + (product0 >>> 16);
+    const product2 = word2 * 435 + (product1 >>> 16) + (low << 8);
+    const product3 = word3 * 435 + (product2 >>> 16) + (word1 << 8);
+    word0 = product0 & 65535;
+    word1 = product1 & 65535;
+    word2 = product2 & 65535;
+    word3 = product3 & 65535;
+  }
+  return word3.toString(16).padStart(4, "0") + word2.toString(16).padStart(4, "0") + word1.toString(16).padStart(4, "0") + word0.toString(16).padStart(4, "0");
+}
+function operationMethod(path) {
+  return path.slice(path.indexOf(".") + 1);
+}
+function operationNamespace(path) {
+  return path.slice(0, path.indexOf("."));
+}
+
 // ../../packages/forage/dist/schemas.js
 var pathPattern = /^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)+$/;
 var maximumCatalogOperations = 1e3;
@@ -20676,13 +20764,10 @@ function jsonDepth(value, depth) {
     }
     return maximum2;
   }
-  if (value === null)
-    return depth;
-  const record3 = external_exports.record(external_exports.string(), external_exports.json()).safeParse(value);
-  if (!record3.success)
+  if (!isJsonObject(value))
     return depth;
   let maximum = depth;
-  for (const item of Object.values(record3.data)) {
+  for (const item of Object.values(value)) {
     maximum = Math.max(maximum, jsonDepth(item, depth + 1));
   }
   return maximum;
@@ -20801,150 +20886,66 @@ var ForageError = class extends Error {
   }
 };
 
-// ../../packages/forage/dist/normalization.js
-var jsonValueSchema = external_exports.json();
-var jsonPrimitiveSchema = external_exports.lazy(() => external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()]));
-function isJsonObject(value) {
-  return value !== null && !Array.isArray(value) && !jsonPrimitiveSchema.safeParse(value).success;
-}
-function compareCodeUnits(left, right) {
-  if (left === right)
-    return 0;
-  const length = Math.min(left.length, right.length);
-  for (let index = 0; index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
-  }
-  return left.length - right.length;
-}
-function normalizeQuery(query) {
-  return query.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_./:-]/g, " ").toLowerCase().trim();
-}
-function tokenize(text) {
-  return text.split(/[^a-zA-Z0-9]+/).filter((token) => token.length > 0);
-}
-var stopwords = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "for",
-  "to",
-  "of",
-  "that",
-  "this",
-  "with",
-  "in",
-  "on"
-]);
-function isStopword(token) {
-  return stopwords.has(token);
-}
-function stemVariants(token) {
-  const variants = [];
-  const add2 = (variant) => {
-    if (variant !== token && variant.length >= 3 && !variants.includes(variant)) {
-      variants.push(variant);
-    }
-  };
-  if (token.endsWith("ing") && token.length > 4)
-    add2(token.slice(0, -3));
-  if (token.endsWith("ed") && token.length > 3)
-    add2(token.slice(0, -2));
-  if (token.endsWith("ies") && token.length > 4) {
-    add2(token.slice(0, -3));
-    add2(`${token.slice(0, -3)}y`);
-  }
-  if (token.endsWith("es") && token.length > 3)
-    add2(token.slice(0, -2));
-  if (token.endsWith("s") && !token.endsWith("ss") && token.length > 3) {
-    add2(token.slice(0, -1));
-  }
-  return variants;
-}
-function canonicalStringify(value) {
-  if (value === null)
-    return "null";
-  const primitive = jsonPrimitiveSchema.safeParse(value);
-  if (primitive.success) {
-    return JSON.stringify(primitive.data);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => canonicalStringify(item)).join(",")}]`;
-  }
-  if (!isJsonObject(value))
-    return "null";
-  const entries = Object.entries(value).sort(([left], [right]) => compareCodeUnits(left, right));
-  return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalStringify(entry)}`).join(",")}}`;
-}
-function hashString64(value) {
-  let hash3 = 0xcbf29ce484222325n;
-  const prime = 0x100000001b3n;
-  const mask = (1n << 64n) - 1n;
-  for (let index = 0; index < value.length; index += 1) {
-    hash3 ^= BigInt(value.charCodeAt(index));
-    hash3 = hash3 * prime & mask;
-  }
-  return hash3.toString(16).padStart(16, "0");
-}
-function operationMethod(path) {
-  return path.slice(path.indexOf(".") + 1);
-}
-function operationNamespace(path) {
-  return path.slice(0, path.indexOf("."));
-}
-
 // ../../packages/forage/dist/rendering.js
-var schemaNode = external_exports.lazy(() => external_exports.union([
-  external_exports.boolean(),
+var schemaNode = external_exports.union([
   external_exports.looseObject({
     $ref: external_exports.string().optional(),
-    $defs: external_exports.record(external_exports.string(), schemaNode).optional(),
-    definitions: external_exports.record(external_exports.string(), schemaNode).optional(),
+    $defs: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+    definitions: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
     const: external_exports.unknown().optional(),
     enum: external_exports.array(external_exports.unknown()).optional(),
-    oneOf: external_exports.array(schemaNode).optional(),
-    anyOf: external_exports.array(schemaNode).optional(),
-    allOf: external_exports.array(schemaNode).optional(),
+    oneOf: external_exports.array(external_exports.unknown()).optional(),
+    anyOf: external_exports.array(external_exports.unknown()).optional(),
+    allOf: external_exports.array(external_exports.unknown()).optional(),
     type: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
-    properties: external_exports.record(external_exports.string(), schemaNode).optional(),
-    additionalProperties: schemaNode.optional(),
+    properties: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+    additionalProperties: external_exports.unknown().optional(),
     required: external_exports.array(external_exports.string()).optional(),
-    prefixItems: external_exports.array(schemaNode).optional(),
-    items: external_exports.union([schemaNode, external_exports.array(schemaNode)]).optional(),
+    prefixItems: external_exports.array(external_exports.unknown()).optional(),
+    items: external_exports.unknown().optional(),
     examples: external_exports.array(external_exports.unknown()).optional(),
     default: external_exports.unknown().optional()
-  })
-]));
-var schemaFacts = /* @__PURE__ */ new WeakMap();
-function factsFor(schema, io) {
-  let entry = schemaFacts.get(schema);
+  }),
+  external_exports.boolean()
+]);
+var projections = /* @__PURE__ */ new WeakMap();
+function projectionFor(schema, io) {
+  let entry = projections.get(schema);
   const cached3 = entry?.[io];
   if (cached3 !== void 0)
     return cached3;
-  let node;
+  let raw;
   try {
-    node = schemaNode.parse(schema["~standard"].jsonSchema[io]({ target: "draft-2020-12" }));
+    raw = schema["~standard"].jsonSchema[io]({ target: "draft-2020-12" });
   } catch {
     throw new ForageError("invalid_input", "Schema cannot be projected to JSON Schema");
   }
-  const json2 = jsonValueSchema.safeParse(node);
-  const facts = {
-    node,
-    json: json2.success ? json2.data : void 0
-  };
+  decodeNode(raw);
+  const projection = { raw };
   if (entry === void 0) {
     entry = {};
-    schemaFacts.set(schema, entry);
+    projections.set(schema, entry);
   }
-  entry[io] = facts;
-  return facts;
+  entry[io] = projection;
+  return projection;
 }
-function schemaFor(schema, io) {
-  return factsFor(schema, io).node;
+function rawSchema(schema, io) {
+  return projectionFor(schema, io).raw;
 }
-function isNodeList(value) {
-  return Array.isArray(value);
+function schemaText(schema, io) {
+  const projection = projectionFor(schema, io);
+  try {
+    projection.text ??= JSON.stringify(projection.raw);
+    return projection.text;
+  } catch {
+    throw new ForageError("invalid_input", "Schema cannot be projected to JSON Schema");
+  }
+}
+function decodeNode(value) {
+  const parsed = schemaNode.safeParse(value);
+  if (!parsed.success)
+    throw new ForageError("invalid_input", "Schema cannot be projected to JSON Schema");
+  return parsed.data;
 }
 var maximumReferenceExpansions = 256;
 var localReference = /^#\/(?:\$defs|definitions)\/([^/]+)$/u;
@@ -20958,7 +20959,7 @@ function renderReference(reference, depth, refs) {
   refs.budget.expansions += 1;
   if (refs.budget.expansions > maximumReferenceExpansions)
     throw new ForageError("invalid_input", `Schema references expand more than ${String(maximumReferenceExpansions)} times; flatten its shared definitions`);
-  return renderNode(target, depth, {
+  return renderNode(decodeNode(target), depth, {
     definitions: refs.definitions,
     expanding: /* @__PURE__ */ new Set([...refs.expanding, name]),
     budget: refs.budget
@@ -20970,7 +20971,7 @@ function rendersUnion(node, refs) {
   if (node.$ref !== void 0) {
     const name = localReference.exec(node.$ref)?.[1];
     const target = name === void 0 || refs.expanding.has(name) ? void 0 : refs.definitions[name];
-    return name !== void 0 && target !== void 0 && rendersUnion(target, {
+    return name !== void 0 && target !== void 0 && rendersUnion(decodeNode(target), {
       definitions: refs.definitions,
       expanding: /* @__PURE__ */ new Set([...refs.expanding, name]),
       budget: refs.budget
@@ -20980,10 +20981,17 @@ function rendersUnion(node, refs) {
     return false;
   return node.enum !== void 0 && node.enum.length > 1 || node.oneOf !== void 0 && node.oneOf.length > 1 || node.anyOf !== void 0 && node.anyOf.length > 1;
 }
-function renderNode(node, depth, refs) {
-  if (node === void 0 || node === true || node === false || depth > 12) {
+function renderNode(node, depth, scope2) {
+  if (depth > 12) {
     return "unknown";
   }
+  if (node === true || node === false)
+    return "unknown";
+  const refs = scope2 ?? {
+    definitions: { ...node.definitions, ...node.$defs },
+    expanding: /* @__PURE__ */ new Set(),
+    budget: { expansions: 0 }
+  };
   if (node.$ref)
     return renderReference(node.$ref, depth, refs);
   if (node.const !== void 0)
@@ -20991,15 +20999,16 @@ function renderNode(node, depth, refs) {
   if (node.enum)
     return node.enum.map((value) => JSON.stringify(value)).join(" | ");
   if (node.oneOf) {
-    return node.oneOf.map((value) => renderNode(value, depth + 1, refs)).join(" | ");
+    return node.oneOf.map((value) => renderNode(decodeNode(value), depth + 1, refs)).join(" | ");
   }
   if (node.anyOf) {
-    return node.anyOf.map((value) => renderNode(value, depth + 1, refs)).join(" | ");
+    return node.anyOf.map((value) => renderNode(decodeNode(value), depth + 1, refs)).join(" | ");
   }
   if (node.allOf) {
     return node.allOf.map((value) => {
-      const member = renderNode(value, depth + 1, refs);
-      return rendersUnion(value, refs) ? `(${member})` : member;
+      const child = decodeNode(value);
+      const member = renderNode(child, depth + 1, refs);
+      return rendersUnion(child, refs) ? `(${member})` : member;
     }).join(" & ");
   }
   if (node.type === "object" || node.properties) {
@@ -21009,13 +21018,13 @@ function renderNode(node, depth, refs) {
       if (additional === false)
         return "Record<string, never>";
       if (additional && additional !== true) {
-        return `Record<string, ${renderNode(additional, depth + 1, refs)}>`;
+        return `Record<string, ${renderNode(decodeNode(additional), depth + 1, refs)}>`;
       }
       return "Record<string, unknown>";
     }
     const required2 = new Set(node.required ?? []);
     const lines = properties.map(([key, value]) => {
-      const child = renderNode(value, depth + 1, refs);
+      const child = renderNode(decodeNode(value), depth + 1, refs);
       const optional3 = required2.has(key) ? "" : "?";
       const safeKey = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
       return `${"  ".repeat(depth + 1)}${safeKey}${optional3}: ${child};`;
@@ -21027,16 +21036,17 @@ ${"  ".repeat(depth)}}`;
   if (node.type === "array") {
     const items = node.items;
     if (node.prefixItems && node.prefixItems.length > 0) {
-      const tuple3 = node.prefixItems.map((value) => renderNode(value, depth + 1, refs));
-      if (items !== void 0 && items !== true && !isNodeList(items)) {
-        tuple3.push(`...${renderNode(items, depth + 1, refs)}[]`);
+      const tuple3 = node.prefixItems.map((value) => renderNode(decodeNode(value), depth + 1, refs));
+      if (items !== void 0 && items !== true && !Array.isArray(items)) {
+        tuple3.push(`...${renderNode(decodeNode(items), depth + 1, refs)}[]`);
       }
       return `[${tuple3.join(", ")}]`;
     }
-    if (items !== void 0 && isNodeList(items))
-      return `[${items.map((value) => renderNode(value, depth + 1, refs)).join(", ")}][]`;
-    const item = renderNode(items, depth + 1, refs);
-    const compoundItem = items !== void 0 && items !== true && items !== false && (items.oneOf !== void 0 || items.anyOf !== void 0 || items.allOf !== void 0);
+    if (items !== void 0 && Array.isArray(items))
+      return `[${items.map((value) => renderNode(decodeNode(value), depth + 1, refs)).join(", ")}][]`;
+    const itemNode = items === void 0 ? true : decodeNode(items);
+    const item = renderNode(itemNode, depth + 1, refs);
+    const compoundItem = itemNode !== true && itemNode !== false && (itemNode.oneOf !== void 0 || itemNode.anyOf !== void 0 || itemNode.allOf !== void 0);
     return `${compoundItem ? `(${item})` : item}[]`;
   }
   switch (node.type) {
@@ -21054,13 +21064,7 @@ ${"  ".repeat(depth)}}`;
   }
 }
 function renderSchemaType(schema, io = "input") {
-  const root = schemaFor(schema, io);
-  const definitions = root === true || root === false ? {} : { ...root.definitions, ...root.$defs };
-  return renderNode(root, 0, {
-    definitions,
-    expanding: /* @__PURE__ */ new Set(),
-    budget: { expansions: 0 }
-  });
+  return renderNode(decodeNode(rawSchema(schema, io)), 0);
 }
 function safeTypeName(name) {
   return name.replace(/[^A-Za-z0-9_$]/g, "_");
@@ -21079,30 +21083,35 @@ function renderOperationTypes(operations) {
   return operations.length === 0 ? types2 : `${types2}
 export declare const env: ${operations.map((operation) => operation.environment).join(" & ")};`;
 }
+var renderedOperations = /* @__PURE__ */ new WeakMap();
 function renderOperation(operation) {
+  const cached3 = renderedOperations.get(operation);
+  if (cached3 !== void 0)
+    return cached3;
   const name = safeTypeName(operation.path.replace(/\./g, "$"));
   const input = renderSchemaType(operation.input, "input");
   const output = operation.output ? renderSchemaType(operation.output, "output") : "unknown";
-  return Object.freeze({
+  const rendered = Object.freeze({
     indexEnvironment: renderEnvironment(operation.path, input, output),
     environment: renderEnvironment(operation.path, `${name}_Input`, `${name}_Output`),
     types: `export type ${name}_Input = ${input};
 export type ${name}_Output = ${output};`
   });
+  renderedOperations.set(operation, rendered);
+  return rendered;
 }
 function deriveSample(schema) {
-  const node = schemaFor(schema, "input");
+  const node = decodeNode(rawSchema(schema, "input"));
   if (node === true || node === false || !node.properties) {
     return void 0;
   }
-  const properties = node.properties;
   const sample = {};
   let found = false;
-  const entries = Object.entries(properties).sort(([left], [right]) => compareCodeUnits(left, right));
+  const entries = Object.entries(node.properties).sort(([left], [right]) => compareCodeUnits(left, right));
   for (const [key, value] of entries) {
-    if (value === true || value === false)
+    const property = decodeNode(value);
+    if (property === true || property === false)
       continue;
-    const property = value;
     const examples = property.examples;
     if (examples && examples.length > 0) {
       const example = jsonValueSchema.safeParse(examples[0]);
@@ -21120,66 +21129,6 @@ function deriveSample(schema) {
   }
   return found ? sample : void 0;
 }
-function inputSchemaProjection(schema) {
-  const projection = factsFor(schema, "input").json;
-  if (projection === void 0) {
-    throw new ForageError("invalid_input", "Schema cannot be projected to JSON Schema");
-  }
-  return projection;
-}
-function schemaFingerprint(schema, io = "input") {
-  const facts = factsFor(schema, io);
-  facts.fingerprint ??= canonicalStringify(facts.json ?? null);
-  return facts.fingerprint;
-}
-function schemaDepth(value, depth) {
-  if (depth > maximumSampleDepth)
-    return depth;
-  if (Array.isArray(value)) {
-    let maximum2 = depth;
-    for (const item of value) {
-      maximum2 = Math.max(maximum2, schemaDepth(item, depth + 1));
-    }
-    return maximum2;
-  }
-  if (!isJsonObject(value))
-    return depth;
-  let maximum = depth;
-  for (const entry of Object.values(value)) {
-    maximum = Math.max(maximum, schemaDepth(entry, depth + 1));
-  }
-  return maximum;
-}
-function schemaProjectionSize(schema, io) {
-  const facts = factsFor(schema, io);
-  facts.size ??= { bytes: measureProjection(schema, io, facts.json) };
-  return facts.size.bytes;
-}
-function measureProjection(schema, io, projection) {
-  if (!projection)
-    return void 0;
-  const encoded = JSON.stringify(projection);
-  if (encoded.length > 2e4 || schemaDepth(projection, 0) > maximumSampleDepth) {
-    return void 0;
-  }
-  if (io === "output")
-    return encoded.length;
-  const sample = deriveSample(schema);
-  if (!sample)
-    return encoded.length;
-  if (Object.keys(sample).length > maximumSampleEntries || schemaDepth(sample, 0) > maximumSampleDepth) {
-    return void 0;
-  }
-  let sampleText;
-  try {
-    sampleText = JSON.stringify(sample);
-  } catch {
-    throw new ForageError("invalid_input", "Derived schema sample cannot be serialized");
-  }
-  if (!sampleText || sampleText.length > maximumSampleBytes)
-    return void 0;
-  return encoded.length + sampleText.length;
-}
 
 // ../../packages/forage/dist/describe.js
 function boundedDescription(value) {
@@ -21196,16 +21145,19 @@ function describeCatalog(operations, rawInput) {
   const operation = operations.find((candidate) => candidate.path === rawInput.path);
   if (operation) {
     const callPath = `env.${operation.path}`;
+    const inputSchema = jsonValueSchema.safeParse(rawSchema(operation.input, "input"));
+    if (!inputSchema.success)
+      throw new ForageError("invalid_input", "Schema cannot be projected to JSON Schema");
     const output = {
       path: operation.path,
       description: boundedDescription(operation.description),
-      types: renderOperationTypes([operation.rendered]),
+      types: renderOperationTypes([renderOperation(operation)]),
       kind: "operation",
-      inputSchema: operation.inputSchema,
+      inputSchema: inputSchema.data,
       usage: `await ${callPath}({ ... })`
     };
     if (output.types.length > maximumDescriptionTypes) {
-      throw new ForageError("invalid_input", "Description types exceed the bounded output");
+      throw new ForageError("invalid_input", "Operation description exceeds the bounded output");
     }
     return checkedDescription(output);
   }
@@ -21221,11 +21173,11 @@ function describeCatalog(operations, rawInput) {
   const selected = rawInput.methods?.length ? namespaceOperations.filter((candidate) => rawInput.methods?.includes(candidate.path.slice(prefix.length))) : namespaceOperations;
   let types2;
   if (rawInput.detail === "index") {
-    types2 = renderNamespaceIndex(namespaceOperations.map((operation2) => operation2.rendered));
+    types2 = renderNamespaceIndex(namespaceOperations.map(renderOperation));
   } else if (rawInput.methods?.length && selected.length === 0) {
-    types2 = renderNamespaceIndex(namespaceOperations.map((operation2) => operation2.rendered));
+    types2 = renderNamespaceIndex(namespaceOperations.map(renderOperation));
   } else {
-    types2 = renderOperationTypes((selected.length > 0 ? selected : namespaceOperations).map((operation2) => operation2.rendered));
+    types2 = renderOperationTypes((selected.length > 0 ? selected : namespaceOperations).map(renderOperation));
   }
   if (types2.length > maximumDescriptionTypes) {
     throw new ForageError("invalid_input", "Description types exceed the bounded output");
@@ -21240,12 +21192,14 @@ function describeCatalog(operations, rawInput) {
 
 // ../../packages/forage/dist/search.js
 function prepareOperation(operation) {
+  const input = schemaText(operation.input, "input");
+  const output = operation.output ? schemaText(operation.output, "output") : "";
   return Object.freeze({
     ...operation,
-    fingerprint: schemaFingerprint(operation.input),
-    inputSchema: inputSchemaProjection(operation.input),
-    sample: deriveSample(operation.input),
-    rendered: renderOperation(operation)
+    fingerprint: hashString64(input + "\n" + output),
+    inputBytes: input.length,
+    outputBytes: output.length,
+    sample: deriveSample(operation.input)
   });
 }
 var matchWeight = {
@@ -21257,28 +21211,25 @@ var matchWeight = {
   substring: 2,
   includes: 1
 };
-function fieldWeight(field) {
-  switch (field) {
-    case "path":
-      return 12;
-    case "namespace":
-      return 8;
-    case "method":
-      return 10;
-    case "description":
-      return 5;
-    default:
-      return 5;
-  }
-}
+var fieldWeight = {
+  path: 12,
+  namespace: 8,
+  method: 10,
+  description: 5
+};
+var fullCoverageBonus = 25;
+var partialCoverageBonus = 10;
+var firstTokenBonus = 8;
+var exactMatchBonus = 20;
+var maxBonus = Math.max(fullCoverageBonus, partialCoverageBonus) + firstTokenBonus + exactMatchBonus;
+var dominanceDivisor = 1 + Math.max(...Object.values(matchWeight)) * Math.max(...Object.values(fieldWeight)) + maxBonus;
 function catalogStamp(operations) {
-  const lines = [...operations].sort((left, right) => compareCodeUnits(left.path, right.path)).map((operation) => canonicalStringify([
+  const lines = [...operations].sort((left, right) => compareCodeUnits(left.path, right.path)).map((operation) => JSON.stringify([
     operation.path,
     operation.description ?? null,
     operation.capabilityNotes ?? null,
     operation.instructions ?? null,
-    operation.fingerprint,
-    operation.output === void 0 ? null : schemaFingerprint(operation.output, "output")
+    operation.fingerprint
   ]));
   return hashString64(lines.join("\n"));
 }
@@ -21305,7 +21256,7 @@ function scoreField(rawValue, field, queryTokens) {
   const value = normalizeQuery(rawValue);
   let bestLevel = "none";
   let bestScore = 0;
-  let matchedTokens = [];
+  const matchedTokens = [];
   for (const token of queryTokens) {
     const terms = [token, ...stemVariants(token)];
     let selected = "none";
@@ -21318,13 +21269,12 @@ function scoreField(rawValue, field, queryTokens) {
     }
     if (selected === "none")
       continue;
-    const score = matchWeight[selected] * fieldWeight(field);
+    const score = matchWeight[selected] * fieldWeight[field];
+    if (!matchedTokens.includes(token))
+      matchedTokens.push(token);
     if (score > bestScore) {
       bestLevel = selected;
       bestScore = score;
-      matchedTokens = [token];
-    } else if (score === bestScore && !matchedTokens.includes(token)) {
-      matchedTokens.push(token);
     }
   }
   return { level: bestLevel, score: bestScore, matchedTokens };
@@ -21367,7 +21317,7 @@ function emptyResult(stamp) {
     catalogStamp: stamp
   });
 }
-function scoreCandidate(operation, normalizedQuery, queryTokens, coverageTokens, threshold) {
+function scoreCandidate(operation, queryTokens, coverageTokens) {
   const namespace = operationNamespace(operation.path);
   const method = operationMethod(operation.path);
   const description = operation.description ?? "";
@@ -21377,23 +21327,25 @@ function scoreCandidate(operation, normalizedQuery, queryTokens, coverageTokens,
   const methodScore = scoreField(method, "method", queryTokens);
   const descriptionScore = scoreField(description, "description", queryTokens);
   const matched = coverageTokens.filter((token) => fields.some((field) => tokenMatches(field, token))).length;
-  const coverage = matched / coverageTokens.length;
-  const phraseMatch = normalizeQuery(`${operation.path} ${description}`).includes(normalizedQuery);
-  if (coverage < threshold && !phraseMatch)
+  if (matched === 0)
     return void 0;
+  const coverage = matched / coverageTokens.length;
   const baseScore = Math.max(pathScore.score, namespaceScore.score, methodScore.score, descriptionScore.score);
   if (baseScore === 0)
     return void 0;
-  let bonus = matched === coverageTokens.length ? 25 : coverage * 10;
+  let bonus = matched === coverageTokens.length ? fullCoverageBonus : coverage * partialCoverageBonus;
   const firstToken = coverageTokens[0];
   if (firstToken && fields.some((field) => tokenMatches(field, firstToken))) {
-    bonus += 8;
+    bonus += firstTokenBonus;
+  }
+  if (pathScore.level === "exact" || methodScore.level === "exact") {
+    bonus += exactMatchBonus;
   }
-  if (pathScore.level === "exact" || methodScore.level === "exact")
-    bonus += 20;
   const result2 = {
     path: operation.path,
-    score: baseScore + bonus
+    // A whole matched word outranks any field-quality difference; the
+    // derived divisor keeps all field and bonus evidence below one word.
+    score: matched + (baseScore + bonus) / dominanceDivisor
   };
   if (description)
     result2.description = description;
@@ -21469,10 +21421,9 @@ function searchCatalog(operations, query, maxResults = 50, stamp) {
   const coverageTokens = queryTokens.filter((token) => !isStopword(token));
   if (coverageTokens.length === 0)
     return emptyResult(stamp);
-  const threshold = coverageTokens.length <= 2 ? 1 : 0.6;
   const candidates = [];
   for (const operation of operations) {
-    const candidate = scoreCandidate(operation, normalizedQuery, queryTokens, coverageTokens, threshold);
+    const candidate = scoreCandidate(operation, queryTokens, coverageTokens);
     if (candidate)
       candidates.push(candidate);
   }
@@ -21521,6 +21472,23 @@ function listOperations(operations, catalogStamp2, rawInput) {
 
 // ../../packages/forage/dist/catalog.js
 var maximumCatalogProjectionBytes = 1e6;
+function schemaDepth(children, depth = 0) {
+  if (depth >= maximumSampleDepth)
+    return children.length === 0 ? depth : depth + 1;
+  let maximum = depth;
+  for (let index = children.length - 1; index >= 0; index -= 1) {
+    const child = children[index];
+    let childDepth = depth + 1;
+    if (Array.isArray(child))
+      childDepth = schemaDepth(child, childDepth);
+    else if (external_exports.util.isObject(child))
+      childDepth = schemaDepth(Object.values(child), childDepth);
+    maximum = Math.max(maximum, childDepth);
+    if (maximum > maximumSampleDepth)
+      return maximum;
+  }
+  return maximum;
+}
 function parseCatalog(input) {
   const parsed = catalogInputSchema.safeParse(input);
   if (!parsed.success) {
@@ -21531,21 +21499,28 @@ function parseCatalog(input) {
   }
   const operations = [...parsed.data.operations].sort((left, right) => compareCodeUnits(left.path, right.path));
   const paths = /* @__PURE__ */ new Set();
+  const preparedOperations = [];
   let projectionBytes = 0;
   for (const operation of operations) {
     if (paths.has(operation.path)) {
       throw new ForageError("duplicate_operation", `Duplicate operation path: ${operation.path}`);
     }
     paths.add(operation.path);
-    const inputProjection = schemaProjectionSize(operation.input, "input");
-    if (inputProjection === void 0) {
+    const inputProjection = schemaText(operation.input, "input").length;
+    if (inputProjection > maximumDescriptionTypes || schemaDepth(Object.values(rawSchema(operation.input, "input"))) > maximumSampleDepth) {
       throw new ForageError("invalid_input", `Schema projection is too large: ${operation.path}`);
     }
-    const outputProjection = operation.output ? schemaProjectionSize(operation.output, "output") : 0;
-    if (outputProjection === void 0) {
+    const outputProjection = operation.output ? schemaText(operation.output, "output").length : 0;
+    if (outputProjection > maximumDescriptionTypes || operation.output !== void 0 && schemaDepth(Object.values(rawSchema(operation.output, "output"))) > maximumSampleDepth) {
       throw new ForageError("invalid_input", `Schema output projection is too large: ${operation.path}`);
     }
-    projectionBytes += inputProjection + outputProjection + operation.path.length;
+    const prepared = prepareOperation(operation);
+    const sample = prepared.sample;
+    const sampleBytes = sample === void 0 ? 0 : JSON.stringify(sample).length;
+    if (sample !== void 0 && (Object.keys(sample).length > maximumSampleEntries || sampleBytes > maximumSampleBytes || jsonDepth(sample, 0) > maximumSampleDepth))
+      throw new ForageError("invalid_input", `Schema projection is too large: ${operation.path}`);
+    preparedOperations.push(prepared);
+    projectionBytes += prepared.inputBytes + prepared.outputBytes + sampleBytes + operation.path.length;
     projectionBytes += operation.description?.length ?? 0;
     projectionBytes += operation.capabilityNotes?.length ?? 0;
     projectionBytes += operation.instructions?.length ?? 0;
@@ -21553,12 +21528,6 @@ function parseCatalog(input) {
       throw new ForageError("invalid_input", "Catalog metadata exceeds the bounded projection");
     }
   }
-  const preparedOperations = operations.map((operation) => prepareOperation(operation));
-  for (const operation of preparedOperations) {
-    if (renderOperationTypes([operation.rendered]).length > maximumDescriptionTypes) {
-      throw new ForageError("invalid_input", `Operation description exceeds the bounded output: ${operation.path}`);
-    }
-  }
   return {
     revision: parsed.data.revision,
     operations: preparedOperations
@@ -21609,7 +21578,8 @@ function createCatalog(input) {
 
 // ../../packages/forage/dist/app-api.js
 var bindingName = external_exports.lazy(() => external_exports.string().min(1).max(75).regex(/^[A-Za-z][A-Za-z0-9_]*$/));
-var jsonSchema = external_exports.lazy(() => external_exports.union([external_exports.record(external_exports.string(), external_exports.json()), external_exports.boolean()]));
+var jsonSchemaDocument = external_exports.lazy(() => external_exports.record(external_exports.string(), external_exports.json()));
+var jsonSchema = external_exports.lazy(() => external_exports.union([jsonSchemaDocument, external_exports.boolean()]));
 var familyRow = external_exports.lazy(() => external_exports.object({
   tool: bindingName,
   title: external_exports.string().max(120),