@lostgradient/weft 0.2.0

package/dist/server/mcp-discovery.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Generator for Weft's `/.well-known/mcp.json` MCP discovery document.
+ *
+ * @module server/mcp-discovery
+ */
+import { MCP_PROTOCOL_VERSION, MCP_RESOURCE_TEMPLATES_LIST_METHOD, MCP_RESOURCES_LIST_METHOD, MCP_TOOLS_LIST_METHOD } from '../mcp/protocol.ts';
+import { VERSION } from '../version.ts';
+export { MCP_PROTOCOL_VERSION, MCP_RESOURCE_TEMPLATES_LIST_METHOD, MCP_RESOURCES_LIST_METHOD, MCP_TOOLS_LIST_METHOD, };
+/** Root-stable discovery document path (RFC 9264 / well-known convention). */
+export declare const MCP_DISCOVERY_PATH = "/.well-known/mcp.json";
+/**
+ * Canonical, root-relative MCP streamable-HTTP path. Runtime routing matches
+ * this form (after the front door strips the `/api` prefix). The discovery
+ * document advertises the external `/api`-prefixed URL via `externalApiPath`.
+ */
+export declare const MCP_STREAMABLE_HTTP_PATH = "/mcp";
+export declare const MCP_STREAMABLE_HTTP_METHODS: readonly ["POST", "GET", "DELETE"];
+export declare const MCP_STDIO_COMMAND = "weft-mcp";
+export type McpDiscoveryOptions = {
+    /** Absolute server origin, e.g. `https://api.example.com`. */
+    readonly origin: string;
+};
+type StreamableHttpTransport = {
+    readonly url: string;
+    readonly methods: typeof MCP_STREAMABLE_HTTP_METHODS;
+    readonly sessionHeader: 'Mcp-Session-Id';
+    readonly protocolVersionHeader: 'Mcp-Protocol-Version';
+};
+type StdioTransport = {
+    readonly command: typeof MCP_STDIO_COMMAND;
+};
+export type McpDiscoveryDocument = {
+    readonly schemaVersion: 1;
+    readonly protocol: 'model-context-protocol';
+    readonly protocolVersion: typeof MCP_PROTOCOL_VERSION;
+    readonly serverInfo: {
+        readonly name: 'weft';
+        readonly version: typeof VERSION;
+    };
+    readonly transports: {
+        readonly streamableHttp: StreamableHttpTransport;
+        readonly stdio: StdioTransport;
+    };
+    readonly discovery: {
+        readonly openRpc: string;
+        readonly tools: {
+            readonly method: typeof MCP_TOOLS_LIST_METHOD;
+            readonly canonical: true;
+        };
+        readonly resources: {
+            readonly listMethod: typeof MCP_RESOURCES_LIST_METHOD;
+            readonly templatesMethod: typeof MCP_RESOURCE_TEMPLATES_LIST_METHOD;
+        };
+    };
+};
+/** Generate the minimal MCP discovery document for build-time consumers. */
+export declare function generateMcpDiscovery(options: McpDiscoveryOptions): McpDiscoveryDocument;

package/dist/server/mcp-discovery.js

@@ -0,0 +1,50 @@
+import {
+  MCP_PROTOCOL_VERSION,
+  MCP_RESOURCE_TEMPLATES_LIST_METHOD,
+  MCP_RESOURCES_LIST_METHOD,
+  MCP_TOOLS_LIST_METHOD
+} from "../mcp/protocol.js";
+import { VERSION } from "../version.js";
+import { externalApiPath } from "./route-model.js";
+
+export {
+  MCP_PROTOCOL_VERSION,
+  MCP_RESOURCE_TEMPLATES_LIST_METHOD,
+  MCP_RESOURCES_LIST_METHOD,
+  MCP_TOOLS_LIST_METHOD
+};
+export const MCP_DISCOVERY_PATH = "/.well-known/mcp.json", MCP_STREAMABLE_HTTP_PATH = "/mcp", MCP_STREAMABLE_HTTP_METHODS = ["POST", "GET", "DELETE"], MCP_STDIO_COMMAND = "weft-mcp";
+export function generateMcpDiscovery(options) {
+  const { origin } = options;
+  return {
+    schemaVersion: 1,
+    protocol: "model-context-protocol",
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    serverInfo: {
+      name: "weft",
+      version: VERSION
+    },
+    transports: {
+      streamableHttp: {
+        url: `${origin}${externalApiPath(MCP_STREAMABLE_HTTP_PATH)}`,
+        methods: MCP_STREAMABLE_HTTP_METHODS,
+        sessionHeader: "Mcp-Session-Id",
+        protocolVersionHeader: "Mcp-Protocol-Version"
+      },
+      stdio: {
+        command: MCP_STDIO_COMMAND
+      }
+    },
+    discovery: {
+      openRpc: `${origin}/openrpc.json`,
+      tools: {
+        method: MCP_TOOLS_LIST_METHOD,
+        canonical: !0
+      },
+      resources: {
+        listMethod: MCP_RESOURCES_LIST_METHOD,
+        templatesMethod: MCP_RESOURCE_TEMPLATES_LIST_METHOD
+      }
+    }
+  };
+}

