@fungi.computer/forage 0.1.0 → 0.2.1

package/README.md

@@ -59,7 +59,13 @@ has a unique dotted path, an input schema, and optional description, capability
 notes, instructions, and output schema. Forage validates the catalog, orders its
 operations deterministically, and prepares descriptions once when the catalog is
 created. To change the catalog, create a new revision instead of mutating the
-existing one.
+existing one. Every operation must fit one complete description, and the
+catalog's aggregate metadata remains bounded. A whole namespace can exceed a
+description response without making its individually describable operations
+unavailable. Use paged `list({ namespace })` and describe one operation or
+select `methods` when a broad namespace description exceeds the response bound.
+This applies equally to flat namespaces and broad parents of nested namespaces;
+responses are never truncated and the response bound is unchanged.
 
 `search` ranks matching operations. `describe` returns a bounded TypeScript
 description for one operation or a namespace. Operation descriptions also

package/dist/app-api.d.ts

@@ -3,7 +3,16 @@ import type { AppApi } from "@fungi.computer/puffball";
 import type { Operation } from "./schemas.js";
 /** The shared JSON-Schema compiler for App methods and OpenAPI operations. */
 export declare function jsonSchemaToZod(source: unknown, defaultTarget?: "draft-2020-12" | "openapi-3.0"): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-/** Compile App validators and their Standard JSON Schema descriptions.
+/**
+ * One decoded, immutable App declaration as a JSON-only Standard Schema.
+ * Release and family-listing decoders own its JSON boundary. A catalog
+ * describes every installed method on each capture but a turn validates only
+ * the few it calls. Compiling every method eagerly exhausted an Agent Durable
+ * Object's isolate. A draft 2020-12 description is the declaration itself;
+ * validators compile for the call in hand and are never kept on the surface.
+ */
+export declare function appJsonSchema(declaration: AppApi["methods"][string]["input"] | boolean): Pick<z.ZodType<z.output<z.ZodJSONSchema>>, "parse" | "safeParse" | "~standard">;
+/** Describe App methods with call-scoped JSON validators.
  * Validation enforces both the declaration and JSON-only values; discovery
  * describes the declaration without adding JSON guard nesting.
  * Agar's emitted output already includes Pending for opted-in methods. */
