@knitli/openapi-mcp 0.0.0

package/dist/runtime/runtime.js

@@ -0,0 +1,1272 @@
+import { classifyOperation } from "./classify.js";
+import { sha256 } from "./digest.js";
+import { OpenApiMcpError } from "./errors.js";
+import { authenticateManifest, commitAuthenticatedManifestAtState, } from "./manifest.js";
+import { createPreparedCall, snapshotPaginationTokenState, verifyAndSnapshotPreparedCall, } from "./prepared-call.js";
+import { decodeOperationRef, encodeOperationRef, parseTypedRecordId, } from "./references.js";
+import { collectReferences, resolveSchemaClosure } from "./schema-resolver.js";
+import { serializeArguments } from "./serialize.js";
+import { canonicalJson } from "./strict-json.js";
+import { verifyStoredRecord } from "./verify-record.js";
+import { DEFAULT_RUNTIME_LIMITS, PREPARED_CALL_VERSION, resolveRuntimeLimits, } from "./versions.js";
+function inputInvalid(message) {
+    return new OpenApiMcpError("INPUT_INVALID", message);
+}
+function upstreamUnavailable(message) {
+    return new OpenApiMcpError("UPSTREAM_ERROR", message, { retryable: true });
+}
+class GenerationStoreUnavailable extends OpenApiMcpError {
+    constructor() {
+        super("UPSTREAM_ERROR", "Generation state is unavailable", {
+            retryable: true,
+        });
+    }
+}
+function manifestKey(catalogId, releaseId) {
+    return `${catalogId}\0${releaseId}`;
+}
+const maximumSearchReleases = 8;
+const maximumInventorySchemaBatch = 128;
+// State churn may require reproof, but one search may spend no more than the
+// same eight-release compatibility envelope used for manifest authentication.
+const maximumCompleteReleaseProofs = maximumSearchReleases;
+function cappedProduct(left, right) {
+    return Math.min(Number.MAX_SAFE_INTEGER, left * right);
+}
+function completeReleaseByteLimit(limits) {
+    return (limits.maxReleaseInventoryBytes ??
+        DEFAULT_RUNTIME_LIMITS.maxReleaseInventoryBytes);
+}
+function createCompleteVerificationBudget(limits) {
+    const perReleaseBytes = completeReleaseByteLimit(limits);
+    // Record verification, one schema-document traversal, references, and
+    // bounded closure visits are charged independently.
+    const perReleaseWork = limits.maxManifestRecords * (limits.maxSchemaRefHops + 3);
+    return {
+        proofsRemaining: maximumCompleteReleaseProofs,
+        // All releases share one inventory envelope. Authentication may consider
+        // eight releases, but search never receives eight independent 128 MiB
+        // proof allocations.
+        bytesRemaining: perReleaseBytes,
+        workRemaining: cappedProduct(perReleaseWork, maximumSearchReleases),
+        storeCallsRemaining: cappedProduct(limits.maxManifestRecords * 2, maximumSearchReleases),
+    };
+}
+function chargeCompleteVerification(budget, charge) {
+    const proofs = charge.proofs ?? 0;
+    const bytes = charge.bytes ?? 0;
+    const work = charge.work ?? 0;
+    const storeCalls = charge.storeCalls ?? 0;
+    if (proofs > budget.proofsRemaining ||
+        bytes > budget.bytesRemaining ||
+        work > budget.workRemaining ||
+        storeCalls > budget.storeCallsRemaining) {
+        throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Search admission verification budget exhausted");
+    }
+    budget.proofsRemaining -= proofs;
+    budget.bytesRemaining -= bytes;
+    budget.workRemaining -= work;
+    budget.storeCallsRemaining -= storeCalls;
+}
+function sameGenerationState(left, right) {
+    return (left === right ||
+        (left !== null &&
+            right !== null &&
+            left.revision === right.revision &&
+            left.highestGeneration === right.highestGeneration &&
+            left.highestManifestDigest === right.highestManifestDigest &&
+            left.activeGeneration === right.activeGeneration &&
+            left.activeManifestDigest === right.activeManifestDigest));
+}
+function snapshotRows(value, maximum) {
+    try {
+        if (!Array.isArray(value))
+            throw new Error();
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+        if (lengthDescriptor === undefined ||
+            !("value" in lengthDescriptor) ||
+            !Number.isSafeInteger(lengthDescriptor.value) ||
+            lengthDescriptor.value < 0 ||
+            lengthDescriptor.value > maximum)
+            throw new Error();
+        const length = lengthDescriptor.value;
+        const keys = Reflect.ownKeys(value);
+        if (keys.length !== length + 1 ||
+            keys.some((key) => typeof key !== "string" ||
+                (key !== "length" && !/^(0|[1-9][0-9]*)$/.test(key))))
+            throw new Error();
+        const snapshot = [];
+        for (let index = 0; index < length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !descriptor.enumerable)
+                throw new Error();
+            snapshot.push(descriptor.value);
+        }
+        return snapshot;
+    }
+    catch {
+        throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Release inventory lookup result is invalid");
+    }
+}
+async function verifyCompleteRelease(store, authenticated, limits, searchBudget) {
+    chargeCompleteVerification(searchBudget, { proofs: 1 });
+    // CatalogStore addresses immutable release identities but has no snapshot
+    // handle. Verify the complete observed release view before admission; later
+    // use-time reads remain independently verified because availability can
+    // still change after this pass.
+    const operationIds = [];
+    const schemaIds = [];
+    for (const id of Object.keys(authenticated.manifest.records).sort()) {
+        const parsed = parseTypedRecordId(id);
+        if (parsed.startsWith("operation:"))
+            operationIds.push(parsed);
+        else
+            schemaIds.push(parsed);
+    }
+    const encoder = new TextEncoder();
+    const maximumBytes = completeReleaseByteLimit(limits);
+    const maximumWork = limits.maxManifestRecords * (limits.maxSchemaRefHops + 2);
+    let aggregateBytes = 0;
+    let aggregateWork = 0;
+    const accountRecord = (record) => {
+        const bytes = encoder.encode(canonicalJson(record)).byteLength;
+        chargeCompleteVerification(searchBudget, { bytes });
+        aggregateBytes += bytes;
+        aggregateWork += 1;
+        if (aggregateBytes > maximumBytes || aggregateWork > maximumWork) {
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Release inventory verification exceeds its aggregate limit");
+        }
+        return bytes;
+    };
+    const operationRoots = [];
+    for (const id of operationIds) {
+        chargeCompleteVerification(searchBudget, { work: 1, storeCalls: 1 });
+        const row = await store.getOperation(authenticated.manifest.catalogId, authenticated.manifest.releaseId, id);
+        if (row === null) {
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Release inventory operation is missing");
+        }
+        const operation = await verifyStoredRecord(authenticated, row, limits);
+        if (!operation.id.startsWith("operation:") || operation.id !== id) {
+            throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Release inventory operation identity does not match");
+        }
+        accountRecord(operation);
+        operationRoots.push([...new Set(operation.schemaIds)].sort());
+    }
+    const schemaBatchSize = Math.max(1, Math.min(maximumInventorySchemaBatch, Math.floor(limits.maxSchemaClosureBytes / limits.maxRecordBytes)));
+    const schemas = new Map();
+    let offset = 0;
+    while (offset < schemaIds.length) {
+        const ids = [];
+        let requestBytes = 0;
+        while (offset < schemaIds.length && ids.length < schemaBatchSize) {
+            const id = schemaIds[offset];
+            const idBytes = encoder.encode(id).byteLength;
+            if (idBytes > limits.maxSchemaClosureBytes ||
+                (ids.length > 0 &&
+                    requestBytes + idBytes > limits.maxSchemaClosureBytes))
+                break;
+            ids.push(id);
+            requestBytes += idBytes;
+            offset += 1;
+        }
+        if (ids.length === 0) {
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Release inventory schema request exceeds its byte limit");
+        }
+        chargeCompleteVerification(searchBudget, {
+            work: ids.length,
+            storeCalls: 1,
+        });
+        const result = await store.getSchemas(authenticated.manifest.catalogId, authenticated.manifest.releaseId, ids);
+        const rows = snapshotRows(result, ids.length);
+        const verified = await Promise.all(rows.map((row) => verifyStoredRecord(authenticated, row, limits)));
+        const returned = new Set(verified.map((record) => record.id));
+        if (returned.size !== ids.length ||
+            verified.length !== ids.length ||
+            ids.some((id) => !returned.has(id)) ||
+            verified.some((record) => !record.id.startsWith("schema:"))) {
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Release inventory schema is missing or ambiguous");
+        }
+        for (const record of verified) {
+            const schema = record;
+            schemas.set(schema.id, {
+                record: schema,
+                bytes: accountRecord(schema),
+            });
+        }
+    }
+    const schemaReferences = new Map();
+    for (const [id, { record }] of schemas) {
+        const references = collectReferences(record.schema);
+        chargeCompleteVerification(searchBudget, {
+            work: references.length + 1,
+        });
+        schemaReferences.set(id, references);
+        aggregateWork += references.length;
+        if (aggregateWork > maximumWork ||
+            references.some((reference) => !schemas.has(reference))) {
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Release schema graph is incomplete or exceeds its work limit");
+        }
+    }
+    const verifiedClosures = new Set();
+    for (const roots of operationRoots) {
+        const cacheKey = roots.join("\0");
+        if (verifiedClosures.has(cacheKey))
+            continue;
+        let frontier = roots;
+        const visited = new Set();
+        let closureBytes = 0;
+        let hop = 0;
+        while (frontier.length > 0) {
+            if (hop > limits.maxSchemaRefHops) {
+                throw new OpenApiMcpError("SCHEMA_RESOLUTION_LIMIT", "Schema reference hop limit exceeded");
+            }
+            const next = new Set();
+            for (const id of frontier) {
+                if (visited.has(id))
+                    continue;
+                const schema = schemas.get(id);
+                if (schema === undefined) {
+                    throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Operation schema root is not in the verified inventory");
+                }
+                visited.add(id);
+                closureBytes += schema.bytes;
+                aggregateWork += 1;
+                chargeCompleteVerification(searchBudget, { work: 1 });
+                if (closureBytes > limits.maxSchemaClosureBytes ||
+                    aggregateWork > maximumWork) {
+                    throw new OpenApiMcpError("SCHEMA_RESOLUTION_LIMIT", "Schema closure exceeds its aggregate limit");
+                }
+                for (const reference of schemaReferences.get(id) ?? []) {
+                    if (!visited.has(reference))
+                        next.add(reference);
+                }
+            }
+            frontier = [...next].sort();
+            hop += 1;
+        }
+        verifiedClosures.add(cacheKey);
+    }
+}
+const markdownCharacters = new Map([
+    ["#", "＃"],
+    ["`", "ˋ"],
+    ["*", "＊"],
+    [">", "›"],
+    ["<", "‹"],
+    ["[", "【"],
+    ["]", "】"],
+]);
+const unsafeUnicodeCategory = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+function safeText(value, maximum) {
+    let safe = "";
+    // Strip control, format, and Unicode line/paragraph separator code points.
+    // Iteration is by code point so supplementary-plane format controls cannot
+    // hide behind a surrogate pair.
+    for (const character of value) {
+        const replacement = unsafeUnicodeCategory.test(character)
+            ? " "
+            : (markdownCharacters.get(character) ?? character);
+        if (safe.length + replacement.length > maximum)
+            break;
+        safe += replacement;
+    }
+    return safe;
+}
+function safeSummary(value) {
+    return value === null ? null : safeText(value, 600);
+}
+function inputOutline(operation) {
+    const outline = {
+        path: [],
+        query: [],
+        headers: [],
+        body: operation.requestBody?.content
+            .slice(0, 16)
+            .map((entry) => safeText(entry.mediaType, 128)) ?? [],
+    };
+    for (const parameter of operation.parameters) {
+        const item = {
+            name: safeText(parameter.name, 128),
+            required: parameter.required,
+        };
+        if (parameter.in === "path" && outline.path.length < 32)
+            outline.path.push(item);
+        if (parameter.in === "query" && outline.query.length < 32)
+            outline.query.push(item);
+        if (parameter.in === "header" && outline.headers.length < 32)
+            outline.headers.push(item);
+    }
+    return outline;
+}
+function safeJsonValue(value, state, depth = 0) {
+    if (state.nodes >= 64 || depth > 4)
+        return undefined;
+    state.nodes += 1;
+    if (typeof value === "string")
+        return safeText(value, 128);
+    if (value === null || typeof value === "boolean" || typeof value === "number")
+        return value;
+    if (Array.isArray(value)) {
+        const result = [];
+        for (const entry of value.slice(0, 32)) {
+            const safe = safeJsonValue(entry, state, depth + 1);
+            if (safe !== undefined)
+                result.push(safe);
+        }
+        return result;
+    }
+    const result = {};
+    for (const key of Object.keys(value).sort().slice(0, 32)) {
+        const safe = safeJsonValue(value[key], state, depth + 1);
+        if (safe !== undefined)
+            result[safeText(key, 64)] = safe;
+    }
+    return result;
+}
+function advisoryPermissions(advisory) {
+    const safe = {};
+    const state = { nodes: 0 };
+    for (const key of [
+        "permissionConfidence",
+        "permissionIds",
+        "permissions",
+        "privilegeLevel",
+        "requiredPermissions",
+        "scopes",
+    ]) {
+        if (Object.hasOwn(advisory, key)) {
+            const value = safeJsonValue(advisory[key], state);
+            if (value !== undefined)
+                safe[key] = value;
+        }
+    }
+    return safe;
+}
+function warning(error) {
+    if (error instanceof OpenApiMcpError) {
+        if (error.code === "RECORD_DIGEST_MISMATCH") {
+            return {
+                code: "RECORD_DIGEST_MISMATCH",
+                message: "Search candidate rejected",
+            };
+        }
+        if (error.code === "RECORD_NOT_ADMITTED") {
+            return {
+                code: "RECORD_NOT_ADMITTED",
+                message: "Search candidate not admitted",
+            };
+        }
+        if (error.code.startsWith("MANIFEST_")) {
+            return {
+                code: error.code,
+                message: "Search candidate manifest rejected",
+            };
+        }
+    }
+    return {
+        code: "UPSTREAM_ERROR",
+        message: "Search candidate unavailable",
+    };
+}
+function normalizeCandidate(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Search candidate shape is invalid");
+    }
+    const prototype = Object.getPrototypeOf(value);
+    const expected = ["catalogId", "operationId", "releaseId"];
+    const keys = Reflect.ownKeys(value).sort();
+    if ((prototype !== null && prototype !== Object.prototype) ||
+        keys.length !== expected.length ||
+        keys.some((key, index) => key !== expected[index])) {
+        throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Search candidate shape is invalid");
+    }
+    const snapshot = Object.create(null);
+    for (const key of expected) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined ||
+            !("value" in descriptor) ||
+            !descriptor.enumerable ||
+            typeof descriptor.value !== "string") {
+            throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Search candidate fields are invalid");
+        }
+        snapshot[key] = descriptor.value;
+    }
+    // The operation-ref codec owns the public identity grammar. Encoding a
+    // detached snapshot validates every segment before it can drive a lookup.
+    encodeOperationRef({
+        catalogId: snapshot.catalogId,
+        releaseId: snapshot.releaseId,
+        operationId: snapshot.operationId,
+        manifestDigest: "0".repeat(64),
+    });
+    return Object.freeze({
+        catalogId: snapshot.catalogId,
+        releaseId: snapshot.releaseId,
+        operationId: snapshot.operationId,
+    });
+}
+function snapshotCandidates(value, maximum) {
+    try {
+        if (!Array.isArray(value))
+            throw new Error();
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+        if (lengthDescriptor === undefined ||
+            !("value" in lengthDescriptor) ||
+            !Number.isSafeInteger(lengthDescriptor.value) ||
+            lengthDescriptor.value < 0 ||
+            lengthDescriptor.value > maximum)
+            throw new Error();
+        const length = lengthDescriptor.value;
+        const keys = Reflect.ownKeys(value);
+        if (keys.length !== length + 1 ||
+            keys.some((key) => typeof key !== "string" ||
+                (key !== "length" && !/^(0|[1-9][0-9]*)$/.test(key))))
+            throw new Error();
+        const snapshot = [];
+        for (let index = 0; index < length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !descriptor.enumerable)
+                throw new Error();
+            snapshot.push(descriptor.value);
+        }
+        return snapshot;
+    }
+    catch {
+        throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Search candidate result is invalid");
+    }
+}
+function snapshotSearchInput(value) {
+    try {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new Error();
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== null && prototype !== Object.prototype)
+            throw new Error();
+        const keys = Reflect.ownKeys(value).sort();
+        const allowed = ["api", "limit", "query"];
+        if (keys.some((key) => typeof key !== "string" || !allowed.includes(key)) ||
+            !keys.includes("query"))
+            throw new Error();
+        const snapshot = Object.create(null);
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !descriptor.enumerable)
+                throw new Error();
+            snapshot[key] = descriptor.value;
+        }
+        return Object.freeze(snapshot);
+    }
+    catch {
+        throw inputInvalid("Search input is invalid");
+    }
+}
+function validateSearchInput(value, limits) {
+    const input = snapshotSearchInput(value);
+    if (typeof input.query !== "string" ||
+        input.query.trim().length === 0 ||
+        input.query.length > 1024)
+        throw inputInvalid("Search input is invalid");
+    if (input.api !== undefined &&
+        (typeof input.api !== "string" ||
+            input.api.length === 0 ||
+            input.api.length > 128 ||
+            input.api === "." ||
+            input.api === ".." ||
+            !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(input.api)))
+        throw inputInvalid("Search input is invalid");
+    const limit = input.limit ??
+        Math.min(limits.defaultSearchResults, limits.maxSearchResults);
+    if (!Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > limits.maxSearchResults) {
+        throw inputInvalid("Search input is invalid");
+    }
+    return { api: input.api, limit, query: input.query };
+}
+function snapshotPrepareInput(value) {
+    try {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new Error();
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== null && prototype !== Object.prototype)
+            throw new Error();
+        const keys = Reflect.ownKeys(value).sort();
+        const expected = Object.hasOwn(value, "pageToken")
+            ? ["arguments", "operation", "pageToken"]
+            : ["arguments", "operation"];
+        if (keys.length !== expected.length ||
+            keys.some((key, index) => key !== expected[index]))
+            throw new Error();
+        const snapshot = Object.create(null);
+        for (const key of expected) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !descriptor.enumerable)
+                throw new Error();
+            snapshot[key] = descriptor.value;
+        }
+        if (Object.hasOwn(snapshot, "pageToken") &&
+            (typeof snapshot.pageToken !== "string" ||
+                snapshot.pageToken.length === 0 ||
+                snapshot.pageToken.length > 512 ||
+                Array.from(snapshot.pageToken).some((character) => character.charCodeAt(0) <= 32 || character.charCodeAt(0) === 127)))
+            throw inputInvalid("Pagination token is invalid");
+        if (typeof snapshot.operation !== "string")
+            throw new Error();
+        return Object.freeze({
+            operation: snapshot.operation,
+            arguments: snapshot.arguments,
+            pageToken: typeof snapshot.pageToken === "string" ? snapshot.pageToken : null,
+        });
+    }
+    catch (error) {
+        if (error instanceof OpenApiMcpError)
+            throw error;
+        throw inputInvalid("Prepare input is invalid");
+    }
+}
+function snapshotCredentialSlots(value) {
+    try {
+        if (!Array.isArray(value) || value.length > 64)
+            throw new Error();
+        const keys = Reflect.ownKeys(value);
+        if (keys.length !== value.length + 1 ||
+            keys.some((key) => key !== "length" &&
+                (typeof key !== "string" || !/^(?:0|[1-9][0-9]*)$/.test(key))))
+            throw new Error();
+        const slots = [];
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                !descriptor.enumerable)
+                throw new Error();
+            const raw = descriptor.value;
+            if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+                throw new Error();
+            const prototype = Object.getPrototypeOf(raw);
+            if (prototype !== null && prototype !== Object.prototype)
+                throw new Error();
+            const slotKeys = Reflect.ownKeys(raw).sort();
+            if (slotKeys.length !== 2 ||
+                slotKeys[0] !== "name" ||
+                slotKeys[1] !== "placement")
+                throw new Error();
+            const nameDescriptor = Object.getOwnPropertyDescriptor(raw, "name");
+            const placementDescriptor = Object.getOwnPropertyDescriptor(raw, "placement");
+            if (nameDescriptor === undefined ||
+                !("value" in nameDescriptor) ||
+                !nameDescriptor.enumerable ||
+                typeof nameDescriptor.value !== "string" ||
+                nameDescriptor.value.length === 0 ||
+                nameDescriptor.value.length > 256 ||
+                new TextEncoder().encode(nameDescriptor.value).length > 256 ||
+                placementDescriptor === undefined ||
+                !("value" in placementDescriptor) ||
+                !placementDescriptor.enumerable ||
+                (placementDescriptor.value !== "header" &&
+                    placementDescriptor.value !== "query"))
+                throw new Error();
+            slots.push(Object.freeze({
+                name: nameDescriptor.value,
+                placement: placementDescriptor.value,
+            }));
+        }
+        slots.sort((left, right) => {
+            const leftKey = `${left.placement}\0${left.placement === "header" ? left.name.toLowerCase() : left.name}`;
+            const rightKey = `${right.placement}\0${right.placement === "header" ? right.name.toLowerCase() : right.name}`;
+            return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+        });
+        return Object.freeze(slots);
+    }
+    catch {
+        throw new OpenApiMcpError("AUTH_PROFILE_INVALID", "Credential slot policy is invalid");
+    }
+}
+function snapshotCredentialProfileBinding(value) {
+    try {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new Error();
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== null && prototype !== Object.prototype)
+            throw new Error();
+        const keys = Reflect.ownKeys(value).sort();
+        if (keys.length !== 3 ||
+            keys[0] !== "profileDigest" ||
+            keys[1] !== "profileId" ||
+            keys[2] !== "slots")
+            throw new Error();
+        const profileId = Object.getOwnPropertyDescriptor(value, "profileId");
+        const profileDigest = Object.getOwnPropertyDescriptor(value, "profileDigest");
+        const slots = Object.getOwnPropertyDescriptor(value, "slots");
+        if (profileId === undefined ||
+            !("value" in profileId) ||
+            !profileId.enumerable ||
+            typeof profileId.value !== "string" ||
+            profileId.value.length === 0 ||
+            profileId.value.length > 128 ||
+            !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(profileId.value) ||
+            profileId.value === "." ||
+            profileId.value === ".." ||
+            profileDigest === undefined ||
+            !("value" in profileDigest) ||
+            !profileDigest.enumerable ||
+            typeof profileDigest.value !== "string" ||
+            !/^[0-9a-f]{64}$/.test(profileDigest.value) ||
+            slots === undefined ||
+            !("value" in slots) ||
+            !slots.enumerable)
+            throw new Error();
+        return Object.freeze({
+            profileId: profileId.value,
+            profileDigest: profileDigest.value,
+            slots: snapshotCredentialSlots(slots.value),
+        });
+    }
+    catch {
+        throw new OpenApiMcpError("AUTH_PROFILE_INVALID", "Credential binding policy is invalid");
+    }
+}
+function destinationDenied() {
+    return new OpenApiMcpError("DESTINATION_DENIED", "Operation destination is denied");
+}
+function timingSafeEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < left.length; index += 1)
+        difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+    return difference === 0;
+}
+/** Internal host preflight. Proves all members without admitting any generation. */
+export async function verifyExecutableRelease(options, catalogId, releaseId) {
+    const limits = resolveRuntimeLimits(options.limits);
+    const authenticated = await authenticateManifest(await options.store.getManifest(catalogId, releaseId), options.trust, limits);
+    if (authenticated.manifest.catalogId !== catalogId ||
+        authenticated.manifest.releaseId !== releaseId)
+        throw new OpenApiMcpError("RECORD_NOT_ADMITTED");
+    await verifyCompleteRelease(options.store, authenticated, limits, createCompleteVerificationBudget(limits));
+    return authenticated;
+}
+/** Internal executable ingress; manifest-only admission retains its public contract. */
+export async function admitExecutableRelease(options, preflight) {
+    const limits = resolveRuntimeLimits(options.limits);
+    const budget = createCompleteVerificationBudget(limits);
+    const { catalogId, releaseId, issuer, generation } = preflight.manifest;
+    let initialTransition;
+    for (let attempt = 0; attempt < 32; attempt++) {
+        const state = await options.generations.get(catalogId, issuer);
+        const transition = state !== null && generation < state.highestGeneration
+            ? "rollback"
+            : "normal";
+        if (initialTransition !== undefined && initialTransition !== transition)
+            throw new OpenApiMcpError("MANIFEST_GENERATION_CONFLICT");
+        initialTransition ??= transition;
+        const current = await authenticateManifest(await options.store.getManifest(catalogId, releaseId), options.trust, limits);
+        if (current.manifestDigest !== preflight.manifestDigest)
+            throw new OpenApiMcpError("MANIFEST_GENERATION_CONFLICT");
+        await verifyCompleteRelease(options.store, current, limits, budget);
+        if (!sameGenerationState(state, await options.generations.get(catalogId, issuer)))
+            continue;
+        const admitted = await commitAuthenticatedManifestAtState(current, options.trust, options.generations, state);
+        if (admitted !== null)
+            return admitted;
+    }
+    throw new OpenApiMcpError("MANIFEST_GENERATION_CONFLICT");
+}
+/** Construct the portable verified runtime. */
+export function createOpenApiRuntime(options) {
+    return createRuntime(options);
+}
+/** Internal adapter seam. Source calls draw from the same budget as record proof. */
+export function createRuntimeWithCandidateLookup(options, lookup) {
+    return createRuntime(options, lookup);
+}
+function createRuntime(options, lookup) {
+    const limits = resolveRuntimeLimits(options.limits);
+    const committingGenerations = {
+        get(catalogId, issuer) {
+            return options.generations.get(catalogId, issuer);
+        },
+        async accept(catalogId, issuer, transition) {
+            try {
+                return await options.generations.accept(catalogId, issuer, transition);
+            }
+            catch {
+                throw new GenerationStoreUnavailable();
+            }
+        },
+    };
+    const requireActiveManifest = async (authenticated) => {
+        let activeState;
+        try {
+            const state = await options.generations.get(authenticated.manifest.catalogId, authenticated.manifest.issuer);
+            activeState =
+                state === null
+                    ? null
+                    : {
+                        generation: state.activeGeneration,
+                        digest: state.activeManifestDigest,
+                    };
+        }
+        catch {
+            throw upstreamUnavailable("Generation state is unavailable");
+        }
+        if (activeState === null ||
+            activeState.generation !== authenticated.manifest.generation ||
+            !timingSafeEqual(typeof activeState.digest === "string" ? activeState.digest : "", authenticated.manifestDigest))
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Prepared call release is not active");
+    };
+    const prepare = async (inputValue, expectedSafety) => {
+        const input = snapshotPrepareInput(inputValue);
+        if (input.pageToken !== null &&
+            (expectedSafety !== "read" || !options.paginationTokenCodec))
+            throw inputInvalid("Pagination token is not permitted");
+        const reference = decodeOperationRef(input.operation);
+        let envelope;
+        try {
+            envelope = await options.store.getManifest(reference.catalogId, reference.releaseId);
+        }
+        catch {
+            throw upstreamUnavailable("Manifest lookup is unavailable");
+        }
+        const authenticated = await authenticateManifest(envelope, options.trust, limits);
+        if (authenticated.manifest.catalogId !== reference.catalogId ||
+            authenticated.manifest.releaseId !== reference.releaseId ||
+            !timingSafeEqual(authenticated.manifestDigest, reference.manifestDigest))
+            throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Operation reference release is not admitted");
+        await requireActiveManifest(authenticated);
+        const destinationPolicy = options.destinationPolicy;
+        if (destinationPolicy === undefined)
+            throw destinationDenied();
+        const credentialBindingResolver = options.credentialBinding;
+        if (credentialBindingResolver === undefined)
+            throw new OpenApiMcpError("AUTH_PROFILE_INVALID", "Credential binding policy is unavailable");
+        let storedOperation;
+        try {
+            storedOperation = await options.store.getOperation(reference.catalogId, reference.releaseId, reference.operationId);
+        }
+        catch {
+            throw upstreamUnavailable("Operation lookup is unavailable");
+        }
+        if (storedOperation === null)
+            throw new OpenApiMcpError("OPERATION_NOT_FOUND", "Referenced operation was not found");
+        const operation = await verifyStoredRecord(authenticated, storedOperation, limits);
+        if (operation.id !== reference.operationId)
+            throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Operation identity does not match its reference");
+        const operationDigest = authenticated.manifest.records[operation.id];
+        const schemas = await resolveSchemaClosure(options.store, authenticated, operation.schemaIds, limits);
+        let allowed = false;
+        try {
+            allowed = await destinationPolicy.allows(operation.origin);
+        }
+        catch {
+            throw destinationDenied();
+        }
+        if (allowed !== true)
+            throw destinationDenied();
+        const slotContext = Object.freeze({
+            catalogId: reference.catalogId,
+            releaseId: reference.releaseId,
+            operationId: operation.id,
+            operationDigest,
+            manifestDigest: authenticated.manifestDigest,
+            method: operation.method,
+            origin: operation.origin,
+        });
+        let bindingResult;
+        try {
+            bindingResult = await credentialBindingResolver.resolve(slotContext);
+        }
+        catch {
+            throw new OpenApiMcpError("AUTH_PROFILE_INVALID", "Credential binding policy failed");
+        }
+        const credentialBinding = snapshotCredentialProfileBinding(bindingResult);
+        const credentialSlots = credentialBinding.slots;
+        const serialized = serializeArguments(operation, schemas, input.arguments, {
+            limits,
+            reservedCredentialSlots: credentialSlots,
+        });
+        const operationClassification = classifyOperation(operation, [...schemas.values()], serialized.normalizedArguments);
+        if (operationClassification.safety !== expectedSafety)
+            throw new OpenApiMcpError("TOOL_SAFETY_MISMATCH", expectedSafety === "read"
+                ? "Operation requires the action tool"
+                : "Operation requires the read tool");
+        const reservedSlotsDigest = await sha256("knitli.openapi-mcp.credential-slots.v1", credentialSlots);
+        let prepared = await createPreparedCall({
+            version: PREPARED_CALL_VERSION,
+            catalogId: reference.catalogId,
+            releaseId: reference.releaseId,
+            operationId: operation.id,
+            operationDigest,
+            manifestDigest: authenticated.manifestDigest,
+            credentialProfileId: credentialBinding.profileId,
+            credentialProfileDigest: credentialBinding.profileDigest,
+            reservedSlotsDigest,
+            method: operation.method,
+            origin: operation.origin,
+            relativeUrl: serialized.relativeUrl,
+            pageToken: null,
+            headers: serialized.headers,
+            body: serialized.body,
+            normalizedArguments: serialized.normalizedArguments,
+            safety: operationClassification.safety,
+            actionKind: operationClassification.actionKind,
+            cardinality: operationClassification.cardinality,
+        });
+        if (input.pageToken !== null) {
+            let token;
+            try {
+                if (!options.paginationTokenCodec)
+                    throw inputInvalid("Pagination codec is unavailable");
+                token = snapshotPaginationTokenState(await options.paginationTokenCodec.decode(input.pageToken), limits);
+            }
+            catch (error) {
+                if (error instanceof OpenApiMcpError &&
+                    error.code === "PAGINATION_LIMIT_EXCEEDED")
+                    throw error;
+                throw inputInvalid("Pagination token is invalid");
+            }
+            if (token.catalogId !== prepared.catalogId ||
+                token.releaseId !== prepared.releaseId ||
+                token.operationId !== prepared.operationId ||
+                token.origin !== prepared.origin ||
+                !timingSafeEqual(token.manifestDigest, prepared.manifestDigest) ||
+                !timingSafeEqual(token.inputDigest, prepared.inputDigest))
+                throw inputInvalid("Pagination token does not match the call");
+            const nextUrl = new URL(token.nextRelativeUrl, prepared.origin);
+            for (const slot of credentialSlots) {
+                if (slot.placement === "query" &&
+                    [...nextUrl.searchParams.keys()].some((key) => key.toLowerCase() === slot.name.toLowerCase()))
+                    throw inputInvalid("Continuation URL contains a reserved credential slot");
+            }
+            const { inputDigest: _inputDigest, preparedCallDigest: _preparedCallDigest, ...payload } = prepared;
+            prepared = await createPreparedCall({
+                ...payload,
+                relativeUrl: token.nextRelativeUrl,
+                pageToken: input.pageToken,
+            });
+        }
+        await requireActiveManifest(authenticated);
+        return prepared;
+    };
+    const runtime = {
+        async search(input) {
+            const query = validateSearchInput(input, limits);
+            const completeVerificationBudget = createCompleteVerificationBudget(limits);
+            const emptyBytes = new TextEncoder().encode(canonicalJson({ operations: [], warnings: [] })).length;
+            if (emptyBytes > limits.maxResponseBytes) {
+                throw new OpenApiMcpError("RESPONSE_LIMIT_EXCEEDED", "Search response limit is too small");
+            }
+            const candidateLimit = Math.min(query.limit * 3, 150);
+            let candidateResult;
+            let candidateLookupLimited = false;
+            try {
+                const input = { ...query, limit: candidateLimit };
+                if (lookup) {
+                    const found = await lookup(input, () => {
+                        try {
+                            chargeCompleteVerification(completeVerificationBudget, {
+                                storeCalls: 1,
+                                work: 1,
+                            });
+                            return true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                    candidateResult = found.candidates;
+                    candidateLookupLimited = found.limited;
+                }
+                else {
+                    chargeCompleteVerification(completeVerificationBudget, {
+                        storeCalls: 1,
+                        work: 1,
+                    });
+                    candidateResult = await options.store.searchCandidates(input);
+                }
+            }
+            catch {
+                throw upstreamUnavailable("Search candidate lookup is unavailable");
+            }
+            const candidates = snapshotCandidates(candidateResult, candidateLimit);
+            const operations = [];
+            const warnings = [];
+            const seen = new Set();
+            const manifests = new Map();
+            const failedManifests = new Set();
+            let releaseAttempts = 0;
+            const authenticateCandidateRelease = async (catalogId, releaseId) => {
+                const key = manifestKey(catalogId, releaseId);
+                const cached = manifests.get(key);
+                if (cached !== undefined)
+                    return cached;
+                if (failedManifests.has(key)) {
+                    throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Search candidate manifest was already rejected");
+                }
+                if (releaseAttempts >= maximumSearchReleases) {
+                    return null;
+                }
+                releaseAttempts += 1;
+                try {
+                    const envelope = await options.store.getManifest(catalogId, releaseId);
+                    const authenticated = await authenticateManifest(envelope, options.trust, limits);
+                    if (authenticated.manifest.catalogId !== catalogId ||
+                        authenticated.manifest.releaseId !== releaseId) {
+                        throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Search candidate release identity does not match its manifest");
+                    }
+                    const entry = { authenticated };
+                    manifests.set(key, entry);
+                    return entry;
+                }
+                catch (error) {
+                    failedManifests.add(key);
+                    throw error;
+                }
+            };
+            const responseFits = (items, candidateWarnings) => new TextEncoder().encode(canonicalJson({
+                operations: [...items],
+                warnings: [...candidateWarnings],
+            })).length <= limits.maxResponseBytes;
+            const limitWarning = {
+                code: "RESPONSE_LIMIT_EXCEEDED",
+                message: "Search response limit reached",
+            };
+            const addWarning = (candidateWarning) => {
+                if (!responseFits([], [...warnings, candidateWarning, limitWarning]))
+                    return false;
+                warnings.push(candidateWarning);
+                return true;
+            };
+            let responseLimited = false;
+            let admissionLimited = candidateLookupLimited;
+            for (const [rank, rawCandidate] of candidates.entries()) {
+                let candidate;
+                try {
+                    candidate = normalizeCandidate(rawCandidate);
+                }
+                catch (error) {
+                    if (!addWarning(warning(error)))
+                        responseLimited = true;
+                    continue;
+                }
+                if (query.api !== undefined &&
+                    !candidate.operationId.startsWith(`operation:${query.api}:`)) {
+                    if (!addWarning(warning(new OpenApiMcpError("RECORD_DIGEST_MISMATCH"))))
+                        responseLimited = true;
+                    continue;
+                }
+                const key = manifestKey(candidate.catalogId, candidate.releaseId);
+                const identity = `${key}\0${candidate.operationId}`;
+                if (seen.has(identity))
+                    continue;
+                seen.add(identity);
+                try {
+                    const entry = await authenticateCandidateRelease(candidate.catalogId, candidate.releaseId);
+                    if (entry === null) {
+                        admissionLimited = true;
+                        continue;
+                    }
+                    const row = await options.store.getOperation(candidate.catalogId, candidate.releaseId, candidate.operationId);
+                    if (row === null) {
+                        throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Search candidate record is missing");
+                    }
+                    const operation = await verifyStoredRecord(entry.authenticated, row, limits);
+                    if (operation.id !== candidate.operationId) {
+                        throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Search candidate identity does not match its record");
+                    }
+                    if (query.api !== undefined && operation.api !== query.api) {
+                        throw new OpenApiMcpError("RECORD_DIGEST_MISMATCH", "Search candidate API does not match its filter");
+                    }
+                    const runtimeClassification = classifyOperation(operation);
+                    const retained = {
+                        admission: {
+                            catalogId: entry.authenticated.manifest.catalogId,
+                            releaseId: entry.authenticated.manifest.releaseId,
+                            issuer: entry.authenticated.manifest.issuer,
+                            generation: entry.authenticated.manifest.generation,
+                            digest: entry.authenticated.manifestDigest,
+                        },
+                        id: `${candidate.catalogId}\0${candidate.releaseId}\0${operation.id}`,
+                        rank,
+                        item: {
+                            operation: encodeOperationRef({
+                                catalogId: candidate.catalogId,
+                                releaseId: candidate.releaseId,
+                                operationId: operation.id,
+                                manifestDigest: entry.authenticated.manifestDigest,
+                            }),
+                            summary: safeSummary(operation.summary),
+                            inputOutline: inputOutline(operation),
+                            ...runtimeClassification,
+                            deprecated: operation.deprecated,
+                            advisory: advisoryPermissions(operation.advisory),
+                        },
+                    };
+                    operations.push(retained);
+                }
+                catch (error) {
+                    if (!addWarning(warning(error)))
+                        responseLimited = true;
+                }
+            }
+            if (admissionLimited) {
+                if (!addWarning({
+                    code: "RECORD_NOT_ADMITTED",
+                    message: "Search release admission limit reached",
+                }))
+                    responseLimited = true;
+            }
+            const stagedOperations = operations.splice(0);
+            const warnedOperations = new Set();
+            const warnOperations = (candidates, error) => {
+                for (const candidate of candidates) {
+                    if (warnedOperations.has(candidate.id))
+                        continue;
+                    warnedOperations.add(candidate.id);
+                    if (!addWarning(warning(error)))
+                        responseLimited = true;
+                }
+            };
+            const groups = new Map();
+            for (const staged of stagedOperations) {
+                const groupKey = `${staged.admission.catalogId}\0${staged.admission.issuer}`;
+                const group = groups.get(groupKey);
+                if (group === undefined)
+                    groups.set(groupKey, [staged]);
+                else
+                    group.push(staged);
+            }
+            for (const group of groups.values()) {
+                const byGeneration = new Map();
+                for (const staged of group) {
+                    let releases = byGeneration.get(staged.admission.generation);
+                    if (releases === undefined) {
+                        releases = new Map();
+                        byGeneration.set(staged.admission.generation, releases);
+                    }
+                    const release = releases.get(staged.admission.digest);
+                    if (release === undefined)
+                        releases.set(staged.admission.digest, [staged]);
+                    else
+                        release.push(staged);
+                }
+                let selected;
+                const generations = [...byGeneration.keys()].sort((left, right) => right - left);
+                let selectionSettled = false;
+                const initialTransitionKinds = new Map();
+                for (let selectionAttempt = 0; selectionAttempt < 32; selectionAttempt += 1) {
+                    let capturedState;
+                    try {
+                        capturedState = await options.generations.get(group[0].admission.catalogId, group[0].admission.issuer);
+                    }
+                    catch {
+                        throw upstreamUnavailable("Generation state is unavailable");
+                    }
+                    const attemptWarnings = [];
+                    let restartSelection = false;
+                    for (const generation of generations) {
+                        const releases = byGeneration.get(generation);
+                        if (releases === undefined)
+                            continue;
+                        let alreadyActive = false;
+                        let candidates;
+                        if (releases.size !== 1) {
+                            const activeDigest = capturedState?.activeGeneration === generation
+                                ? capturedState.activeManifestDigest
+                                : undefined;
+                            candidates =
+                                activeDigest === undefined
+                                    ? undefined
+                                    : releases.get(activeDigest);
+                            alreadyActive = candidates !== undefined;
+                            if (candidates === undefined) {
+                                for (const conflicting of releases.values())
+                                    attemptWarnings.push({
+                                        candidates: conflicting,
+                                        error: new OpenApiMcpError("MANIFEST_GENERATION_CONFLICT"),
+                                    });
+                                continue;
+                            }
+                        }
+                        else {
+                            candidates = releases.values().next().value;
+                        }
+                        if (candidates === undefined || candidates.length === 0)
+                            continue;
+                        const admission = candidates[0].admission;
+                        const key = manifestKey(admission.catalogId, admission.releaseId);
+                        const entry = manifests.get(key);
+                        if (entry === undefined)
+                            continue;
+                        try {
+                            if (alreadyActive) {
+                                await verifyCompleteRelease(options.store, entry.authenticated, limits, completeVerificationBudget);
+                                let currentState;
+                                try {
+                                    currentState = await options.generations.get(admission.catalogId, admission.issuer);
+                                }
+                                catch {
+                                    throw new GenerationStoreUnavailable();
+                                }
+                                if (!sameGenerationState(capturedState, currentState)) {
+                                    restartSelection = true;
+                                    break;
+                                }
+                            }
+                            else {
+                                await verifyCompleteRelease(options.store, entry.authenticated, limits, completeVerificationBudget);
+                                const transitionKind = capturedState !== null &&
+                                    admission.generation < capturedState.highestGeneration
+                                    ? "rollback"
+                                    : "normal";
+                                const initialTransitionKind = initialTransitionKinds.get(admission.digest);
+                                if (initialTransitionKind === undefined) {
+                                    initialTransitionKinds.set(admission.digest, transitionKind);
+                                }
+                                else if (initialTransitionKind !== transitionKind) {
+                                    throw new OpenApiMcpError("MANIFEST_GENERATION_CONFLICT", "Generation state changed the selected transition kind");
+                                }
+                                const admitted = await commitAuthenticatedManifestAtState(entry.authenticated, options.trust, committingGenerations, capturedState);
+                                if (admitted === null) {
+                                    restartSelection = true;
+                                    break;
+                                }
+                            }
+                            selected = candidates;
+                            operations.push(...candidates);
+                            break;
+                        }
+                        catch (error) {
+                            if (error instanceof GenerationStoreUnavailable)
+                                throw error;
+                            failedManifests.add(key);
+                            attemptWarnings.push({ candidates, error });
+                        }
+                    }
+                    if (restartSelection) {
+                        selected = undefined;
+                        continue;
+                    }
+                    if (selected === undefined) {
+                        let currentState;
+                        try {
+                            currentState = await options.generations.get(group[0].admission.catalogId, group[0].admission.issuer);
+                        }
+                        catch {
+                            throw upstreamUnavailable("Generation state is unavailable");
+                        }
+                        if (!sameGenerationState(capturedState, currentState))
+                            continue;
+                    }
+                    for (const pending of attemptWarnings)
+                        warnOperations(pending.candidates, pending.error);
+                    selectionSettled = true;
+                    break;
+                }
+                if (!selectionSettled) {
+                    warnOperations(group, new OpenApiMcpError("MANIFEST_GENERATION_CONFLICT", "Generation state changed too many times; retry search"));
+                }
+                const selectedSet = new Set(selected ?? []);
+                for (const staged of group) {
+                    if (selectedSet.has(staged) || warnedOperations.has(staged.id))
+                        continue;
+                    warnOperations([staged], new OpenApiMcpError("RECORD_NOT_ADMITTED"));
+                }
+            }
+            const finalStates = new Map();
+            for (const { admission } of operations) {
+                const key = `${admission.catalogId}\0${admission.issuer}`;
+                if (finalStates.has(key))
+                    continue;
+                try {
+                    const state = await options.generations.get(admission.catalogId, admission.issuer);
+                    finalStates.set(key, state === null
+                        ? null
+                        : {
+                            activeGeneration: state.activeGeneration,
+                            activeManifestDigest: state.activeManifestDigest,
+                        });
+                }
+                catch {
+                    throw upstreamUnavailable("Generation state is unavailable");
+                }
+            }
+            for (let index = operations.length - 1; index >= 0; index -= 1) {
+                const admission = operations[index].admission;
+                const state = finalStates.get(`${admission.catalogId}\0${admission.issuer}`);
+                if (state === undefined ||
+                    state === null ||
+                    state.activeGeneration !== admission.generation ||
+                    state.activeManifestDigest !== admission.digest) {
+                    operations.splice(index, 1);
+                    if (!addWarning(warning(new OpenApiMcpError("RECORD_NOT_ADMITTED"))))
+                        responseLimited = true;
+                }
+            }
+            operations.sort((left, right) => {
+                if (left.item.deprecated !== right.item.deprecated) {
+                    return left.item.deprecated ? 1 : -1;
+                }
+                if (left.rank !== right.rank)
+                    return left.rank - right.rank;
+                return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+            });
+            const returnedOperations = operations.slice(0, query.limit);
+            if (!responseFits(returnedOperations.map(({ item }) => item), warnings))
+                responseLimited = true;
+            if (responseLimited) {
+                while (!responseFits(returnedOperations.map(({ item }) => item), [...warnings, limitWarning])) {
+                    if (returnedOperations.pop() === undefined) {
+                        throw new OpenApiMcpError("RESPONSE_LIMIT_EXCEEDED", "Search response limit is too small");
+                    }
+                }
+                warnings.push(limitWarning);
+            }
+            return {
+                operations: returnedOperations.map(({ item }) => item),
+                warnings,
+            };
+        },
+        async prepareRead(input) {
+            return await prepare(input, "read");
+        },
+        async prepareAction(input) {
+            return await prepare(input, "action");
+        },
+        async revalidate(call) {
+            const snapshot = await verifyAndSnapshotPreparedCall(call);
+            const operation = encodeOperationRef({
+                catalogId: snapshot.catalogId,
+                releaseId: snapshot.releaseId,
+                operationId: snapshot.operationId,
+                manifestDigest: snapshot.manifestDigest,
+            });
+            const fresh = await prepare(Object.freeze({
+                operation,
+                arguments: snapshot.normalizedArguments,
+                ...(snapshot.pageToken === null
+                    ? {}
+                    : { pageToken: snapshot.pageToken }),
+            }), snapshot.safety);
+            if (!timingSafeEqual(fresh.operationDigest, snapshot.operationDigest) ||
+                !timingSafeEqual(fresh.manifestDigest, snapshot.manifestDigest) ||
+                fresh.credentialProfileId !== snapshot.credentialProfileId ||
+                !timingSafeEqual(fresh.credentialProfileDigest, snapshot.credentialProfileDigest) ||
+                !timingSafeEqual(fresh.reservedSlotsDigest, snapshot.reservedSlotsDigest) ||
+                !timingSafeEqual(fresh.inputDigest, snapshot.inputDigest) ||
+                !timingSafeEqual(fresh.preparedCallDigest, snapshot.preparedCallDigest))
+                throw new OpenApiMcpError("RECORD_NOT_ADMITTED", "Prepared call no longer matches current policy and records");
+            return fresh;
+        },
+    };
+    return runtime;
+}