package/dist/server/openapi-canonical-json.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical JSON utilities for OpenAPI schema deduplication.
+ *
+ * @module server/openapi-canonical-json
+ */
+/**
+ * Produce a stable JSON string with object keys sorted recursively and array
+ * order preserved.
+ */
+export declare function canonicalJson(value: unknown): string;

package/dist/server/openapi-canonical-json.js

@@ -0,0 +1,13 @@
+export function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map(sortKeys);
+  const sorted = {};
+  for (const [key, entry] of Object.entries(value).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0))
+    sorted[key] = sortKeys(entry);
+  return sorted;
+}

package/dist/server/openapi-error-responses.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenAPI response helpers for catalogued operation faults.
+ *
+ * @module server/openapi-error-responses
+ */
+import type { ErasedOperation } from './operation-catalog.ts';
+/**
+ * Shared JSON error schema emitted as `#/components/schemas/Error`.
+ */
+export declare const ERROR_SCHEMA: Record<string, unknown>;
+/**
+ * Build OpenAPI error responses for an operation's declared producible faults
+ * plus the universal pipeline fault defaults.
+ */
+export declare function buildErrorResponses(operation: ErasedOperation): Record<string, unknown>;

package/dist/server/openapi-error-responses.js

@@ -0,0 +1,36 @@
+import { UNIVERSAL_FAULT_DEFAULTS } from "./operation-catalog/raise-fault.js";
+import { FAULT_CODE_TO_HTTP_STATUS } from "./operation-fault.js";
+export const ERROR_SCHEMA = {
+  type: "object",
+  required: ["code", "message"],
+  properties: {
+    code: { type: "string", description: "Machine-readable error code" },
+    message: { type: "string", description: "Human-readable error description" },
+    data: { description: "Additional fault-specific context" }
+  }
+};
+export function buildErrorResponses(operation) {
+  const codes = new Set([
+    ...UNIVERSAL_FAULT_DEFAULTS,
+    ...operation.producibleFaults ?? []
+  ]), codesByStatus = new Map;
+  for (const code of codes) {
+    const status = String(FAULT_CODE_TO_HTTP_STATUS[code]), existingCodes = codesByStatus.get(status);
+    if (existingCodes === void 0) {
+      codesByStatus.set(status, [code]);
+      continue;
+    }
+    existingCodes.push(code);
+  }
+  const responses = {};
+  for (const [status, statusCodes] of [...codesByStatus.entries()].toSorted(([left], [right]) => Number(left) - Number(right)))
+    responses[status] = {
+      description: statusCodes.toSorted().join(", "),
+      content: {
+        "application/json": {
+          schema: { $ref: "#/components/schemas/Error" }
+        }
+      }
+    };
+  return responses;
+}

package/dist/server/openapi-schemas.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JSON Schema extraction and component deduplication for OpenAPI documents.
+ *
+ * @module server/openapi-schemas
+ */
+import type { OperationRegistry } from './operation-catalog.ts';
+/** Schema slots owned by an operation definition. */
+export type OpenApiSchemaSlot = 'Input' | 'Output' | 'Event';
+export type OpenApiSchemaHelper = {
+    readonly components: Record<string, unknown>;
+    refFor(operationName: string, slot: OpenApiSchemaSlot): unknown;
+};
+/**
+ * Extract JSON Schemas for every discoverable operation and hoist duplicate
+ * schemas into `components.schemas` using canonical-JSON equality.
+ */
+export declare function extractComponentsSchemas(registry: OperationRegistry): OpenApiSchemaHelper;

