better-supabase 0.7.0 → 0.8.0

package/dist/spec/index.d.ts

@@ -0,0 +1,134 @@
+import { C as ModelWorkflow, D as SecurityRequirement, E as ResourceOperation, S as ModelWebhook, T as OperationSource, _ as ModelSecurityProfileRequirement, a as ModelBody, b as ModelStep, c as ModelContent, d as ModelMessage, f as ModelMessageTrait, g as ModelResponseOrRef, h as ModelResponse, i as JsonSchema, l as ModelExample, m as ModelParameter, n as HttpMethod, o as ModelChannel, p as ModelOperation, r as JsonObject, s as ModelChannelOperation, t as ApiModel, u as ModelInfo, v as ModelSecurityScheme, w as OAuthFlow, x as ModelTag, y as ModelServer } from "../model-OgBxvk3N.js";
+import { a as FormatVersion, c as SpecDiagnostic, d as defineDocumentFormat, i as DocumentOf, l as VersionOf, n as DiagnosticSeverity, o as LowerContext, r as DocumentFormat, s as RenderedOf, t as AnyDocumentFormat, u as VersionStatus } from "../format-DTXdu8ya.js";
+import { a as ResourcePlan, r as ResourceDescription } from "../resource--vTrBe6I.js";
+import { C as ApiSource, D as OperationIdContext, E as EnrichHooks, M as DEFAULT_ERRORS, N as PROBLEM_SCHEMA, O as ResourceInput, P as SecurityPreset, S as ApiOptions, T as ComponentNameContext, a as OverlayEngine, c as defineApi, i as OpenApiRenderResult, j as CustomSecurity, k as RouteSpec, n as DefineApiOptions, o as RenderOptions, r as OpenApiRenderOptions, s as RenderResult, t as Api, w as BuiltModel } from "../api-Dnf2q-Ht.js";
+//#region src/spec/build.d.ts
+/**
+ * Builds the version-neutral API model once per metadata, plugin list and
+ * options object. Formats lower it to each version; `defineApi` wraps it.
+ */
+export declare function buildApiModel<Ref = string>(source: ApiSource, options: ApiOptions<Ref>): BuiltModel;
+//#endregion
+//#region src/spec/merge.d.ts
+/** Escapes a key for a JSON Pointer (RFC 6901). */
+export declare function pointerToken(key: string): string;
+/**
+ * Deep merge: objects merge key by key, anything else (arrays included)
+ * is replaced by the patch. `onConflict` hears each replaced leaf whose value
+ * differs, with its JSON Pointer. Neither input is changed.
+ */
+export declare function mergeJson<T>(base: T, patch: unknown, onConflict?: (pointer: string) => void, pointer?: string): T;
+//#endregion
+//#region src/spec/serialize.d.ts
+interface SerializeOptions {
+  /** Spaces per level. Defaults to 2; 0 writes one line. */
+  readonly indent?: number;
+  /** Sorts object keys by UTF-16 code unit. Off by default, so generated order stays. */
+  readonly sortKeys?: boolean;
+}
+/**
+ * The document as JSON text: the same document always gives the same
+ * bytes, ending in a newline. Throws on `NaN` and infinities, which JSON
+ * cannot hold.
+ */
+export declare function serializeDocument(document: unknown, options?: SerializeOptions): string;
+interface SpecResponseOptions {
+  /** Defaults to `public, no-cache`: clients revalidate with the ETag. */
+  readonly cacheControl?: string;
+  /** Defaults to `application/json`. */
+  readonly contentType?: string;
+  readonly indent?: number;
+}
+/**
+ * A `Response` that serves a rendered document with a strong ETag (the
+ * SHA-256 of the body). A matching `If-None-Match` gets `304`; `HEAD` gets
+ * the headers only; other methods than `GET` and `HEAD` get `405`. The body
+ * and ETag are computed once per document object.
+ */
+export declare function specResponse(document: object, request?: Request, options?: SpecResponseOptions): Promise<Response>;
+//#endregion
+//#region src/spec/reference.d.ts
+/** A docs UI that renders an OpenAPI document. */
+type SpecUi = "scalar" | "swagger" | "redoc" | "elements" | "rapidoc";
+export declare const SPEC_UIS: readonly SpecUi[];
+/** The package and version each UI loads from the CDN by default. */
+export declare const SPEC_UI_PACKAGES: Readonly<Record<SpecUi, {
+  readonly name: string;
+  readonly version: string;
+}>>;
+/** Files the app serves itself, for self-hosted mode. */
+interface SpecUiAssets {
+  readonly scripts: readonly string[];
+  readonly styles?: readonly string[];
+}
+interface SpecReferenceOptions {
+  /** The URL of the document, usually the `specResponse` route. */
+  readonly specUrl: string;
+  /** Defaults to `scalar`. */
+  readonly ui?: SpecUi;
+  /** The page title. Defaults to `API reference`. */
+  readonly title?: string;
+  /**
+   * Where the UI loads from. Defaults to jsDelivr at the versions in
+   * `SPEC_UI_PACKAGES`, with Subresource Integrity. A string is another CDN
+   * with the same package paths (no integrity); `{ scripts, styles }` lists
+   * files the app hosts itself.
+   */
+  readonly assets?: string | SpecUiAssets;
+  /** Set on every script and style tag, for a Content Security Policy with nonces. */
+  readonly nonce?: string;
+  /** UI options: Scalar's configuration, Swagger UI's and Redoc's options, or attributes of the Elements and RapiDoc components. */
+  readonly config?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The HTML page of a docs UI for a spec document. Scalar is the default;
+ * Swagger UI, Redoc, Stoplight Elements and RapiDoc load the same way.
+ *
+ * ```ts
+ * const html = specReferenceHtml({ specUrl: "/api/openapi.json", ui: "redoc" });
+ * ```
+ */
+export declare function specReferenceHtml(options: SpecReferenceOptions): string;
+interface SpecReferenceResponseOptions extends SpecReferenceOptions {
+  /**
+   * Sends a Content-Security-Policy that allows the nonce and the asset
+   * origins. Generates a nonce when `nonce` is unset.
+   */
+  readonly csp?: boolean;
+  /** Defaults to `no-cache`. */
+  readonly cacheControl?: string;
+}
+/** The policy `specReference` sends with `csp: true`. */
+export declare function specReferenceCsp(options: Pick<SpecReferenceOptions, "ui" | "assets"> & {
+  readonly nonce: string;
+}): string;
+/**
+ * A `Response` with the docs UI page for a spec document. Pair it with
+ * `specResponse` on the document's route. `GET` and `HEAD` only.
+ *
+ * ```ts
+ * export const GET = (request: Request) =>
+ *   specReference({ specUrl: "/api/openapi.json", csp: true }, request);
+ * ```
+ */
+export declare function specReference(options: SpecReferenceResponseOptions, request?: Request): Response;
+interface ScalarPresetOptions {
+  /** A public OAuth client Scalar's "try it" uses for the authorization code flow. */
+  readonly clientId?: string;
+  readonly redirectUri?: string;
+  /** PKCE for the authorization code flow. Defaults to `SHA-256`. */
+  readonly pkce?: "SHA-256" | "plain" | "no";
+  /** Scopes Scalar selects by default. */
+  readonly defaultScopes?: readonly string[];
+  /** `x-scalar-environments`: variables Scalar offers per environment. */
+  readonly environments?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Adds Scalar's `x-scalar-*` extensions to an OpenAPI document, so the
+ * reference can sign in through the OAuth flows the document declares.
+ * Returns a copy. Use it in a `transform`:
+ * `transform: ({ document }) => scalarPreset(document, { clientId })`.
+ */
+export declare function scalarPreset<D extends object>(document: D, options?: ScalarPresetOptions): D;
+//#endregion
+export { type AnyDocumentFormat, type Api, type ApiModel, type ApiOptions, type ApiSource, type BuiltModel, type ComponentNameContext, type CustomSecurity, DEFAULT_ERRORS, type DefineApiOptions, type DiagnosticSeverity, type DocumentFormat, type DocumentOf, type EnrichHooks, type FormatVersion, type HttpMethod, type JsonObject, type JsonSchema, type LowerContext, type ModelBody, type ModelChannel, type ModelChannelOperation, type ModelContent, type ModelExample, type ModelInfo, type ModelMessage, type ModelMessageTrait, type ModelOperation, type ModelParameter, type ModelResponse, type ModelResponseOrRef, type ModelSecurityProfileRequirement, type ModelSecurityScheme, type ModelServer, type ModelStep, type ModelTag, type ModelWebhook, type ModelWorkflow, type OAuthFlow, type OpenApiRenderOptions, type OpenApiRenderResult, type OperationIdContext, type OperationSource, type OverlayEngine, PROBLEM_SCHEMA, type RenderOptions, type RenderResult, type RenderedOf, type ResourceDescription, type ResourceInput, type ResourceOperation, type ResourcePlan, type RouteSpec, type ScalarPresetOptions, type SecurityPreset, type SecurityRequirement, type SerializeOptions, type SpecDiagnostic, type SpecReferenceOptions, type SpecReferenceResponseOptions, type SpecResponseOptions, type SpecUi, type SpecUiAssets, type VersionOf, type VersionStatus, defineApi, defineDocumentFormat };

package/dist/spec/index.js

@@ -0,0 +1,353 @@
+import { r as isPlainObject } from "../clone-dN9XOL1K.js";
+import { a as methodNotAllowed } from "../problem-CJvFeGu7.js";
+import { o as defineDocumentFormat, t as defineApi } from "../api-DtHFC037.js";
+import { c as mergeJson, l as pointerToken, n as DEFAULT_ERRORS, r as PROBLEM_SCHEMA, t as buildApiModel } from "../build-hPwk3_X5.js";
+//#region src/spec/serialize.ts
+function normalize(value, sortKeys, pointer) {
+	if (typeof value === "number" && !Number.isFinite(value)) throw new TypeError(`better-supabase/spec: ${String(value)} at "${pointer}" has no JSON form`);
+	if (Array.isArray(value)) return value.map((item, index) => normalize(item, sortKeys, `${pointer}/${index}`));
+	if (!isPlainObject(value)) return value;
+	const keys = Object.keys(value);
+	if (sortKeys) keys.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	const out = {};
+	for (const key of keys) {
+		const entry = value[key];
+		if (entry === void 0) continue;
+		out[key] = normalize(entry, sortKeys, `${pointer}/${key}`);
+	}
+	return out;
+}
+/**
+* The document as JSON text: the same document always gives the same
+* bytes, ending in a newline. Throws on `NaN` and infinities, which JSON
+* cannot hold.
+*/
+function serializeDocument(document, options = {}) {
+	const { indent = 2, sortKeys = false } = options;
+	return `${JSON.stringify(normalize(document, sortKeys, ""), null, indent)}\n`;
+}
+const encoded = /* @__PURE__ */ new WeakMap();
+function base64url(bytes) {
+	let binary = "";
+	for (const byte of new Uint8Array(bytes)) binary += String.fromCodePoint(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function encode(document, indent) {
+	let byIndent = encoded.get(document);
+	if (!byIndent) {
+		byIndent = /* @__PURE__ */ new Map();
+		encoded.set(document, byIndent);
+	}
+	const key = String(indent);
+	let hit = byIndent.get(key);
+	if (!hit) {
+		const body = serializeDocument(document, { indent });
+		hit = {
+			body,
+			etag: crypto.subtle.digest("SHA-256", new TextEncoder().encode(body)).then((digest) => `"${base64url(digest)}"`)
+		};
+		byIndent.set(key, hit);
+	}
+	return hit;
+}
+/** RFC 9110 section 13.1.2: weak comparison, so `W/` prefixes match too. */
+function matches(header, etag) {
+	return header.split(",").map((tag) => tag.trim().replace(/^W\//, "")).some((tag) => tag === "*" || tag === etag);
+}
+/**
+* A `Response` that serves a rendered document with a strong ETag (the
+* SHA-256 of the body). A matching `If-None-Match` gets `304`; `HEAD` gets
+* the headers only; other methods than `GET` and `HEAD` get `405`. The body
+* and ETag are computed once per document object.
+*/
+async function specResponse(document, request, options = {}) {
+	const { cacheControl = "public, no-cache", contentType = "application/json", indent = 2 } = options;
+	const method = request?.method.toUpperCase() ?? "GET";
+	if (method !== "GET" && method !== "HEAD") return methodNotAllowed(["GET", "HEAD"]);
+	const { body, etag } = encode(document, indent);
+	const tag = await etag;
+	const headers = {
+		"cache-control": cacheControl,
+		etag: tag
+	};
+	const ifNoneMatch = request?.headers.get("if-none-match");
+	if (ifNoneMatch && matches(ifNoneMatch, tag)) return new Response(null, {
+		status: 304,
+		headers
+	});
+	return new Response(method === "HEAD" ? null : body, {
+		status: 200,
+		headers: {
+			...headers,
+			"content-type": contentType
+		}
+	});
+}
+//#endregion
+//#region src/spec/reference.ts
+/** A plain object this module may change: callers pass a fresh copy. */
+const isRecord = (value) => isPlainObject(value);
+const SPEC_UIS = [
+	"scalar",
+	"swagger",
+	"redoc",
+	"elements",
+	"rapidoc"
+];
+/** The package and version each UI loads from the CDN by default. */
+const SPEC_UI_PACKAGES = {
+	scalar: {
+		name: "@scalar/api-reference",
+		version: "1.73.1"
+	},
+	swagger: {
+		name: "swagger-ui-dist",
+		version: "5.33.1"
+	},
+	redoc: {
+		name: "redoc",
+		version: "2.5.4"
+	},
+	elements: {
+		name: "@stoplight/elements",
+		version: "9.0.28"
+	},
+	rapidoc: {
+		name: "rapidoc",
+		version: "10.1.0"
+	}
+};
+const DEFAULT_CDN = "https://cdn.jsdelivr.net/npm";
+const PINNED = {
+	scalar: {
+		scripts: [{
+			path: "dist/browser/standalone.js",
+			integrity: "sha384-kYDGzV91Jnn3TbHINV3nt54riK2uMJDfN5Al8dAkz4FssELTBWbD8rgw32sTKfOi"
+		}],
+		styles: []
+	},
+	swagger: {
+		scripts: [{
+			path: "swagger-ui-bundle.js",
+			integrity: "sha384-ZPehFMQommnnuaZ4rpxgkgTT2DKFVp4hZC/7pLit+9Lek9T1YGSo23eHFbvNkXkw"
+		}],
+		styles: [{
+			path: "swagger-ui.css",
+			integrity: "sha384-Ov4/wv3j2bmct8cDc5X4ngJZohVPzEmc6uDPH8WeljUxO5vtoykvMEfbu9Vh6RaW"
+		}]
+	},
+	redoc: {
+		scripts: [{
+			path: "bundles/redoc.standalone.js",
+			integrity: "sha384-w447zOpYfw/1Tv/5AK9NfHTlQIqE3RVR6KY62jCyy9zNDgO64cMwGGP1Fj0zJVf5"
+		}],
+		styles: []
+	},
+	elements: {
+		scripts: [{
+			path: "web-components.min.js",
+			integrity: "sha384-enyjBaVmV00WFIo0D7AIVgtZ/4x0idVNWHotG8WUpvQo9HXgMSGAAW2YEOpiJTpP"
+		}],
+		styles: [{
+			path: "styles.min.css",
+			integrity: "sha384-iVQBHadsD+eV0M5+ubRCEVXrXEBj+BqcuwjUwPoVJc0Pb1fmrhYSAhL+BFProHdV"
+		}]
+	},
+	rapidoc: {
+		scripts: [{
+			path: "dist/rapidoc-min.js",
+			integrity: "sha384-HHR6HoZp1auZpg4HHlW1QQNBJOq2gLnEa05IBhNnkE64/gK72hd0kG+TJPmDN3ij"
+		}],
+		styles: []
+	}
+};
+function assetsOf(ui, assets) {
+	if (typeof assets === "object") return {
+		scripts: assets.scripts.map((url) => ({ url })),
+		styles: (assets.styles ?? []).map((url) => ({ url }))
+	};
+	const { name, version } = SPEC_UI_PACKAGES[ui];
+	const base = (assets ?? DEFAULT_CDN).replace(/\/+$/, "");
+	const pinned = assets === void 0;
+	const toAsset = (file) => ({
+		url: `${base}/${name}@${version}/${file.path}`,
+		...pinned ? { integrity: file.integrity } : {}
+	});
+	return {
+		scripts: PINNED[ui].scripts.map(toAsset),
+		styles: PINNED[ui].styles.map(toAsset)
+	};
+}
+const HTML_ESCAPES = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+/** Text safe inside an HTML attribute or element. */
+function escapeHtml(text) {
+	return text.replaceAll(/[&<>"']/g, (char) => HTML_ESCAPES[char] ?? char);
+}
+/** JSON safe inside an inline `<script>`: no `<\/script>`, `<!--` or line separators. */
+function scriptJson(value) {
+	return JSON.stringify(value).replaceAll("<", "\\u003c").replaceAll(">", "\\u003e").replaceAll("&", "\\u0026").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+function attributes(values) {
+	return Object.entries(values).filter(([, value]) => value !== void 0 && value !== false).map(([key, value]) => value === true ? ` ${escapeHtml(key)}` : ` ${escapeHtml(key)}="${escapeHtml(typeof value === "string" ? value : JSON.stringify(value))}"`).join("");
+}
+function body(ui, specUrl, config) {
+	switch (ui) {
+		case "scalar": return {
+			markup: "<div id=\"app\"></div>",
+			init: `Scalar.createApiReference("#app", ${scriptJson({
+				url: specUrl,
+				...config
+			})});`
+		};
+		case "swagger": return {
+			markup: "<div id=\"swagger-ui\"></div>",
+			init: `window.ui = SwaggerUIBundle(${scriptJson({
+				url: specUrl,
+				dom_id: "#swagger-ui",
+				...config
+			})});`
+		};
+		case "redoc": return {
+			markup: "<div id=\"redoc\"></div>",
+			init: `Redoc.init(${scriptJson(specUrl)}, ${scriptJson(config)}, document.getElementById("redoc"));`
+		};
+		case "elements": return { markup: `<elements-api${attributes({
+			apiDescriptionUrl: specUrl,
+			router: "hash",
+			layout: "sidebar",
+			...config
+		})}></elements-api>` };
+		case "rapidoc": return { markup: `<rapi-doc${attributes({
+			"spec-url": specUrl,
+			...config
+		})}></rapi-doc>` };
+		default: throw new TypeError(`Unknown docs UI "${String(ui)}"`);
+	}
+}
+/**
+* The HTML page of a docs UI for a spec document. Scalar is the default;
+* Swagger UI, Redoc, Stoplight Elements and RapiDoc load the same way.
+*
+* ```ts
+* const html = specReferenceHtml({ specUrl: "/api/openapi.json", ui: "redoc" });
+* ```
+*/
+function specReferenceHtml(options) {
+	const ui = options.ui ?? "scalar";
+	if (!SPEC_UIS.includes(ui)) throw new TypeError(`Unknown docs UI "${ui}". Use one of ${SPEC_UIS.join(", ")}.`);
+	const { scripts, styles } = assetsOf(ui, options.assets);
+	const nonce = options.nonce === void 0 ? "" : ` nonce="${escapeHtml(options.nonce)}"`;
+	const integrity = (asset) => asset.integrity === void 0 ? "" : ` integrity="${asset.integrity}" crossorigin="anonymous"`;
+	const { markup, init } = body(ui, options.specUrl, { ...options.config });
+	const module = ui === "rapidoc" ? " type=\"module\"" : "";
+	return [
+		"<!doctype html>",
+		"<html lang=\"en\">",
+		"<head>",
+		"<meta charset=\"utf-8\">",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
+		`<title>${escapeHtml(options.title ?? "API reference")}</title>`,
+		...styles.map((style) => `<link rel="stylesheet" href="${escapeHtml(style.url)}"${integrity(style)}${nonce}>`),
+		"</head>",
+		"<body>",
+		markup,
+		...scripts.map((script) => `<script${module} src="${escapeHtml(script.url)}"${integrity(script)}${nonce}><\/script>`),
+		...init === void 0 ? [] : [`<script${nonce}>${init}<\/script>`],
+		"</body>",
+		"</html>",
+		""
+	].join("\n");
+}
+function origins(ui, assets) {
+	const { scripts, styles } = assetsOf(ui, assets);
+	const found = /* @__PURE__ */ new Set();
+	for (const { url } of [...scripts, ...styles]) {
+		if (!/^https?:\/\//.test(url)) continue;
+		found.add(new URL(url).origin);
+	}
+	return [...found];
+}
+/** The policy `specReference` sends with `csp: true`. */
+function specReferenceCsp(options) {
+	const hosts = origins(options.ui ?? "scalar", options.assets).join(" ");
+	const from = (...sources) => [...sources, hosts].filter(Boolean).join(" ");
+	return [
+		"default-src 'none'",
+		`script-src ${from(`'nonce-${options.nonce}'`)}`,
+		`style-src ${from("'self'", "'unsafe-inline'")}`,
+		"img-src 'self' data: https:",
+		"font-src 'self' data: https:",
+		"connect-src 'self' https:",
+		"worker-src 'self' blob:",
+		"base-uri 'none'",
+		"form-action 'none'",
+		"frame-ancestors 'self'"
+	].join("; ");
+}
+/**
+* A `Response` with the docs UI page for a spec document. Pair it with
+* `specResponse` on the document's route. `GET` and `HEAD` only.
+*
+* ```ts
+* export const GET = (request: Request) =>
+*   specReference({ specUrl: "/api/openapi.json", csp: true }, request);
+* ```
+*/
+function specReference(options, request) {
+	const method = request?.method.toUpperCase() ?? "GET";
+	if (method !== "GET" && method !== "HEAD") return methodNotAllowed(["GET", "HEAD"]);
+	const nonce = options.nonce ?? (options.csp === true ? crypto.randomUUID().replaceAll("-", "") : void 0);
+	const html = specReferenceHtml({
+		...options,
+		...nonce === void 0 ? {} : { nonce }
+	});
+	const headers = {
+		"content-type": "text/html; charset=utf-8",
+		"cache-control": options.cacheControl ?? "no-cache"
+	};
+	if (options.csp === true && nonce !== void 0) headers["content-security-policy"] = specReferenceCsp({
+		nonce,
+		...options.ui === void 0 ? {} : { ui: options.ui },
+		...options.assets === void 0 ? {} : { assets: options.assets }
+	});
+	return new Response(method === "HEAD" ? null : html, {
+		status: 200,
+		headers
+	});
+}
+/**
+* Adds Scalar's `x-scalar-*` extensions to an OpenAPI document, so the
+* reference can sign in through the OAuth flows the document declares.
+* Returns a copy. Use it in a `transform`:
+* `transform: ({ document }) => scalarPreset(document, { clientId })`.
+*/
+function scalarPreset(document, options = {}) {
+	const copy = structuredClone(document);
+	const root = copy;
+	if (!isRecord(root)) return copy;
+	if (options.environments !== void 0) root["x-scalar-environments"] = options.environments;
+	const components = root["components"];
+	const schemes = isRecord(components) ? components["securitySchemes"] : void 0;
+	if (!isRecord(schemes)) return copy;
+	for (const scheme of Object.values(schemes)) {
+		if (!isRecord(scheme) || scheme["type"] !== "oauth2") continue;
+		const flows = scheme["flows"];
+		if (!isRecord(flows)) continue;
+		for (const [name, flow] of Object.entries(flows)) {
+			if (!isRecord(flow)) continue;
+			if (options.clientId !== void 0) flow["x-scalar-client-id"] = options.clientId;
+			if (options.redirectUri !== void 0) flow["x-scalar-redirect-uri"] = options.redirectUri;
+			if (options.defaultScopes !== void 0) flow["x-default-scopes"] = [...options.defaultScopes];
+			if (name === "authorizationCode") flow["x-usePkce"] = options.pkce ?? "SHA-256";
+		}
+	}
+	return copy;
+}
+//#endregion
+export { DEFAULT_ERRORS, PROBLEM_SCHEMA, SPEC_UIS, SPEC_UI_PACKAGES, buildApiModel, defineApi, defineDocumentFormat, mergeJson, pointerToken, scalarPreset, serializeDocument, specReference, specReferenceCsp, specReferenceHtml, specResponse };

package/dist/{spec-pins-C89s6DyW.d.ts → spec-pins-CwzDY25w.d.ts}

@@ -6,7 +6,24 @@
 declare const SPEC_PINS: {
   readonly otelSemconv: "1.37.0";
   readonly mcp: "2026-07-28";
-  readonly openapi: "3.1.1";
+  /** The default OpenAPI version `createOpenApi` emits. */
+  readonly openapi: "3.1.2";
+  readonly openapi30: "3.0.4";
+  readonly openapi31: "3.1.2";
+  readonly openapi32: "3.2.1";
+  /** `src/oas.md` on the `v3.3-dev` branch of OAI/OpenAPI-Specification. */
+  readonly openapi33Preview: "aa2f6c0";
+  /** OAI sig-security discussion #50, as of this date. */
+  readonly securityProfiles: "sig-security#50@2026-05-05";
+  readonly overlay10: "1.0.0";
+  readonly overlay11: "1.1.0";
+  readonly overlay12: "1.2.0";
+  readonly arazzo10: "1.0.1";
+  readonly arazzo11: "1.1.0";
+  readonly asyncapi30: "3.0.0";
+  readonly asyncapi31: "3.1.0";
+  /** OpenID AuthZEN Authorization API, the vocabulary of `Authorizer`. */
+  readonly authzen: "1.0";
   readonly cloudevents: "1.0.2";
   readonly standardWebhooks: "1.0.0";
   readonly sarif: "2.1.0";

package/dist/{spec-pins--j6mTok4.js → spec-pins-DsLfUH7l.js}

@@ -6,7 +6,20 @@
 const SPEC_PINS = {
 	otelSemconv: "1.37.0",
 	mcp: "2026-07-28",
-	openapi: "3.1.1",
+	openapi: "3.1.2",
+	openapi30: "3.0.4",
+	openapi31: "3.1.2",
+	openapi32: "3.2.1",
+	openapi33Preview: "aa2f6c0",
+	securityProfiles: "sig-security#50@2026-05-05",
+	overlay10: "1.0.0",
+	overlay11: "1.1.0",
+	overlay12: "1.2.0",
+	arazzo10: "1.0.1",
+	arazzo11: "1.1.0",
+	asyncapi30: "3.0.0",
+	asyncapi31: "3.1.0",
+	authzen: "1.0",
 	cloudevents: "1.0.2",
 	standardWebhooks: "1.0.0",
 	sarif: "2.1.0",