@knitli/openapi-mcp 0.0.0

package/dist/runtime/classify.js

@@ -0,0 +1,279 @@
+const MAX_TOKEN_SOURCE_LENGTH = 1_024;
+const MAX_TOKENS = 48;
+const MAX_TOKEN_LENGTH = 48;
+const communicationTokens = new Set([
+    "communicate",
+    "email",
+    "invite",
+    "invitation",
+    "mail",
+    "message",
+    "notify",
+    "notification",
+    "send",
+    "share",
+    "sharing",
+]);
+const authorityTokens = new Set([
+    "access",
+    "authority",
+    "grant",
+    "membership",
+    "member",
+    "permission",
+    "privilege",
+    "role",
+]);
+const transactionTokens = new Set([
+    "charge",
+    "invoice",
+    "payment",
+    "purchase",
+    "refund",
+    "transaction",
+    "transfer",
+]);
+const executeTokens = new Set([
+    "deploy",
+    "execute",
+    "invoke",
+    "run",
+    "start",
+    "trigger",
+]);
+const createTokens = new Set(["add", "create", "provision", "register"]);
+const updateTokens = new Set(["modify", "patch", "replace", "set", "update"]);
+const bulkTokens = new Set([
+    "all",
+    "batch",
+    "bulk",
+    "each",
+    "everyone",
+    "many",
+]);
+function tokensForSource(source) {
+    const inspected = source.slice(0, MAX_TOKEN_SOURCE_LENGTH);
+    const words = inspected
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .toLowerCase()
+        .match(/[a-z0-9]+/g);
+    const tokenSource = words ?? [];
+    return {
+        tokens: tokenSource
+            .slice(0, MAX_TOKENS)
+            .map((word) => word.slice(0, MAX_TOKEN_LENGTH)),
+        truncated: source.length > MAX_TOKEN_SOURCE_LENGTH ||
+            tokenSource.length > MAX_TOKENS ||
+            tokenSource.some((word) => word.length > MAX_TOKEN_LENGTH),
+    };
+}
+function normalizedTokens(operation) {
+    // Each signed source has an independent budget. A source that does not fit
+    // cannot be safely classified as routine, because omitted later evidence
+    // could establish a dangerous kind or batch cardinality.
+    const tokens = [];
+    let truncated = false;
+    for (const source of [
+        operation.operationId,
+        operation.path,
+        ...operation.tags,
+    ]) {
+        const evidence = tokensForSource(source);
+        tokens.push(...evidence.tokens);
+        truncated ||= evidence.truncated;
+    }
+    return { tokens, truncated };
+}
+function hasAny(tokens, candidates) {
+    return tokens.some((token) => candidates.has(token) ||
+        (token.length > 4 &&
+            token.endsWith("ies") &&
+            candidates.has(`${token.slice(0, -3)}y`)) ||
+        (token.length > 4 &&
+            token.endsWith("es") &&
+            candidates.has(token.slice(0, -2))) ||
+        (token.length > 3 &&
+            token.endsWith("s") &&
+            candidates.has(token.slice(0, -1))));
+}
+function hasBatchSemantics(operation, tokens) {
+    return (operation.path === "/$batch" ||
+        operation.path.endsWith("/$batch") ||
+        tokens.includes("batch"));
+}
+function actionKindFor(operation, evidence) {
+    if (operation.method === "DELETE")
+        return "delete";
+    if (evidence.truncated)
+        return "unknown";
+    const dangerousMatches = [];
+    for (const [kind, candidates] of [
+        ["communicate", communicationTokens],
+        ["authority", authorityTokens],
+        ["transaction", transactionTokens],
+        ["execute", executeTokens],
+    ]) {
+        if (hasAny(evidence.tokens, candidates))
+            dangerousMatches.push(kind);
+    }
+    if (dangerousMatches.length > 0)
+        return dangerousMatches.length === 1 ? dangerousMatches[0] : "unknown";
+    const routineMatches = [];
+    for (const [kind, candidates] of [
+        ["create", createTokens],
+        ["update", updateTokens],
+    ]) {
+        if (hasAny(evidence.tokens, candidates))
+            routineMatches.push(kind);
+    }
+    return routineMatches.length === 1 ? routineMatches[0] : "unknown";
+}
+function isVerifiedArrayBound(schema) {
+    if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+        return null;
+    if (schema.type !== "array")
+        return null;
+    const maxItems = schema.maxItems;
+    return typeof maxItems === "number" &&
+        Number.isSafeInteger(maxItems) &&
+        maxItems > 0
+        ? maxItems
+        : null;
+}
+function argumentSection(arguments_, section) {
+    const value = arguments_[section];
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function presentParameterSelector(arguments_, parameter) {
+    if (parameter.in === "cookie")
+        return undefined;
+    const section = argumentSection(arguments_, parameter.in === "header" ? "headers" : parameter.in);
+    return section !== undefined && Object.hasOwn(section, parameter.name)
+        ? section[parameter.name]
+        : undefined;
+}
+function boundedCardinality(operation, schemas, normalizedArguments) {
+    const schemaById = new Map();
+    const ambiguousSchemaIds = new Set();
+    for (const schema of schemas) {
+        if (schemaById.has(schema.id))
+            ambiguousSchemaIds.add(schema.id);
+        else
+            schemaById.set(schema.id, schema);
+    }
+    let maximum = 0;
+    let found = false;
+    let unprovenArray = false;
+    const containsArray = (value) => {
+        if (Array.isArray(value))
+            return true;
+        return (typeof value === "object" &&
+            value !== null &&
+            Object.values(value).some(containsArray));
+    };
+    const addBound = (schemaId, selector) => {
+        if (!Array.isArray(selector)) {
+            unprovenArray ||= containsArray(selector);
+            return;
+        }
+        // Independent selectors may multiply effects. A single array bound also
+        // does not bound nested arrays, so neither shape proves a routine limit.
+        if (found || selector.some(containsArray)) {
+            unprovenArray = true;
+            return;
+        }
+        if (ambiguousSchemaIds.has(schemaId)) {
+            unprovenArray = true;
+            return;
+        }
+        const schema = schemaById.get(schemaId);
+        if (schema === undefined) {
+            unprovenArray = true;
+            return;
+        }
+        const maxItems = isVerifiedArrayBound(schema.schema);
+        if (maxItems === null) {
+            unprovenArray = true;
+            return;
+        }
+        maximum = maxItems;
+        found = true;
+    };
+    for (const parameter of operation.parameters) {
+        addBound(parameter.value.schemaId, presentParameterSelector(normalizedArguments, parameter));
+    }
+    const requestBody = operation.requestBody;
+    if (Array.isArray(normalizedArguments.body)) {
+        if (requestBody === null || requestBody.content.length !== 1) {
+            unprovenArray = true;
+        }
+        else {
+            addBound(requestBody.content[0].schemaId, normalizedArguments.body);
+        }
+    }
+    else if (containsArray(normalizedArguments.body)) {
+        unprovenArray = true;
+    }
+    return {
+        cardinality: !unprovenArray && found && Number.isSafeInteger(maximum) && maximum > 0
+            ? { kind: "bounded", maxAffected: maximum }
+            : null,
+        unprovenArray,
+    };
+}
+function hasTerminalRequiredResourceIdentifier(operation) {
+    const terminalSegment = operation.path.split("/").at(-1);
+    return operation.parameters.some((parameter) => parameter.in === "path" &&
+        parameter.required &&
+        terminalSegment === `{${parameter.name}}` &&
+        /^(?:[iI][dD]|[A-Za-z0-9]+(?:Id|ID)|[A-Za-z0-9]+[-_.][iI][dD])$/.test(parameter.name));
+}
+function cardinalityFor(operation, tokens, schemas, normalizedArguments, truncated) {
+    if (truncated)
+        return { kind: "unknown" };
+    if (hasAny(tokens, bulkTokens))
+        return { kind: "unbounded" };
+    const bounded = boundedCardinality(operation, schemas, normalizedArguments);
+    if (bounded.unprovenArray)
+        return { kind: "unknown" };
+    if (bounded.cardinality !== null)
+        return bounded.cardinality;
+    if (hasTerminalRequiredResourceIdentifier(operation))
+        return { kind: "single" };
+    return { kind: "unknown" };
+}
+function isDangerous(kind) {
+    return kind !== "create" && kind !== "update";
+}
+/**
+ * Recompute safety, action kind, cardinality, and risk from verified records.
+ * Compiler-supplied advisory fields intentionally do not participate.
+ */
+export function classifyOperation(operation, schemas = [], normalizedArguments = {}) {
+    const evidence = normalizedTokens(operation);
+    if ((operation.method === "GET" || operation.method === "HEAD") &&
+        !evidence.truncated &&
+        !hasBatchSemantics(operation, evidence.tokens)) {
+        return {
+            safety: "read",
+            actionKind: null,
+            cardinality: null,
+            dangerous: false,
+            highRisk: false,
+        };
+    }
+    const actionKind = actionKindFor(operation, evidence);
+    const cardinality = cardinalityFor(operation, evidence.tokens, schemas, normalizedArguments, evidence.truncated);
+    const dangerous = isDangerous(actionKind);
+    return {
+        safety: "action",
+        actionKind,
+        cardinality,
+        dangerous,
+        highRisk: dangerous ||
+            cardinality.kind === "unknown" ||
+            cardinality.kind === "unbounded",
+    };
+}

package/dist/runtime/credential-binding.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialAuthorizationBinding, PreparedCall, Sha256 } from "./types.ts";
+export declare function digestCredentialAuthorizationBinding(value: Omit<CredentialAuthorizationBinding, "bindingDigest">): Promise<Sha256>;
+export declare function snapshotCredentialAuthorizationBinding(value: CredentialAuthorizationBinding, call?: Pick<PreparedCall, "credentialProfileId" | "credentialProfileDigest" | "reservedSlotsDigest">): Promise<CredentialAuthorizationBinding>;