package/dist/server/openapi-schemas.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { definitionSchemaToJsonSchema } from "../core/types/definition-schema-to-json.js";
+import { isDiscoverable } from "./discovery-filter.js";
+import { compareStrings, normalizeJsonObject } from "./json-schema-utilities.js";
+import { canonicalJson } from "./openapi-canonical-json.js";
+export function extractComponentsSchemas(registry) {
+  const byCanonical = new Map, operationSlotToCanonical = new Map;
+  for (const operation of registry.list()) {
+    if (!isDiscoverable(operation))
+      continue;
+    const slots = [
+      ["Input", operation.inputSchema],
+      ["Output", operation.outputSchema],
+      ["Event", operation.eventSchema]
+    ];
+    for (const [slot, schema] of slots) {
+      if (schema === void 0)
+        continue;
+      const jsonSchema = definitionSchemaToJsonSchema(schema, directionForSlot(slot)), canonical = canonicalJson(jsonSchema), owner = { operationName: operation.name, slot };
+      operationSlotToCanonical.set(ownerKey(owner.operationName, owner.slot), canonical);
+      const existing = byCanonical.get(canonical);
+      if (existing === void 0)
+        byCanonical.set(canonical, { schema: normalizeJsonObject(jsonSchema), owners: [owner] });
+      else
+        existing.owners.push(owner);
+    }
+  }
+  const components = {}, hoistedKeys = new Map, hoistCandidates = [...byCanonical.entries()].filter(([, entry]) => entry.owners.length >= 2).map(([canonical, entry]) => {
+    const firstOwner = [...entry.owners].toSorted(compareOwners)[0];
+    return {
+      canonical,
+      entry,
+      baseName: operationSlotToComponentName(firstOwner.operationName, firstOwner.slot)
+    };
+  }).toSorted((left, right) => compareStrings(left.baseName, right.baseName) || compareStrings(left.canonical, right.canonical));
+  for (const candidate of hoistCandidates) {
+    let componentName = candidate.baseName, suffix = 2;
+    while (componentName in components) {
+      componentName = `${candidate.baseName}_${suffix}`;
+      suffix += 1;
+    }
+    components[componentName] = candidate.entry.schema;
+    hoistedKeys.set(candidate.canonical, componentName);
+  }
+  return {
+    components,
+    refFor(operationName, slot) {
+      const canonical = operationSlotToCanonical.get(ownerKey(operationName, slot));
+      if (canonical === void 0)
+        return;
+      const componentName = hoistedKeys.get(canonical);
+      if (componentName !== void 0)
+        return { $ref: `#/components/schemas/${componentName}` };
+      return byCanonical.get(canonical)?.schema;
+    }
+  };
+}
+function ownerKey(operationName, slot) {
+  return `${operationName}:${slot}`;
+}
+function directionForSlot(slot) {
+  return slot === "Input" ? "input" : "output";
+}
+function compareOwners(left, right) {
+  return compareStrings(left.operationName, right.operationName) || compareStrings(left.slot, right.slot);
+}
+function operationSlotToComponentName(operationName, slot) {
+  return operationName.split(".").map((segment) => `${segment.charAt(0).toUpperCase()}${segment.slice(1)}`).join("") + slot;
+}

package/dist/server/openapi.d.ts