@@ -11,18 +20,18 @@ export declare function appMethodSchemas(api: AppApi): {
     [k: string]: {
         readonly description: string;
         readonly effect: "write" | "external" | "read";
-        readonly requires: readonly ("agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
+        readonly requires: readonly ("approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
         readonly pending: true | undefined;
         readonly input: Pick<z.ZodType<z.core.util.JSONType, unknown, z.core.$ZodTypeInternals<z.core.util.JSONType, unknown>>, "~standard" | "parse" | "safeParse">;
         readonly output: Pick<z.ZodType<z.core.util.JSONType, unknown, z.core.$ZodTypeInternals<z.core.util.JSONType, unknown>>, "~standard" | "parse" | "safeParse">;
     };
 };
-/** Compile discoverable App methods only; direct RPC validation uses appMethodSchemas. */
+/** Describe discoverable App methods only; direct RPC validation uses appMethodSchemas. */
 export declare function appToolSchemas(api: AppApi): {
     [k: string]: {
         readonly description: string;
         readonly effect: "write" | "external" | "read";
-        readonly requires: readonly ("agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
+        readonly requires: readonly ("approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
         readonly pending: true | undefined;
         readonly input: Pick<z.ZodType<z.core.util.JSONType, unknown, z.core.$ZodTypeInternals<z.core.util.JSONType, unknown>>, "~standard" | "parse" | "safeParse">;
         readonly output: Pick<z.ZodType<z.core.util.JSONType, unknown, z.core.$ZodTypeInternals<z.core.util.JSONType, unknown>>, "~standard" | "parse" | "safeParse">;
@@ -35,7 +44,7 @@ export declare function appToolFamilySchemas(api: AppApi, reply: unknown): {
     name: string;
     call: string;
     effect: "write" | "external" | "read";
-    requires: readonly ("agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
+    requires: readonly ("approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage")[];
     kind: "ready" | "unindexed";
     tools: {
         row: {

package/dist/app-api.js

@@ -4,25 +4,45 @@ const bindingName = z.lazy(() => z
     .min(1)
     .max(75)
     .regex(/^[A-Za-z][A-Za-z0-9_]*$/));
-const jsonSchema = z.lazy(() => z.union([z.record(z.string(), z.json()), z.boolean()]));
+const jsonSchemaDocument = z.lazy(() => z.record(z.string(), z.json()));
+const jsonSchema = z.lazy(() => z.union([jsonSchemaDocument, z.boolean()]));
 /** The shared JSON-Schema compiler for App methods and OpenAPI operations. */
 export function jsonSchemaToZod(source, defaultTarget = "draft-2020-12") {
     return z.fromJSONSchema(jsonSchema.parse(source), { defaultTarget });
 }
-/** Validate JSON with Zod; describe the declaration without the redundant JSON guard. */
-function appMethodSchema(source) {
-    const declared = jsonSchemaToZod(source);
-    const validator = z.intersection(declared, z.json());
+/**
+ * One decoded, immutable App declaration as a JSON-only Standard Schema.
+ * Release and family-listing decoders own its JSON boundary. A catalog
+ * describes every installed method on each capture but a turn validates only
+ * the few it calls. Compiling every method eagerly exhausted an Agent Durable
+ * Object's isolate. A draft 2020-12 description is the declaration itself;
+ * validators compile for the call in hand and are never kept on the surface.
+ */
+export function appJsonSchema(declaration) {
+    const build = () => jsonSchemaToZod(declaration);
+    const validate = () => z.intersection(build(), z.json());
+    const describe = (io, options) => {
+        if (options.target === "draft-2020-12" &&
+            declaration !== true &&
+            declaration !== false)
+            return declaration;
+        return build()["~standard"].jsonSchema[io](options);
+    };
     return {
-        parse: (value, options) => validator.parse(value, options),
-        safeParse: (value, options) => validator.safeParse(value, options),
+        parse: (value, options) => validate().parse(value, options),
+        safeParse: (value, options) => validate().safeParse(value, options),
         "~standard": {
-            ...validator["~standard"],
-            jsonSchema: declared["~standard"].jsonSchema,
+            version: 1,
+            vendor: "zod",
+            validate: (value, options) => validate()["~standard"].validate(value, options),
+            jsonSchema: {
+                input: (options) => describe("input", options),
+                output: (options) => describe("output", options),
+            },
         },
     };
 }
-/** Compile App validators and their Standard JSON Schema descriptions.
+/** Describe App methods with call-scoped JSON validators.
  * Validation enforces both the declaration and JSON-only values; discovery
  * describes the declaration without adding JSON guard nesting.
  * Agar's emitted output already includes Pending for opted-in methods. */
@@ -34,12 +54,12 @@ export function appMethodSchemas(api) {
             effect: declaration.effect,
             requires: declaration.requires,
             pending: declaration.pending,
-            input: appMethodSchema(declaration.input),
-            output: appMethodSchema(declaration.output),
+            input: appJsonSchema(declaration.input),
+            output: appJsonSchema(declaration.output),
         },
     ]));
 }
-/** Compile discoverable App methods only; direct RPC validation uses appMethodSchemas. */
+/** Describe discoverable App methods only; direct RPC validation uses appMethodSchemas. */
 export function appToolSchemas(api) {
     return appMethodSchemas({
         ...api,
@@ -83,7 +103,7 @@ export function appToolFamilySchemas(api, reply) {
     const call = api.methods[family.call];
     if (list === undefined || call === undefined)
         throw new Error("Tool family references undeclared methods");
-    const inventory = familyInventory.parse(appMethodSchema(list.output).parse(reply));
+    const inventory = familyInventory.parse(appJsonSchema(list.output).parse(reply));
     return {
         name: family.name,
         call: family.call,
@@ -97,8 +117,8 @@ export function appToolFamilySchemas(api, reply) {
                 description: [row.title, row.description]
                     .filter((text) => text.length > 0)
                     .join("\n"),
-                input: appMethodSchema(row.input),
-                output: appMethodSchema(row.output),
+                input: appJsonSchema(row.input),
+                output: appJsonSchema(row.output),
             })),
     };
 }

package/dist/catalog.js

@@ -1,11 +1,34 @@
+import { z } from "zod";
 import { ForageError } from "./errors.js";
-import { catalogInputSchema, forageDescribeInput, forageSearchInput, maximumDescriptionTypes, } from "./schemas.js";
+import { catalogInputSchema, forageDescribeInput, forageSearchInput, maximumDescriptionTypes, maximumSampleBytes, maximumSampleDepth, maximumSampleEntries, jsonDepth, } from "./schemas.js";
 import { describeCatalog } from "./describe.js";
 import { catalogStamp, prepareOperation, searchCatalog, } from "./search.js";
 import { compareCodeUnits } from "./normalization.js";
 import { listOperations } from "./list.js";
-import { renderNamespaceIndex, renderOperationTypes, schemaProjectionSize, } from "./rendering.js";
+import { rawSchema, schemaText } from "./rendering.js";
 const maximumCatalogProjectionBytes = 1_000_000;
+/**
+ * A nesting bound on the raw producer document, not a second JSON decoder.
+ * The ceiling bounds recursion; sibling order cannot change the maximum.
+ * Indexed traversal avoids cold iterator results and heap stack entries.
+ */
+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 (z.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) {
@@ -16,24 +39,42 @@ function parseCatalog(input) {
     }
     const operations = [...parsed.data.operations].sort((left, right) => compareCodeUnits(left.path, right.path));
     const paths = 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 === undefined) {
+        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")
+            ? schemaText(operation.output, "output").length
             : 0;
-        if (outputProjection === undefined) {
+        if (outputProjection > maximumDescriptionTypes ||
+            (operation.output !== undefined &&
+                schemaDepth(Object.values(rawSchema(operation.output, "output"))) >
+                    maximumSampleDepth)) {
             throw new ForageError("invalid_input", `Schema output projection is too large: ${operation.path}`);
         }
+        const prepared = prepareOperation(operation);
+        const sample = prepared.sample;
+        const sampleBytes = sample === undefined ? 0 : JSON.stringify(sample).length;
+        if (sample !== undefined &&
+            (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 +=
-            inputProjection + outputProjection + operation.path.length;
+            prepared.inputBytes +
+                prepared.outputBytes +
+                sampleBytes +
+                operation.path.length;
         projectionBytes += operation.description?.length ?? 0;
         projectionBytes += operation.capabilityNotes?.length ?? 0;
         projectionBytes += operation.instructions?.length ?? 0;
@@ -41,23 +82,6 @@ function parseCatalog(input) {
             throw new ForageError("invalid_input", "Catalog metadata exceeds the bounded projection");
         }
     }
-    const preparedOperations = operations.map((operation) => prepareOperation(operation));
-    const namespaces = new Map();
-    for (const operation of preparedOperations) {
-        const namespace = operation.path.slice(0, operation.path.lastIndexOf("."));
-        const group = namespaces.get(namespace) ?? [];
-        group.push(operation);
-        namespaces.set(namespace, group);
-    }
-    for (const [namespace, group] of namespaces) {
-        const rendered = group.map((operation) => operation.rendered);
-        const index = renderNamespaceIndex(rendered);
-        const full = renderOperationTypes(rendered);
-        if (index.length > maximumDescriptionTypes ||
-            full.length > maximumDescriptionTypes) {
-            throw new ForageError("invalid_input", `Namespace description exceeds the bounded output: ${namespace}`);
-        }
-    }
     return {
         revision: parsed.data.revision,
         operations: preparedOperations,

package/dist/describe.js

@@ -1,6 +1,6 @@
 import { describeOutputSchema, maximumDescriptionTypes, } from "./schemas.js";
-import { compareCodeUnits } from "./normalization.js";
-import { renderNamespaceIndex, renderOperationTypes } from "./rendering.js";
+import { compareCodeUnits, jsonValueSchema } from "./normalization.js";
+import { rawSchema, renderOperation, renderNamespaceIndex, renderOperationTypes, } from "./rendering.js";
 import { ForageError } from "./errors.js";
 function boundedDescription(value) {
     return value && value.length > 0 ? value : undefined;
@@ -17,16 +17,19 @@ export 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);
     }
@@ -46,13 +49,13 @@ export function describeCatalog(operations, rawInput) {
         : namespaceOperations;
     let types;
     if (rawInput.detail === "index") {
-        types = renderNamespaceIndex(namespaceOperations.map((operation) => operation.rendered));
+        types = renderNamespaceIndex(namespaceOperations.map(renderOperation));
     }
     else if (rawInput.methods?.length && selected.length === 0) {
-        types = renderNamespaceIndex(namespaceOperations.map((operation) => operation.rendered));
+        types = renderNamespaceIndex(namespaceOperations.map(renderOperation));
     }
     else {
-        types = renderOperationTypes((selected.length > 0 ? selected : namespaceOperations).map((operation) => operation.rendered));
+        types = renderOperationTypes((selected.length > 0 ? selected : namespaceOperations).map(renderOperation));
     }
     if (types.length > maximumDescriptionTypes) {
         throw new ForageError("invalid_input", "Description types exceed the bounded output");

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { CatalogInput, DescribeOutput, ForageDescribeInput, ForageFailure,
 export type { ForageDefinition } from "./definitions.js";
 export { ForageError } from "./errors.js";
 export { createCatalog } from "./catalog.js";
-export { appApiOperations, appMethodSchemas, appToolSchemas, appToolFamilySchemas, jsonSchemaToZod, } from "./app-api.js";
+export { appApiOperations, appJsonSchema, appMethodSchemas, appToolSchemas, appToolFamilySchemas, jsonSchemaToZod, } from "./app-api.js";
 export { listOperations } from "./list.js";
 export type { ForageCatalog } from "./catalog.js";
 export { forageDescribeDefinition, forageSearchDefinition, forageListDefinition, } from "./definitions.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { catalogInputSchema, describeOutputSchema, forageDescribeInput, forageFailureSchema, forageSearchInput, operationSchema, searchOutputSchema, searchResultSchema, forageListInput, listOutputSchema, } from "./schemas.js";
 export { ForageError } from "./errors.js";
 export { createCatalog } from "./catalog.js";
-export { appApiOperations, appMethodSchemas, appToolSchemas, appToolFamilySchemas, jsonSchemaToZod, } from "./app-api.js";
+export { appApiOperations, appJsonSchema, appMethodSchemas, appToolSchemas, appToolFamilySchemas, jsonSchemaToZod, } from "./app-api.js";
 export { listOperations } from "./list.js";
 export { forageDescribeDefinition, forageSearchDefinition, forageListDefinition, } from "./definitions.js";
 import { createCatalog } from "./catalog.js";

package/dist/normalization.d.ts

@@ -16,7 +16,6 @@ export declare function normalizeQuery(query: string): string;
 export declare function tokenize(text: string): string[];
 export declare function isStopword(token: string): boolean;
 export declare function stemVariants(token: string): string[];
-export declare function canonicalStringify(value: JsonValue): string;
 export declare function hashString64(value: string): string;
 export declare function operationMethod(path: Operation["path"]): string;
 export declare function operationNamespace(path: Operation["path"]): string;

package/dist/normalization.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 export const jsonValueSchema = z.json();
-const jsonPrimitiveSchema = z.lazy(() => z.union([z.string(), z.number(), z.boolean()]));
 /**
  * Narrow an already-parsed JSON value to its object case. The value was
  * validated once at its boundary, so each nested level is told apart by its
@@ -8,9 +7,7 @@ const jsonPrimitiveSchema = z.lazy(() => z.union([z.string(), z.number(), z.bool
  * made walking a large schema quadratic.
  */
 export function isJsonObject(value) {
-    return (value !== null &&
-        !Array.isArray(value) &&
-        !jsonPrimitiveSchema.safeParse(value).success);
+    return value !== null && !Array.isArray(value) && typeof value === "object";
 }
 export function compareCodeUnits(left, right) {
     if (left === right)
@@ -63,6 +60,9 @@ export function stemVariants(token) {
         add(token.slice(0, -3));
     if (token.endsWith("ed") && token.length > 3)
         add(token.slice(0, -2));
+    if (token.endsWith("ation") && token.length > 6) {
+        add(`${token.slice(0, -3)}e`);
+    }
     if (token.endsWith("ies") && token.length > 4) {
         add(token.slice(0, -3));
         add(`${token.slice(0, -3)}y`);
@@ -74,32 +74,29 @@ export function stemVariants(token) {
     }
     return variants;
 }
-export 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(",")}}`;
-}
 export function hashString64(value) {
-    let hash = 0xcbf29ce484222325n;
-    const prime = 0x100000001b3n;
-    const mask = (1n << 64n) - 1n;
+    let word0 = 0x2325;
+    let word1 = 0x8422;
+    let word2 = 0x9ce4;
+    let word3 = 0xcbf2;
     for (let index = 0; index < value.length; index += 1) {
-        hash ^= BigInt(value.charCodeAt(index));
-        hash = (hash * prime) & mask;
+        const low = word0 ^ value.charCodeAt(index);
+        // The prime is 2^40 + 435. Four 16-bit limbs preserve modulo 2^64;
+        // every intermediate stays below 2^26, including before V8 optimizes
+        // this loop. Unsigned 32-bit limbs allocated boxed numbers when cold.
+        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 & 0xffff;
+        word1 = product1 & 0xffff;
+        word2 = product2 & 0xffff;
+        word3 = product3 & 0xffff;
     }
-    return hash.toString(16).padStart(16, "0");
+    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"));
 }
 export function operationMethod(path) {
     return path.slice(path.indexOf(".") + 1);

package/dist/openapi.js

@@ -11,6 +11,16 @@ const reservedNames = new Set([
     "prototype",
     ...Object.getOwnPropertyNames(Object.prototype),
 ]);
+const operationMethods = [
+    "get",
+    "head",
+    "options",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "trace",
+];
 const pathTemplate = z
     .string()
     .max(2048)
@@ -304,6 +314,18 @@ function inspectExpansion(source, budget) {
         throw new OpenApiError(refusal, messages[refusal]);
     }
 }
+function inspectOperationCount(paths) {
+    let count = 0;
+    for (const item of Object.values(paths)) {
+        count +=
+            item.$ref !== undefined
+                ? 1
+                : operationMethods.filter((method) => item[method] !== undefined)
+                    .length;
+        if (count > 500)
+            throw new OpenApiError("operations_limit", "The spec exceeds 500 operations");
+    }
+}
 /** Pure intake: the host supplies bounded spec text, never a fetch locator. */
 export async function normalizeOpenApi(source, options = {}) {
     const authParameter = intakeOptions.parse(options).authParameter;
@@ -349,9 +371,9 @@ export async function normalizeOpenApi(source, options = {}) {
     const budget = { nodes: 0 };
     const names = new Set(reservedNames);
     const operations = [];
+    // Refuse oversized catalogs before cloning or compiling individual operations.
+    inspectOperationCount(parsed.paths);
     for (const [path, item] of Object.entries(parsed.paths).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
-        if (operations.length >= 500)
-            throw new OpenApiError("operations_limit", "The spec exceeds 500 operations");
         if (item.$ref !== undefined) {
             operations.push({
                 status: "unsupported",
@@ -362,21 +384,10 @@ export async function normalizeOpenApi(source, options = {}) {
             });
             continue;
         }
-        for (const method of [
-            "get",
-            "head",
-            "options",
-            "post",
-            "put",
-            "patch",
-            "delete",
-            "trace",
-        ]) {
+        for (const method of operationMethods) {
             const raw = item[method];
             if (raw === undefined)
                 continue;
-            if (operations.length >= 500)
-                throw new OpenApiError("operations_limit", "The spec exceeds 500 operations");
             const label = z
                 .object({ operationId: z.string().max(128).optional() })
                 .safeParse(raw);

package/dist/rendering.d.ts

@@ -1,26 +1,20 @@
 import type { JsonValue } from "./normalization.js";
-import { type JsonSchemaSource } from "./schemas.js";
-/** Installation-time TypeScript projections for one catalog operation. */
+import type { JsonSchemaSource, Operation } from "./schemas.js";
+/** Requested TypeScript projections for one catalog operation. */
 export type RenderedOperation = Readonly<{
     types: string;
     environment: string;
     indexEnvironment: string;
 }>;
+/** The producer's document, without a recursive projection decode or copy. */
+export declare function rawSchema(schema: JsonSchemaSource, io: "input" | "output"): object;
+/** Native serialization owns the document's text representation and failures. */
+export declare function schemaText(schema: JsonSchemaSource, io: "input" | "output"): string;
 /** Render a namespace index as a callable nested environment. */
 export declare function renderNamespaceIndex(operations: readonly RenderedOperation[]): string;
 /** Render whole-operation schemas and their callable nested environment. */
 export declare function renderOperationTypes(operations: readonly RenderedOperation[]): string;
-/** Prepare all TypeScript descriptions for one operation at installation. */
-export declare function renderOperation(operation: {
-    path: string;
-    input: JsonSchemaSource;
-    output?: JsonSchemaSource | undefined;
-}): RenderedOperation;
+/** Render only requested operations, once per immutable prepared operation. */
+export declare function renderOperation(operation: Operation): RenderedOperation;
 /** Derive sample arguments solely from input-schema examples and defaults. */
 export declare function deriveSample(schema: JsonSchemaSource): Record<string, JsonValue> | undefined;
-/** Preserve validator constraints in the operation's Standard JSON Schema. */
-export declare function inputSchemaProjection(schema: JsonSchemaSource): JsonValue;
-/** Produce a canonical schema representation used in peer identity and stamps. */
-export declare function schemaFingerprint(schema: JsonSchemaSource, io?: "input" | "output"): string;
-/** Validate the bounded JSON projection before a catalog is installed. */
-export declare function schemaProjectionSize(schema: JsonSchemaSource, io: "input" | "output"): number | undefined;