package/dist/runtime/credential-binding.js

@@ -0,0 +1,101 @@
+import { sha256 } from "./digest.js";
+import { OpenApiMcpError } from "./errors.js";
+import { canonicalJsonBounded, parseJsonStrict } from "./strict-json.js";
+const domain = "knitli.openapi-mcp.credential-binding.v1";
+const digestPattern = /^[0-9a-f]{64}$/;
+function hasDisallowedCharacter(value, forbidSpace) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= (forbidSpace ? 0x20 : 0x1f) || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+function snapshot(value, hasDigest) {
+    try {
+        const json = canonicalJsonBounded(value, {
+            maxBytes: 16384,
+            maxDepth: 4,
+            maxNodes: 256,
+        });
+        const data = parseJsonStrict(json, {
+            maxBytes: 16384,
+            maxDepth: 4,
+            maxKeys: 256,
+        });
+        if (data === null || Array.isArray(data) || typeof data !== "object")
+            throw new Error();
+        const expected = [
+            "profileId",
+            "profileDigest",
+            "grantId",
+            "scopes",
+            "slotsDigest",
+        ];
+        if (hasDigest)
+            expected.push("bindingDigest");
+        if (Object.hasOwn(data, "audience"))
+            expected.push("audience");
+        if (Object.keys(data).sort().join(",") !== expected.sort().join(","))
+            throw new Error();
+        if (typeof data.profileId !== "string" ||
+            !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(data.profileId))
+            throw new Error();
+        if (typeof data.grantId !== "string" ||
+            !/^[A-Za-z0-9_-]{16,128}$/.test(data.grantId))
+            throw new Error();
+        for (const key of hasDigest
+            ? ["profileDigest", "slotsDigest", "bindingDigest"]
+            : ["profileDigest", "slotsDigest"]) {
+            if (typeof data[key] !== "string" || !digestPattern.test(data[key]))
+                throw new Error();
+        }
+        if (Object.hasOwn(data, "audience") &&
+            (typeof data.audience !== "string" ||
+                data.audience.length === 0 ||
+                data.audience.length > 2048 ||
+                hasDisallowedCharacter(data.audience, false)))
+            throw new Error();
+        if (!Array.isArray(data.scopes) || data.scopes.length > 64)
+            throw new Error();
+        const scopes = [];
+        for (const scope of data.scopes) {
+            if (typeof scope !== "string" ||
+                scope.length === 0 ||
+                scope.length > 256 ||
+                hasDisallowedCharacter(scope, true) ||
+                scopes.includes(scope))
+                throw new Error();
+            scopes.push(scope);
+        }
+        data.scopes = scopes.sort();
+        return data;
+    }
+    catch {
+        throw new OpenApiMcpError("AUTH_PROFILE_INVALID", "Credential binding is invalid");
+    }
+}
+export async function digestCredentialAuthorizationBinding(value) {
+    return sha256(domain, snapshot(value, false));
+}
+export async function snapshotCredentialAuthorizationBinding(value, call) {
+    const data = snapshot(value, true);
+    const callCommitments = call === undefined
+        ? undefined
+        : {
+            profileId: call.credentialProfileId,
+            profileDigest: call.credentialProfileDigest,
+            slotsDigest: call.reservedSlotsDigest,
+        };
+    const { bindingDigest, ...payload } = data;
+    const expected = await sha256(domain, payload);
+    if (expected !== bindingDigest ||
+        (callCommitments !== undefined &&
+            (data.profileId !== callCommitments.profileId ||
+                data.profileDigest !== callCommitments.profileDigest ||
+                data.slotsDigest !== callCommitments.slotsDigest))) {
+        throw new OpenApiMcpError("AUTH_PROFILE_INVALID", "Credential binding does not match the prepared call");
+    }
+    Object.freeze(data.scopes);
+    return Object.freeze(data);
+}