@@ -0,0 +1,48 @@
+/**
+ * OpenAPI 3.1 document generator driven from the operation and direct-route
+ * models.
+ *
+ * Produces a JSON-serializable OpenAPI document for the REST-ish HTTP
+ * surface. Both `handleRequest()` and `serve()` expose this at
+ * `GET /openapi.json`.
+ *
+ * @module server/openapi
+ */
+import { type DiscoveryInfo } from './discovery-info.ts';
+import { type OpenApiSchemaHelper } from './openapi-schemas.ts';
+import type { OperationRegistry } from './operation-catalog.ts';
+import type { UnknownRestBinding } from './rest-bindings.ts';
+export type OpenApiSecuritySchemeName = 'bearerAuth' | 'apiKeyAuth';
+/** Options for customizing the generated OpenAPI document. */
+export type OpenApiOptions = {
+    /** API title. Defaults to `'Weft Workflow Engine'`. */
+    title?: string;
+    /** API version. Defaults to the current Weft package version. */
+    version?: string;
+    /** Operator-supplied discovery metadata applied to the generated document. */
+    discoveryInfo?: DiscoveryInfo;
+    /** Operation registry used to emit operation-backed REST bindings. */
+    registry?: OperationRegistry;
+    /**
+     * REST bindings used to emit OpenAPI path items. Defaults to
+     * `createLiveRestBindings()`. Servers that override their binding set
+     * (e.g. for a restricted subset) should pass the same set here so
+     * `/openapi.json` matches the live HTTP surface.
+     */
+    restBindings?: ReadonlyArray<UnknownRestBinding>;
+    /** Server URL. When omitted, no `servers` array is included. */
+    serverUrl?: string;
+    /**
+     * Security schemes the live server actually supports. When omitted,
+     * emit both schemes for backward-compatible call sites.
+     */
+    supportedSchemes?: ReadonlySet<OpenApiSecuritySchemeName>;
+};
+/**
+ * Emit REST bindings into the OpenAPI paths map. Exported for tests;
+ * `generateOpenApiDocument` is the production entry point.
+ *
+ * @internal
+ */
+export declare function emitBindings(paths: Record<string, Record<string, unknown>>, tagSet: Set<string>, bindings?: ReadonlyArray<UnknownRestBinding>, registry?: OperationRegistry, schemaHelper?: OpenApiSchemaHelper): void;
+export declare function generateOpenApiDocument(options?: OpenApiOptions): Record<string, unknown>;

package/dist/server/openapi.js

@@ -0,0 +1,290 @@
+import { definitionSchemaToJsonSchema } from "../core/types/definition-schema-to-json.js";
+import { VERSION } from "../version.js";
+import { isDiscoverable } from "./discovery-filter.js";
+import { applyDiscoveryInfo } from "./discovery-info.js";
+import { asPlainObject, compareStrings } from "./json-schema-utilities.js";
+import { buildErrorResponses, ERROR_SCHEMA } from "./openapi-error-responses.js";
+import { extractComponentsSchemas } from "./openapi-schemas.js";
+import { createLiveOperationRegistry, createLiveRestBindings } from "./rest-bindings.js";
+import {
+  DIRECT_HTTP_ROUTES,
+  externalApiPath,
+  toOpenApiPath
+} from "./route-model.js";
+const DEFAULT_SCHEMA_HELPER = {
+  components: {},
+  refFor() {
+    return;
+  }
+}, JSON_MEDIA_TYPE = "application/json", OCTET_STREAM_MEDIA_TYPE = "application/octet-stream";
+function buildPathParameters(paramNames) {
+  return paramNames.map((name) => ({
+    name,
+    in: "path",
+    required: !0,
+    schema: { type: name === "step" ? "integer" : "string" }
+  }));
+}
+function inputSourceEntries(binding) {
+  return Object.entries(binding.inputSources).filter((entry) => entry[1] !== void 0).toSorted(([left], [right]) => compareStrings(left, right));
+}
+function inputJsonSchema(operation) {
+  return definitionSchemaToJsonSchema(operation.inputSchema);
+}
+function fieldSchema(operation, field) {
+  const properties = asPlainObject(inputJsonSchema(operation).properties);
+  return asPlainObject(properties[field]);
+}
+function requiredInputFields(operation) {
+  const required = inputJsonSchema(operation).required;
+  if (!Array.isArray(required))
+    return new Set;
+  return new Set(required.filter((entry) => typeof entry === "string"));
+}
+function binaryBodySchema() {
+  return { type: "string", format: "binary" };
+}
+function streamingResponseSchema(mediaType) {
+  if (mediaType === OCTET_STREAM_MEDIA_TYPE)
+    return binaryBodySchema();
+  return { type: "string" };
+}
+function directRouteContentSchema(content) {
+  if (content.schema === "string")
+    return { type: "string" };
+  return { type: "object" };
+}
+function outputCanBeNull(operation) {
+  try {
+    return operation.outputSchema.safeParse(null).success;
+  } catch {
+    return !1;
+  }
+}
+function buildBindingParameters(binding, operation) {
+  const parameters = buildPathParameters(binding.pathParamNames), seen = new Set(parameters.map((parameter) => `${String(parameter.in)}:${String(parameter.name)}`));
+  for (const [field, source] of inputSourceEntries(binding)) {
+    if (source.kind !== "query" && source.kind !== "header")
+      continue;
+    const parameter = {
+      name: source.kind === "query" ? source.queryParam : source.headerName,
+      in: source.kind,
+      required: !1,
+      schema: fieldSchema(operation, field)
+    }, key = `${parameter.in}:${parameter.name}`;
+    if (seen.has(key))
+      continue;
+    parameters.push(parameter);
+    seen.add(key);
+  }
+  return parameters;
+}
+function buildRequestBodyFromInputSources(binding, operation) {
+  const entries = inputSourceEntries(binding), bodyEntry = entries.find((entry) => entry[1].kind === "body");
+  if (bodyEntry !== void 0) {
+    const [field, source] = bodyEntry;
+    if (source.kind !== "body")
+      return;
+    const mediaType = source.mediaType ?? JSON_MEDIA_TYPE, schema = mediaType === OCTET_STREAM_MEDIA_TYPE ? binaryBodySchema() : fieldSchema(operation, field);
+    return {
+      required: !0,
+      content: { [mediaType]: { schema } }
+    };
+  }
+  const bodyFieldEntries = entries.filter((entry) => entry[1].kind === "body-field");
+  if (bodyFieldEntries.length === 0)
+    return;
+  const requiredFields = requiredInputFields(operation), properties = {}, required = [];
+  for (const [field, source] of bodyFieldEntries) {
+    properties[source.bodyField] = fieldSchema(operation, field);
+    if (requiredFields.has(field))
+      required.push(source.bodyField);
+  }
+  const schema = {
+    type: "object",
+    properties,
+    additionalProperties: operation.unknownKeyPolicy.http !== "reject"
+  };
+  if (required.length > 0)
+    schema.required = required.toSorted(compareStrings);
+  return {
+    required: !0,
+    content: { [JSON_MEDIA_TYPE]: { schema } }
+  };
+}
+function buildRequestBody(binding, operation, schemaHelper) {
+  const requestBody = buildRequestBodyFromInputSources(binding, operation);
+  if (requestBody !== void 0)
+    return requestBody;
+  if (inputSourceEntries(binding).length > 0)
+    return;
+  if (binding.method !== "POST" && binding.method !== "PUT" && binding.method !== "PATCH")
+    return;
+  return {
+    content: {
+      [JSON_MEDIA_TYPE]: {
+        schema: schemaHelper.refFor(operation.name, "Input") ?? { type: "object" }
+      }
+    }
+  };
+}
+function buildSuccessResponse(binding, operation, schemaHelper) {
+  const success = binding.success;
+  if (success.kind === "empty")
+    return {
+      [String(success.status)]: {
+        description: "No content"
+      }
+    };
+  if (success.kind === "streaming") {
+    const responses = {
+      "200": {
+        description: "Streaming response",
+        content: {
+          [success.mediaType]: {
+            schema: streamingResponseSchema(success.mediaType)
+          }
+        }
+      }
+    };
+    if (success.mediaType === OCTET_STREAM_MEDIA_TYPE && outputCanBeNull(operation))
+      responses["404"] = { description: "Storage key not found" };
+    return responses;
+  }
+  return {
+    [String(success.status)]: {
+      description: "Successful response",
+      content: {
+        [JSON_MEDIA_TYPE]: {
+          schema: schemaHelper.refFor(operation.name, "Output") ?? { type: "object" }
+        }
+      }
+    }
+  };
+}
+export function emitBindings(paths, tagSet, bindings = createLiveRestBindings(), registry = createLiveOperationRegistry(), schemaHelper = DEFAULT_SCHEMA_HELPER) {
+  for (const binding of bindings)
+    tryRegisterBinding(paths, tagSet, binding, registry, schemaHelper);
+}
+function tryRegisterBinding(paths, tagSet, binding, registry, schemaHelper) {
+  const operation = registry.get(binding.operationName);
+  if (operation === void 0)
+    return;
+  if (!isDiscoverable(operation))
+    return;
+  const openApiPath = externalApiPath(toOpenApiPath(binding.path));
+  if (!paths[openApiPath])
+    paths[openApiPath] = {};
+  paths[openApiPath][binding.method.toLowerCase()] = buildBindingEntry(binding, operation, schemaHelper);
+  for (const tag of operation.tags)
+    tagSet.add(tag);
+}
+function buildBindingEntry(binding, operation, schemaHelper) {
+  const parameters = buildBindingParameters(binding, operation), successResponse = buildSuccessResponse(binding, operation, schemaHelper), entry = {
+    summary: operation.summary,
+    operationId: operation.name,
+    tags: operation.tags,
+    responses: {
+      ...successResponse,
+      ...buildErrorResponses(operation)
+    }
+  };
+  if (operation.description !== void 0)
+    entry.description = operation.description;
+  if (parameters.length > 0)
+    entry.parameters = parameters;
+  const requestBody = buildRequestBody(binding, operation, schemaHelper);
+  if (requestBody !== void 0)
+    entry.requestBody = requestBody;
+  return entry;
+}
+function buildDirectRouteResponses(route) {
+  const responses = {};
+  for (const routeResponse of route.responses) {
+    const response = {
+      description: routeResponse.description
+    };
+    if (routeResponse.content !== void 0) {
+      const content = {};
+      for (const contentVariant of routeResponse.content)
+        content[contentVariant.mediaType] = {
+          schema: directRouteContentSchema(contentVariant)
+        };
+      response.content = content;
+    }
+    responses[String(routeResponse.status)] = response;
+  }
+  return responses;
+}
+function buildDirectRouteSecurity(route) {
+  if (route.access === "public")
+    return [];
+  return;
+}
+function emitDirectRoutes(paths, tagSet) {
+  for (const route of DIRECT_HTTP_ROUTES) {
+    const openApiPath = toOpenApiPath(route.path);
+    if (!paths[openApiPath])
+      paths[openApiPath] = {};
+    const parameters = buildPathParameters(route.paramNames), entry = {
+      summary: route.summary,
+      operationId: route.handler,
+      tags: route.tags,
+      responses: buildDirectRouteResponses(route)
+    }, security = buildDirectRouteSecurity(route);
+    if (security !== void 0)
+      entry.security = security;
+    if (parameters.length > 0)
+      entry.parameters = parameters;
+    paths[openApiPath][route.method.toLowerCase()] = entry;
+    for (const tag of route.tags)
+      tagSet.add(tag);
+  }
+}
+export function generateOpenApiDocument(options) {
+  const title = options?.title ?? "Weft Workflow Engine", version = options?.version ?? VERSION, infoBlock = applyDiscoveryInfo({ title, version }, options?.discoveryInfo), registry = options?.registry ?? createLiveOperationRegistry(), schemaHelper = extractComponentsSchemas(registry), { paths, tags } = buildOpenApiPaths(options, registry, schemaHelper), { security, securitySchemes } = buildSecurityBlock(options?.supportedSchemes), document = {
+    openapi: "3.1.0",
+    info: infoBlock,
+    paths,
+    tags,
+    security,
+    components: {
+      schemas: {
+        ...schemaHelper.components,
+        Error: ERROR_SCHEMA
+      },
+      securitySchemes
+    }
+  };
+  applyOpenApiExtras(document, options);
+  return document;
+}
+function buildOpenApiPaths(options, registry, schemaHelper) {
+  const paths = {}, tagSet = new Set;
+  emitBindings(paths, tagSet, options?.restBindings, registry, schemaHelper);
+  emitDirectRoutes(paths, tagSet);
+  const tags = [...tagSet].toSorted().map((name) => ({ name }));
+  return { paths, tags };
+}
+const SECURITY_SCHEME_DEFINITIONS = {
+  bearerAuth: {
+    type: "http",
+    scheme: "bearer",
+    bearerFormat: "JWT"
+  },
+  apiKeyAuth: {
+    type: "apiKey",
+    in: "header",
+    name: "x-api-key"
+  }
+};
+function buildSecurityBlock(supportedSchemes) {
+  const schemes = supportedSchemes ?? new Set(["bearerAuth", "apiKeyAuth"]), security = [...schemes].map((schemeName) => ({ [schemeName]: [] })), securitySchemes = Object.fromEntries([...schemes].map((schemeName) => [schemeName, SECURITY_SCHEME_DEFINITIONS[schemeName]]));
+  return { security, securitySchemes };
+}
+function applyOpenApiExtras(document, options) {
+  if (options?.serverUrl)
+    document.servers = [{ url: options.serverUrl }];
+  if (options?.discoveryInfo?.externalDocs !== void 0)
+    document.externalDocs = { ...options.discoveryInfo.externalDocs };
+}