package/dist/runtime/digest.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue, Sha256 } from "./types.ts";
+/** Hash domain-separated canonical JSON using portable Web Crypto. */
+export declare function sha256(domain: string, value: JsonValue): Promise<Sha256>;
+/**
+ * Verify a base64url Ed25519 signature with a base64url SPKI public key.
+ * Malformed material is deliberately an ordinary verification failure.
+ */
+export declare function verifyEd25519(payload: Uint8Array | string, signature: Uint8Array | string, key: Uint8Array | string): Promise<boolean>;

package/dist/runtime/digest.js

@@ -0,0 +1,80 @@
+import { OpenApiMcpError } from "./errors.js";
+import { canonicalJson } from "./strict-json.js";
+const base64urlAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function decodeBase64Url(value) {
+    if (!/^[A-Za-z0-9_-]*$/.test(value) || value.length % 4 === 1)
+        return null;
+    let accumulator = 0;
+    let bits = 0;
+    const bytes = [];
+    for (const character of value) {
+        const digit = base64urlAlphabet.indexOf(character);
+        if (digit < 0)
+            return null;
+        accumulator = (accumulator << 6) | digit;
+        bits += 6;
+        while (bits >= 8) {
+            bits -= 8;
+            bytes.push((accumulator >> bits) & 0xff);
+        }
+    }
+    if (bits > 0 && (accumulator & ((1 << bits) - 1)) !== 0)
+        return null;
+    const decoded = Uint8Array.from(bytes);
+    return encodeBase64Url(decoded) === value ? decoded : null;
+}
+function encodeBase64Url(bytes) {
+    let accumulator = 0;
+    let bits = 0;
+    let encoded = "";
+    for (const byte of bytes) {
+        accumulator = (accumulator << 8) | byte;
+        bits += 8;
+        while (bits >= 6) {
+            bits -= 6;
+            encoded += base64urlAlphabet[(accumulator >> bits) & 0x3f];
+        }
+    }
+    if (bits > 0)
+        encoded += base64urlAlphabet[(accumulator << (6 - bits)) & 0x3f];
+    return encoded;
+}
+function bytesFor(value) {
+    return typeof value === "string"
+        ? decodeBase64Url(value)
+        : new Uint8Array(value);
+}
+function toArrayBuffer(bytes) {
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return copy.buffer;
+}
+/** Hash domain-separated canonical JSON using portable Web Crypto. */
+export async function sha256(domain, value) {
+    if (domain.length === 0 || domain.includes("\0")) {
+        throw new OpenApiMcpError("MANIFEST_INVALID", "Digest domain must be non-empty and NUL-free");
+    }
+    const bytes = new TextEncoder().encode(`${domain}\0${canonicalJson(value)}`);
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", toArrayBuffer(bytes));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * Verify a base64url Ed25519 signature with a base64url SPKI public key.
+ * Malformed material is deliberately an ordinary verification failure.
+ */
+export async function verifyEd25519(payload, signature, key) {
+    try {
+        const signatureBytes = bytesFor(signature);
+        const keyBytes = bytesFor(key);
+        if (signatureBytes === null || keyBytes === null)
+            return false;
+        const payloadBytes = typeof payload === "string"
+            ? new TextEncoder().encode(payload)
+            : new Uint8Array(payload);
+        const publicKey = await globalThis.crypto.subtle.importKey("spki", toArrayBuffer(keyBytes), { name: "Ed25519" }, false, ["verify"]);
+        return await globalThis.crypto.subtle.verify("Ed25519", publicKey, toArrayBuffer(signatureBytes), toArrayBuffer(payloadBytes));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime/errors.d.ts

@@ -0,0 +1,14 @@
+import type { OpenApiValue } from "./types.ts";
+export type OpenApiMcpErrorCode = "ARTIFACT_FORMAT_UNSUPPORTED" | "MANIFEST_INVALID" | "MANIFEST_SIGNATURE_INVALID" | "MANIFEST_ROLLBACK_REJECTED" | "MANIFEST_GENERATION_CONFLICT" | "RECORD_NOT_ADMITTED" | "RECORD_DIGEST_MISMATCH" | "OPERATION_REF_INVALID" | "OPERATION_NOT_FOUND" | "SCHEMA_RESOLUTION_LIMIT" | "INPUT_INVALID" | "TOOL_SAFETY_MISMATCH" | "ACTION_CONFIRMATION_REQUIRED" | "ACTION_DENIED" | "ACTION_CONFIRMATION_EXPIRED" | "AUTH_PROFILE_INVALID" | "AUTH_REQUIRED" | "DESTINATION_DENIED" | "RESPONSE_LIMIT_EXCEEDED" | "PAGINATION_LIMIT_EXCEEDED" | "UPSTREAM_ERROR" | "UPSTREAM_OUTCOME_UNKNOWN";
+/**
+ * A stable, model-safe error. Callers must provide only pre-redacted details.
+ */
+export declare class OpenApiMcpError extends Error {
+    readonly code: OpenApiMcpErrorCode;
+    readonly retryable: boolean;
+    readonly details: Readonly<Record<string, OpenApiValue>>;
+    constructor(code: OpenApiMcpErrorCode, message?: string, options?: {
+        retryable?: boolean;
+        details?: Readonly<Record<string, OpenApiValue>>;
+    });
+}

package/dist/runtime/errors.js

@@ -0,0 +1,15 @@
+/**
+ * A stable, model-safe error. Callers must provide only pre-redacted details.
+ */
+export class OpenApiMcpError extends Error {
+    code;
+    retryable;
+    details;
+    constructor(code, message = code, options = {}) {
+        super(message);
+        this.name = "OpenApiMcpError";
+        this.code = code;
+        this.retryable = options.retryable ?? false;
+        this.details = options.details ?? {};
+    }
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,20 @@
+export type { ActionDispatchPermit } from "./action-permit.ts";
+export { classifyOperation, type OperationClassification, } from "./classify.ts";
+export { digestCredentialAuthorizationBinding, snapshotCredentialAuthorizationBinding, } from "./credential-binding.ts";
+export { sha256, verifyEd25519 } from "./digest.ts";
+export type { OpenApiMcpErrorCode } from "./errors.ts";
+export { OpenApiMcpError } from "./errors.ts";
+export type { AdmittedManifest, ManifestTrust, TrustedManifestKey, } from "./manifest.ts";
+export { admitManifest } from "./manifest.ts";
+export { createPreparedCall, digestBytes, digestPreparedCall, type PreparedCallInput, verifyPreparedCall, } from "./prepared-call.ts";
+export { decodeOperationRef, encodeOperationRef, parseTypedRecordId, } from "./references.ts";
+export { createOpenApiRuntime, type OpenApiRuntimeOptions } from "./runtime.ts";
+export { resolveSchemaClosure } from "./schema-resolver.ts";
+export { type SerializedArguments, serializeArguments } from "./serialize.ts";
+export { CATALOG_STORE_PUBLIC_MESSAGES, createD1CatalogStore, type D1CatalogDatabase, type D1CatalogPreparedStatement, type D1CatalogResult, type D1CatalogValue, } from "./store.ts";
+export type { StrictJsonLimits } from "./strict-json.ts";
+export { canonicalJson, DEFAULT_STRICT_JSON_LIMITS, parseJsonStrict, } from "./strict-json.ts";
+export type { ActionAuthorizer, ActionCardinality, ActionKind, AuthorizationContext, AuthorizationDecision, AuthorizationId, AuthorizedActionDecision, AuthorizedTransport, AuthProfile, CallOutcome, CandidateRef, CatalogId, CatalogStore, Credential, CredentialAuthorizationBinding, CredentialBindingResolver, CredentialProfileBinding, CredentialProvider, CredentialResolution, CredentialSlot, CredentialSlotContext, CredentialSnapshot, DestinationPolicy, GenerationState, GenerationStore, GenerationTransition, HttpMethod, JsonObject, JsonValue, LocalAuthProfile, ManifestEnvelope, ManifestSignature, OpenApiArguments, OpenApiRuntime, OpenApiValue, OperationRecordV4, OperationRef, OperationRefPayload, PaginationTokenCodec, PaginationTokenState, PreparedCall, PreparedDispatch, PrepareInput, ReleaseId, ReleaseManifestV4, RollbackAuthorization, SafeApprovalPresentation, SchemaRecordV4, SearchInput, SearchQuery, SearchResult, SearchResultItem, SearchWarning, SecretStore, Sha256, StoredRecord, TypedOperationId, TypedRecordId, TypedSchemaId, VerifiedActionRequestState, } from "./types.ts";
+export { verifyStoredRecord } from "./verify-record.ts";
+export type { RuntimeLimits } from "./versions.ts";
+export { ARTIFACT_FORMAT_VERSION, DEFAULT_RUNTIME_LIMITS, MAX_SEARCH_QUERY_BYTES, PREPARED_CALL_VERSION, RUNTIME_CONTRACT_VERSION, resolveRuntimeLimits, } from "./versions.ts";

package/dist/runtime/index.js

@@ -0,0 +1,14 @@
+export { classifyOperation, } from "./classify.js";
+export { digestCredentialAuthorizationBinding, snapshotCredentialAuthorizationBinding, } from "./credential-binding.js";
+export { sha256, verifyEd25519 } from "./digest.js";
+export { OpenApiMcpError } from "./errors.js";
+export { admitManifest } from "./manifest.js";
+export { createPreparedCall, digestBytes, digestPreparedCall, verifyPreparedCall, } from "./prepared-call.js";
+export { decodeOperationRef, encodeOperationRef, parseTypedRecordId, } from "./references.js";
+export { createOpenApiRuntime } from "./runtime.js";
+export { resolveSchemaClosure } from "./schema-resolver.js";
+export { serializeArguments } from "./serialize.js";
+export { CATALOG_STORE_PUBLIC_MESSAGES, createD1CatalogStore, } from "./store.js";
+export { canonicalJson, DEFAULT_STRICT_JSON_LIMITS, parseJsonStrict, } from "./strict-json.js";
+export { verifyStoredRecord } from "./verify-record.js";
+export { ARTIFACT_FORMAT_VERSION, DEFAULT_RUNTIME_LIMITS, MAX_SEARCH_QUERY_BYTES, PREPARED_CALL_VERSION, RUNTIME_CONTRACT_VERSION, resolveRuntimeLimits, } from "./versions.js";

package/dist/runtime/manifest.d.ts

@@ -0,0 +1,33 @@
+import type { GenerationState, GenerationStore, ManifestEnvelope, ReleaseManifestV4, RollbackAuthorization, Sha256 } from "./types.ts";
+import { type RuntimeLimits } from "./versions.ts";
+export interface TrustedManifestKey {
+    issuer: string;
+    keyId: string;
+    /** Base64url-encoded Ed25519 SPKI public key. */
+    publicKey: string;
+}
+export interface ManifestTrust {
+    releaseKeys: readonly TrustedManifestKey[];
+    rollbackKeys: readonly TrustedManifestKey[];
+    now?: () => Date;
+}
+export interface AdmittedManifest {
+    readonly manifest: ReleaseManifestV4;
+    readonly manifestDigest: Sha256;
+}
+export interface AuthenticatedManifest extends AdmittedManifest {
+    readonly rollback: RollbackAuthorization | undefined;
+    readonly rollbackMalformed: boolean;
+}
+/** Authenticate a v4/v5 manifest without reading or mutating generation state. */
+export declare function authenticateManifest(envelope: ManifestEnvelope, trust: ManifestTrust, limitOverrides?: Partial<RuntimeLimits>): Promise<AuthenticatedManifest>;
+/** Atomically commit the generation transition for an authenticated manifest. */
+/**
+ * Commit only the generation decision made against `state`.
+ * A null result is a CAS miss; callers must reread and re-plan rather than
+ * reinterpreting this manifest under a newer generation policy.
+ */
+export declare function commitAuthenticatedManifestAtState(authenticated: AuthenticatedManifest, trust: ManifestTrust, generations: GenerationStore, state: GenerationState | null): Promise<AdmittedManifest | null>;
+export declare function admitAuthenticatedManifest(authenticated: AuthenticatedManifest, trust: ManifestTrust, generations: GenerationStore): Promise<AdmittedManifest>;
+/** Verify a v4/v5 manifest and atomically admit its generation transition. */
+export declare function admitManifest(envelope: ManifestEnvelope, trust: ManifestTrust, generations: GenerationStore, limitOverrides?: Partial<RuntimeLimits>): Promise<AdmittedManifest>;