apps 0.0.1-beta.0 → 0.0.1-beta.10

package/js/openapi.js

@@ -1,167 +1,296 @@
 import {
-  protocolOperations
-} from "./chunk-LOKGDT6B.js";
-import "./chunk-C24KEZXR.js";
+  parse
+} from "./chunk-UVL56Z6E.js";
+import {
+  protocolOperations,
+  protocolRouter
+} from "./chunk-72JNVHPK.js";
+import {
+  OpenapiError,
+  OpenapiErrorResponse,
+  OpenapiOperation,
+  OpenapiParameter,
+  OpenapiRequestBody,
+  OpenapiToolsOptions,
+  defaultOpenapiResponseLimits,
+  isOpenapiFileSchema,
+  isOpenapiTextMedia,
+  openapiBinaryResultSchema,
+  openapiMediaKind
+} from "./chunk-FL2QR3XW.js";
+import "./chunk-IPI4MFSN.js";
+import {
+  fromPromise,
+  nativeOperation,
+  routerDeclaration,
+  toPromise
+} from "./chunk-Z5M2LQOZ.js";
+import {
+  accountProviderError,
+  httpProviderError
+} from "./chunk-MKWZPDR6.js";
+import {
+  ApiErrorRecovery,
+  ApiErrorResponse,
+  OpenapiResponseError,
+  RouterMeta,
+  defaultOpenapiErrorLimits
+} from "./chunk-WLE7WX2U.js";
+import "./chunk-N7YDVXYJ.js";
+import {
+  ProviderError
+} from "./chunk-R3EV5FTO.js";
+import "./chunk-JU7VHODU.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-VFUZI3NY.js";
+} from "./chunk-57RKNWL2.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-W7Q5EOTS.js";
+} from "./chunk-UK573G7W.js";
 import {
-  jsonSchemaDecoder
-} from "./chunk-BPEFS4YF.js";
+  jsonSchema,
+  lazyJsonSchemaDecoder,
+  once,
+  wrap
+} from "./chunk-5T57N25Q.js";
+import "./chunk-PZB6T6KU.js";
 import {
-  HttpUrl,
-  JsonObject
-} from "./chunk-36DNRFZQ.js";
+  JsonObject,
+  JsonValue
+} from "./chunk-27F7W2LG.js";
 import {
+  Deferred_exports,
+  Duration_exports,
   Effect_exports,
-  Schema_exports
-} from "./chunk-2OTCEKL2.js";
-import "./chunk-MLKGABMK.js";
-
-// src/contracts/openapi.ts
-var RequestParameter = Schema_exports.Struct({
-  name: Schema_exports.String,
-  in: Schema_exports.Literals(["path", "query", "header"]),
-  style: Schema_exports.String,
-  explode: Schema_exports.Boolean
-});
-var OpenapiOperation = Schema_exports.Struct({
-  name: Schema_exports.NonEmptyString,
-  description: Schema_exports.String,
-  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
-  path: Schema_exports.String,
-  baseUrl: HttpUrl,
-  parameters: Schema_exports.Array(RequestParameter),
-  body: Schema_exports.Literals(["json", "base64", "none"]),
-  /** Streams remain in the metadata but cannot run through a single-result tool call. */
-  streaming: Schema_exports.optionalKey(Schema_exports.Literal(true)),
-  security: Schema_exports.Array(Schema_exports.Array(Schema_exports.String)),
-  input: JsonObject,
-  outputSchema: Schema_exports.optionalKey(JsonObject)
-});
-var CredentialBinding = Schema_exports.Struct({
-  scheme: Schema_exports.String,
-  field: Schema_exports.String,
-  in: Schema_exports.Literals(["header", "query"]),
-  name: Schema_exports.String,
-  prefix: Schema_exports.String
-});
-var OpenapiAccount = Schema_exports.Struct({
-  method: Schema_exports.String,
-  fields: Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-});
-var OpenapiToolsOptions = Schema_exports.Struct({
-  operations: Schema_exports.Array(OpenapiOperation),
-  methods: Schema_exports.Record(Schema_exports.String, Schema_exports.Array(CredentialBinding)),
-  oauth: Schema_exports.Array(Schema_exports.String),
-  account: Schema_exports.optional(OpenapiAccount),
-  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
-  fetch: Schema_exports.optional(
-    Schema_exports.declare((value) => typeof value === "function")
-  )
-});
-var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
-  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
-  status: Schema_exports.optional(Schema_exports.Number)
-}) {
-};
+  Encoding_exports,
+  JsonPointer_exports,
+  JsonSchema_exports,
+  Option_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-CDL5PM2Q.js";
+import "./chunk-CZ7CSFO4.js";
+
+// src/implementation/swagger-client.ts
+var loadSwaggerClient = () => import("./es-APDZKREY.js").then((module) => module.default);
 
 // src/implementation/openapi-request.ts
+var bodyRecovery = Schema_exports.decodeUnknownOption(Schema_exports.Struct({ recovery: ApiErrorRecovery }));
+function responseError(response, errors) {
+  return Effect_exports.gen(function* () {
+    const candidates = errors.filter((error) => error.status === response.status);
+    if (candidates.length === 0 || !/^application\/(?:[\w.-]+\+)?json$/i.test(
+      response.headers["content-type"]?.split(";")[0]?.trim() ?? ""
+    ))
+      return;
+    const length = response.headers["content-length"];
+    if (length !== void 0 && Number(length) > defaultOpenapiErrorLimits.maxBodyBytes) return;
+    const json = yield* response.stream.pipe(
+      Stream_exports.mapError(() => new OpenapiError({ reason: "request", status: response.status })),
+      Stream_exports.limitBytes(
+        defaultOpenapiErrorLimits.maxBodyBytes,
+        () => Stream_exports.fail(new OpenapiError({ reason: "request", status: response.status }))
+      ),
+      Stream_exports.decodeText,
+      Stream_exports.mkString,
+      Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(Schema_exports.Json))),
+      Effect_exports.timeout(defaultOpenapiErrorLimits.readTimeoutMs)
+    );
+    for (const candidate of candidates) {
+      const parsed = yield* Schema_exports.decodeUnknownEffect(candidate.decoder)(json).pipe(Effect_exports.option);
+      if (Option_exports.isSome(parsed)) {
+        const message = candidate.message.source === "schema" ? Option_exports.some({ message: candidate.message.value }) : Schema_exports.decodeUnknownOption(
+          Schema_exports.Struct({ message: ApiErrorResponse.fields.message })
+        )(parsed.value);
+        if (Option_exports.isNone(message)) continue;
+        const recovery = bodyRecovery(parsed.value);
+        return new OpenapiResponseError({
+          code: candidate.code,
+          status: response.status,
+          message: message.value.message,
+          ...Option_exports.isSome(recovery) ? { recovery: recovery.value.recovery } : {}
+        });
+      }
+    }
+  }).pipe(Effect_exports.catch(() => Effect_exports.succeed(void 0)));
+}
 var object = Schema_exports.decodeUnknownSync(Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown));
 function scalar(value) {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
     return String(value);
   throw new Error("This parameter requires scalar values");
 }
-function pairs(value) {
-  return Object.entries(object(value)).map(([key, item]) => [key, scalar(item)]);
+var swaggerRequest = Schema_exports.decodeUnknownSync(
+  Schema_exports.Struct({
+    url: Schema_exports.String,
+    method: Schema_exports.String,
+    headers: Schema_exports.Record(Schema_exports.String, Schema_exports.String),
+    body: Schema_exports.optional(
+      Schema_exports.Union([Schema_exports.String, Schema_exports.instanceOf(Blob), Schema_exports.instanceOf(FormData)])
+    )
+  })
+);
+var reservedPath = /* @__PURE__ */ new Set([
+  ":",
+  "@",
+  "!",
+  "$",
+  "&",
+  "'",
+  "(",
+  ")",
+  "*",
+  "+",
+  ",",
+  ";",
+  "=",
+  "/"
+]);
+function reservedPathValue(value) {
+  const text = Array.isArray(value) ? value.map(scalar).join(",") : scalar(value);
+  if (/[?#\\]/.test(text)) throw new Error("This path value contains a forbidden character");
+  const encoded = text.replace(/%[0-9A-Fa-f]{2}|[^]/gu, (part) => {
+    if (part.length === 3 && part.startsWith("%")) {
+      if ("./\\?#%".includes(String.fromCharCode(Number.parseInt(part.slice(1), 16))))
+        throw new Error("This path value contains a forbidden escape");
+      return part;
+    }
+    return reservedPath.has(part) ? part : encodeURIComponent(part);
+  });
+  if (encoded.split("/").some((segment) => segment === "" || segment === "." || segment === ".."))
+    throw new Error("This path value would change the request path");
+  return encoded;
 }
-function simple(value, explode, encode) {
-  const token = (value2) => encode ? encodeURIComponent(scalar(value2)) : scalar(value2);
-  if (Array.isArray(value)) return value.map(token).join(",");
-  if (typeof value === "object" && value !== null)
-    return pairs(value).map(([key, item]) => token(key) + (explode ? "=" : ",") + token(item)).join(",");
-  return token(value);
+function operationPath(op) {
+  const template = op.baseUrl.replace(/\/$/, "") + op.path;
+  let marker = "executorPathParameter";
+  while (template.includes(marker)) marker += "_";
+  const expansions = [];
+  const address = template.replace(/\{[^{}]+\}/g, (placeholder) => {
+    const parameter = op.request.parameters.find(
+      (p) => p.in === "path" && p.name === placeholder.slice(1, -1)
+    );
+    if (parameter === void 0) throw new Error("A path parameter is not declared");
+    const token = `${marker}_${expansions.length}_`;
+    expansions.push({
+      token,
+      pattern: parameter.allowReserved === true && parameter.content === void 0 ? ".+" : "[^/]+"
+    });
+    return token;
+  });
+  let pattern = new URL(address).pathname.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const expansion of expansions)
+    pattern = pattern.replaceAll(expansion.token, expansion.pattern);
+  return new RegExp("^" + pattern + "$");
 }
+var bytes = (value) => Uint8Array.from(atob(scalar(value)), (char) => char.charCodeAt(0));
 function createRequest(config) {
   const { methods, oauth } = config;
-  function schemes(method) {
-    if (method === void 0) return [];
-    if (oauth.includes(method)) return [method];
-    const bindings = Object.hasOwn(methods, method) ? methods[method] : void 0;
-    return bindings?.map((binding) => binding.scheme) ?? [];
-  }
-  function selectedSecurity(op, method) {
+  function selectedCredentials(op, account) {
     if (op.streaming === true) return void 0;
-    if (!op.security.length) return [];
-    const supported = schemes(method);
-    return op.security.find((keys) => keys.every((key) => supported.includes(key)));
+    const authorized = {};
+    if (account !== void 0) {
+      if (oauth.includes(account.method)) {
+        const token = account.fields.access_token;
+        if (typeof token === "string" && token.length > 0)
+          authorized[account.method] = { token: { access_token: token } };
+      } else if (Object.hasOwn(methods, account.method)) {
+        const bindings = methods[account.method] ?? [];
+        for (const scheme of new Set(bindings.map((binding) => binding.scheme))) {
+          const parts = bindings.filter((binding) => binding.scheme === scheme);
+          if (parts.some(
+            ({ field }) => typeof account.fields[field] !== "string" || account.fields[field] === ""
+          ))
+            continue;
+          for (const { part, field, prefix } of parts) {
+            const value = scalar(account.fields[field]);
+            authorized[scheme] = part === "value" ? prefix + value : { ...object(authorized[scheme] ?? {}), [part]: value };
+          }
+        }
+      }
+    }
+    const security = op.request.security;
+    const keys = security.length === 0 ? [] : security.map(Object.keys).find((keys2) => keys2.every((key) => Object.hasOwn(authorized, key)));
+    return keys === void 0 ? void 0 : Object.fromEntries(keys.map((key) => [key, authorized[key]]));
   }
-  const call = (op, input, account) => Effect_exports.scoped(
+  const call = (op, input, account, errors) => Effect_exports.scoped(
     Effect_exports.gen(function* () {
+      const swagger = yield* Effect_exports.promise(loadSwaggerClient);
       const prepared = yield* Effect_exports.try({
         try: () => {
           const args = object(input);
-          const security = selectedSecurity(op, account?.method);
-          if (security === void 0)
+          const authorized = selectedCredentials(op, account);
+          if (authorized === void 0)
             throw new Error("The selected account cannot call this tool");
+          const parameters = {};
           let path = op.path;
-          const query = new URLSearchParams();
-          const headers = new Headers();
-          for (const p of op.parameters) {
+          const swaggerParameters = op.request.parameters.filter((p) => {
             const group = args[p.in === "header" ? "headers" : p.in];
             const value = group === void 0 ? void 0 : object(group)[p.name];
-            if (value === void 0) continue;
-            if (p.in === "path")
-              path = path.replaceAll("{" + p.name + "}", simple(value, p.explode, true));
-            else if (p.in === "header") headers.set(p.name, simple(value, p.explode, false));
-            else if (p.style === "deepObject") {
-              for (const [key, item] of pairs(value))
-                query.append(p.name + "[" + key + "]", item);
-            } else if (Array.isArray(value)) {
-              if (p.explode && p.style === "form")
-                for (const item of value) query.append(p.name, scalar(item));
-              else
-                query.append(
-                  p.name,
-                  value.map(scalar).join(
-                    p.style === "spaceDelimited" ? " " : p.style === "pipeDelimited" ? "|" : ","
-                  )
-                );
-            } else if (typeof value === "object" && value !== null) {
-              if (p.style !== "form") throw new Error("Unsupported object parameter style");
-              if (p.explode) for (const [key, item] of pairs(value)) query.append(key, item);
-              else query.append(p.name, pairs(value).flat().join(","));
-            } else query.append(p.name, scalar(value));
-          }
-          if (/{[^}]+}/.test(path)) throw new Error("A required path parameter is missing");
-          const url = new URL(op.baseUrl + path);
-          if (account && Object.hasOwn(methods, account.method)) {
-            for (const binding of methods[account.method] ?? []) {
-              if (!security.includes(binding.scheme)) continue;
-              const credential = binding.prefix + scalar(account.fields[binding.field]);
-              if (binding.in === "header") headers.set(binding.name, credential);
-              else query.set(binding.name, credential);
-            }
-          } else if (account && oauth.includes(account.method) && security.includes(account.method)) {
-            headers.set("Authorization", "Bearer " + scalar(account.fields.access_token));
-          }
-          url.search = query.toString();
-          let body;
-          if (args.body !== void 0) {
-            if (op.body === "json") {
-              headers.set("Content-Type", "application/json");
-              body = JSON.stringify(args.body);
-            } else if (op.body === "base64") {
-              headers.set("Content-Type", "application/octet-stream");
-              body = Uint8Array.from(atob(scalar(args.body)), (char) => char.charCodeAt(0));
-            }
-          }
-          return { url, headers, body, method: op.method };
+            if (p.in === "path" && p.allowReserved === true && p.content === void 0) {
+              if (value === void 0) throw new Error("A required path parameter is missing");
+              path = path.replaceAll(`{${p.name}}`, reservedPathValue(value));
+              return false;
+            }
+            if (group !== void 0) parameters[`${p.in}.${p.name}`] = value;
+            return true;
+          });
+          const content = op.request.requestBody?.content ?? {};
+          const contentType2 = args.contentType === void 0 ? Object.keys(content)[0] : scalar(args.contentType);
+          const media = contentType2 === void 0 ? void 0 : content[contentType2];
+          let body = args.body;
+          if (body !== void 0 && media !== void 0 && contentType2 !== void 0) {
+            const kind = openapiMediaKind(contentType2);
+            if (kind === "json") body = JSON.stringify(body);
+            else if (kind === "binary") body = new Blob([bytes(body)]);
+            else if (kind === "multipart") {
+              const fields = { ...object(body) };
+              for (const [name, property] of Object.entries(
+                object(media.schema?.properties ?? {})
+              )) {
+                if (isOpenapiFileSchema(object(property)) && fields[name] !== void 0)
+                  fields[name] = new File([bytes(fields[name])], name);
+              }
+              body = fields;
+            }
+          }
+          const prepared2 = swaggerRequest(
+            swagger.buildRequest({
+              spec: {
+                openapi: op.openapi,
+                servers: [{ url: op.baseUrl }],
+                components: { securitySchemes: op.securitySchemes },
+                paths: {
+                  [path]: {
+                    [op.method.toLowerCase()]: {
+                      ...op.request,
+                      parameters: swaggerParameters,
+                      operationId: op.name
+                    }
+                  }
+                }
+              },
+              operationId: op.name,
+              pathName: path,
+              method: op.method.toLowerCase(),
+              parameters,
+              securities: { authorized },
+              ...contentType2 === void 0 ? {} : { requestContentType: contentType2 },
+              ...body === void 0 ? {} : { requestBody: body }
+            })
+          );
+          const pathname = prepared2.url.replace(/^[^:]+:\/\/[^/]*/, "").split(/[?#]/)[0] ?? "";
+          if (pathname.split("/").some((segment) => /^(?:\.|%2e){1,2}$/i.test(segment)))
+            throw new Error("This path value would change the request path");
+          const url = new URL(prepared2.url);
+          const origin = new URL(op.baseUrl).origin;
+          if (url.origin !== origin || !operationPath(op).test(url.pathname) || url.username || url.password)
+            throw new Error("The request escaped its API operation");
+          const headers = new Headers(prepared2.headers);
+          if (!headers.has("user-agent")) headers.set("user-agent", "Executor");
+          if (prepared2.body instanceof FormData) headers.delete("content-type");
+          return { ...prepared2, url, headers };
         },
         catch: () => new OpenapiError({ reason: "invalid_input" })
       });
@@ -177,10 +306,34 @@ function createRequest(config) {
         catch: () => new OpenapiError({ reason: "invalid_input" })
       });
       const response = yield* HttpClient_exports.withScope(client).execute(request);
-      if (response.status < 200 || response.status >= 300)
-        return yield* new OpenapiError({ reason: "request", status: response.status });
+      if (response.status < 200 || response.status >= 300) {
+        const provider = httpProviderError(response.status, response.headers);
+        if (provider !== void 0 && provider.reason !== "rejected") return yield* provider;
+        const declared = yield* responseError(response, errors);
+        return yield* declared ?? provider ?? new OpenapiError({ reason: "request", status: response.status });
+      }
       if (response.status === 204 || prepared.method === "HEAD") return null;
-      return yield* (response.headers["content-type"]?.includes("json") ? response.json : response.text).pipe(Effect_exports.withSpan("provider.http.response.read"));
+      const contentType = response.headers["content-type"] ?? "text/plain";
+      const chunks = yield* response.stream.pipe(
+        Stream_exports.mapError(() => new OpenapiError({ reason: "request" })),
+        Stream_exports.limitBytes(
+          defaultOpenapiResponseLimits.maxBodyBytes,
+          () => Stream_exports.fail(new OpenapiError({ reason: "request" }))
+        ),
+        Stream_exports.runCollect,
+        Effect_exports.timeout(defaultOpenapiResponseLimits.readTimeoutMs),
+        Effect_exports.withSpan("provider.http.response.read")
+      );
+      const data = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.length, 0));
+      let offset = 0;
+      for (const chunk of chunks) {
+        data.set(chunk, offset);
+        offset += chunk.length;
+      }
+      if (!isOpenapiTextMedia(contentType))
+        return { base64: Encoding_exports.encodeBase64(data), contentType };
+      const text = new TextDecoder().decode(data);
+      return contentType.includes("json") && !contentType.includes("ndjson") ? yield* Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(Schema_exports.Json))(text) : text;
     })
   ).pipe(
     Effect_exports.withSpan("provider.openapi.call", {
@@ -189,36 +342,145 @@ function createRequest(config) {
     Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
     Effect_exports.provide(FetchHttpClient_exports.layer),
     Effect_exports.mapError(
-      (error) => error instanceof OpenapiError ? error : new OpenapiError({ reason: "request" })
+      (error) => error instanceof ProviderError && account?.id !== void 0 ? accountProviderError(error, account.id) : error instanceof OpenapiError || error instanceof OpenapiResponseError || error instanceof ProviderError ? error : new OpenapiError({ reason: "request" })
     )
   );
   return {
-    available: (op, method) => selectedSecurity(op, method) !== void 0,
+    available: (op, account) => selectedCredentials(op, account) !== void 0,
     call
   };
 }
 
 // src/implementation/openapi.ts
-var openapiToolsEffect = (options) => Effect_exports.gen(function* () {
+function references(value, found = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(value)) for (const item of value) references(item, found);
+  else if (value !== null && typeof value === "object")
+    for (const [key, item] of Object.entries(value)) {
+      if (key !== "$ref" || typeof item !== "string") references(item, found);
+      else {
+        const path = item.startsWith("#/$defs/") ? JsonPointer_exports.parseUriFragment(item) : void 0;
+        if (path?.[1] !== void 0) found.add(path[1]);
+      }
+    }
+  return found;
+}
+var bundler = (definitions) => {
+  const direct = /* @__PURE__ */ new Map();
+  return (schema2) => {
+    const reached = /* @__PURE__ */ new Map();
+    const pending = [...references(schema2)];
+    for (let name = pending.pop(); name !== void 0; name = pending.pop()) {
+      const definition = Object.hasOwn(definitions, name) ? definitions[name] : void 0;
+      if (definition === void 0 || reached.has(name)) continue;
+      reached.set(name, definition);
+      let names = direct.get(name);
+      if (names === void 0) direct.set(name, names = references(definition));
+      pending.push(...names);
+    }
+    if (reached.size === 0) return schema2;
+    const own = schema2.$defs;
+    return {
+      ...schema2,
+      $defs: {
+        ...Object.fromEntries(reached),
+        ...own !== null && typeof own === "object" && !Array.isArray(own) ? own : {}
+      }
+    };
+  };
+};
+var parameterGroups = { path: "path", query: "query", headers: "header" };
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var boundParameters = (op, defaults) => Object.keys(parameterGroups).flatMap(
+  (group) => Object.entries(defaults?.[group] ?? {}).filter(
+    ([name]) => op.request.parameters.some((p) => p.name === name && p.in === parameterGroups[group])
+  ).map(([name, value]) => ({ group, name, value }))
+);
+var parameterDefaultsInput = (op, defaults, publish) => {
+  const bound = boundParameters(op, defaults);
+  if (!bound.length || !isObject(op.input.properties)) return op.input;
+  const properties = { ...op.input.properties };
+  let required = Array.isArray(op.input.required) ? op.input.required : [];
+  for (const group of new Set(bound.map((entry) => entry.group))) {
+    const shape = properties[group];
+    if (!isObject(shape)) continue;
+    const names = bound.filter((entry) => entry.group === group);
+    const remaining = (Array.isArray(shape.required) ? shape.required : []).filter(
+      (name) => !names.some((entry) => entry.name === name)
+    );
+    const fields = isObject(shape.properties) ? shape.properties : {};
+    properties[group] = {
+      ...shape,
+      required: remaining,
+      ...publish ? {
+        properties: {
+          ...fields,
+          ...Object.fromEntries(
+            names.map(({ name, value }) => {
+              const field = isObject(fields[name]) ? fields[name] : {};
+              const note = "Optional; defaults to the value bound to the selected account.";
+              const description = typeof field.description === "string" ? `${field.description} ${note}` : note;
+              return [name, { ...field, description, default: value }];
+            })
+          )
+        }
+      } : {}
+    };
+    if (!remaining.length) required = required.filter((key) => key !== group);
+  }
+  return { ...op.input, properties, required };
+};
+var fillParameterDefaults = (op, defaults, value) => {
+  const bound = boundParameters(op, defaults);
+  if (!bound.length || !isObject(value)) return value;
+  const result = { ...value };
+  for (const { group, name, value: fallback } of bound) {
+    const current = result[group] ?? {};
+    if (!isObject(current)) return value;
+    if (!Object.hasOwn(current, name)) result[group] = { ...current, [name]: fallback };
+  }
+  return result;
+};
+var prepareOpenapiOperation = (op, definitions, defaults) => Effect_exports.gen(function* () {
+  const bundle = bundler(definitions);
+  const input = yield* lazyJsonSchemaDecoder(
+    () => bundle(parameterDefaultsInput(op, defaults, false))
+  );
+  const errors = yield* Effect_exports.forEach(
+    op.errorResponses ?? [],
+    (response) => lazyJsonSchemaDecoder(() => bundle(response.schema)).pipe(
+      Effect_exports.map((decoder) => ({ ...response, decoder }))
+    )
+  );
+  return {
+    input,
+    errors,
+    output: once(() => op.outputSchema === void 0 ? void 0 : bundle(op.outputSchema))
+  };
+});
+var openapiToolsEffect = (options, prepared) => Effect_exports.gen(function* () {
   const config = yield* Schema_exports.decodeUnknownEffect(OpenapiToolsOptions)(options).pipe(
     Effect_exports.mapError(() => new OpenapiError({ reason: "invalid_definition" }))
   );
   const request = createRequest(config);
   const entries = yield* Effect_exports.forEach(
-    config.operations.filter((op) => request.available(op, config.account?.method)),
+    config.operations.filter((op) => request.available(op, config.account)),
     (op) => Effect_exports.gen(function* () {
-      const input = yield* jsonSchemaDecoder(op.input).pipe(
-        Effect_exports.mapError(() => new OpenapiError({ reason: "invalid_definition" }))
-      );
+      const schemas = prepared?.get(op.name) ?? (yield* prepareOpenapiOperation(
+        op,
+        config.definitions ?? {},
+        config.parameterDefaults
+      ));
+      const { input, errors } = schemas;
       const tool = {
         description: op.description,
         readOnly: ["GET", "HEAD", "OPTIONS"].includes(op.method),
         input,
-        ...op.outputSchema === void 0 ? {} : { outputSchema: op.outputSchema },
-        run: (_context, value) => Schema_exports.decodeUnknownEffect(input)(value).pipe(
+        run: (_context, value) => Schema_exports.decodeUnknownEffect(input)(
+          fillParameterDefaults(op, config.parameterDefaults, value)
+        ).pipe(
           Effect_exports.mapError(() => new OpenapiError({ reason: "invalid_input" })),
           Effect_exports.flatMap(
-            (parsed) => request.call(op, parsed, config.account).pipe(
+            (parsed) => request.call(op, parsed, config.account, errors).pipe(
               Effect_exports.provideService(
                 FetchHttpClient_exports.Fetch,
                 config.fetch ?? globalThis.fetch
@@ -227,20 +489,2656 @@ var openapiToolsEffect = (options) => Effect_exports.gen(function* () {
           )
         )
       };
+      const output = op.outputSchema;
+      if (output !== void 0)
+        Object.defineProperty(tool, "outputSchema", {
+          enumerable: true,
+          get: schemas.output
+        });
       return [op.name, tool];
     })
   );
   return Object.fromEntries(entries);
 });
 
-// src/openapi.ts
-var openapiOperations = (options, kinds = {}) => Effect_exports.runPromise(
-  openapiToolsEffect(options).pipe(
-    Effect_exports.map((operations) => protocolOperations(operations, kinds))
+// src/contracts/openapi-compile.ts
+var OpenapiCompileErrorCode = Schema_exports.Literals([
+  "server_protocol",
+  "server_url",
+  "external_reference",
+  "circular_reference",
+  "schema_keyword",
+  "schema_reference",
+  "missing_component",
+  "openapi_version",
+  "auth_helper",
+  "auth_missing",
+  "operation_path",
+  "duplicate_operation",
+  "server_missing",
+  "multiple_hosts",
+  "parameter_encoding",
+  "parameter_style",
+  "request_body",
+  "combined_oauth",
+  "auth_method",
+  "input_schema",
+  "no_operations",
+  "no_supported_operations",
+  "invalid_document",
+  "source_generation",
+  "authoring_reference"
+]);
+var OpenapiCompileError = class extends Schema_exports.TaggedError()(
+  "OpenapiCompileError",
+  {
+    code: OpenapiCompileErrorCode,
+    reason: Schema_exports.String
+  }
+) {
+};
+
+// src/contracts/openapi-document.ts
+var Server = Schema_exports.Struct({ url: Schema_exports.String, variables: Schema_exports.optionalKey(JsonObject) });
+var Specification = Schema_exports.Struct({
+  openapi: Schema_exports.String,
+  servers: Schema_exports.optionalKey(Schema_exports.Array(Server)),
+  paths: Schema_exports.Record(Schema_exports.String, JsonObject),
+  components: Schema_exports.optionalKey(
+    Schema_exports.Struct({
+      schemas: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, JsonObject)),
+      securitySchemes: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, JsonObject))
+    })
+  ),
+  security: Schema_exports.optionalKey(
+    Schema_exports.Array(Schema_exports.Record(Schema_exports.String, Schema_exports.Array(Schema_exports.String)))
+  )
+});
+var Operation = Schema_exports.Struct({
+  operationId: Schema_exports.optionalKey(Schema_exports.String),
+  responses: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, JsonObject)),
+  summary: Schema_exports.optionalKey(Schema_exports.String),
+  description: Schema_exports.optionalKey(Schema_exports.String),
+  parameters: Schema_exports.optionalKey(Schema_exports.Array(JsonObject)),
+  requestBody: Schema_exports.optionalKey(JsonObject),
+  security: Schema_exports.optionalKey(
+    Schema_exports.Array(Schema_exports.Record(Schema_exports.String, Schema_exports.Array(Schema_exports.String)))
+  ),
+  servers: Schema_exports.optionalKey(Schema_exports.Array(Server))
+});
+
+// ../../node_modules/.bun/@scalar+helpers@0.14.0/node_modules/@scalar/helpers/dist/object/is-object.js
+var isObject2 = (value) => {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var isObjectLike = (value) => typeof value === "object" && value !== null;
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/helpers/clone-document.js
+var ALIAS_EXPANSION_ENTRY_FLOOR = 1e5;
+var MAX_ALIAS_EXPANSION_RATIO = 10;
+var cloneDocument = (document) => {
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  const expansion = { sourceEntries: 0, copiedEntries: 0, sizes: /* @__PURE__ */ new Map() };
+  const clone = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined") {
+      return value;
+    }
+    if (!Array.isArray(value) && !isObject2(value)) {
+      return structuredClone(value);
+    }
+    if (ancestors.has(value)) {
+      throw new Error("Cannot upgrade to OpenAPI 3.2: cyclic objects cannot be represented in JSON. Use $ref instead.");
+    }
+    const size = expansion.sizes.get(value) ?? 1 + (Array.isArray(value) ? value.length : Object.keys(value).length);
+    if (!expansion.sizes.has(value)) {
+      expansion.sizes.set(value, size);
+      expansion.sourceEntries += size;
+    }
+    expansion.copiedEntries += size;
+    if (expansion.copiedEntries > ALIAS_EXPANSION_ENTRY_FLOOR && expansion.copiedEntries > expansion.sourceEntries * MAX_ALIAS_EXPANSION_RATIO) {
+      throw new Error("Cannot upgrade to OpenAPI 3.2: excessive YAML alias expansion. Use $ref for shared schemas.");
+    }
+    ancestors.add(value);
+    const result = Array.isArray(value) ? value.map(clone) : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
+    ancestors.delete(value);
+    return result;
+  };
+  return clone(document);
+};
+
+// ../../node_modules/.bun/@scalar+helpers@0.14.0/node_modules/@scalar/helpers/dist/json/escape-json-pointer.js
+var escapeJsonPointer = (str) => str.replace(/~/g, "~0").replace(/\//g, "~1");
+
+// ../../node_modules/.bun/@scalar+helpers@0.14.0/node_modules/@scalar/helpers/dist/json/unescape-json-pointer.js
+var unescapeJsonPointer = (uri) => decodeURI(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
+
+// ../../node_modules/.bun/@scalar+helpers@0.14.0/node_modules/@scalar/helpers/dist/json/parse-json-pointer-segments.js
+var parseJsonPointerSegments = (path) => path.split("/").slice(1).map(unescapeJsonPointer);
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/upgrade-incompatibility-error.js
+var UpgradeIncompatibilityError = class extends AggregateError {
+  errors;
+  constructor(errors) {
+    super(errors, errors.map((error) => error.message).join("\n"));
+    this.errors = errors;
+    this.name = "UpgradeIncompatibilityError";
+  }
+};
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/3.1-to-3.2/migrate-objects.js
+var schemaMaps = ["properties", "patternProperties", "$defs", "dependentSchemas"];
+var schemaArrays = ["allOf", "anyOf", "oneOf", "prefixItems"];
+var schemaSingles = [
+  "items",
+  "contains",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "propertyNames",
+  "not",
+  "if",
+  "then",
+  "else",
+  "contentSchema"
+];
+var migrateObjects = (document) => {
+  const properties = /* @__PURE__ */ new WeakMap();
+  const own = (value, key) => {
+    const entries = properties.get(value) ?? new Map(Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([, descriptor]) => Object.hasOwn(descriptor, "value")).map(([name, descriptor]) => [name, descriptor.value]));
+    properties.set(value, entries);
+    return entries.get(key);
+  };
+  const operationTags = /* @__PURE__ */ new Set();
+  const errors = [];
+  const requiredCache = /* @__PURE__ */ new WeakMap();
+  const cyclicRequired = /* @__PURE__ */ new WeakSet();
+  const requiredWork = { evaluations: 0 };
+  const propertySchemas = /* @__PURE__ */ new WeakSet();
+  const xmlRoots = [];
+  const markPropertySchema = (schema2) => {
+    if (!isObject2(schema2) || propertySchemas.has(schema2)) {
+      return;
+    }
+    propertySchemas.add(schema2);
+    markPropertySchema(schema2.items);
+    if (Array.isArray(schema2.prefixItems)) {
+      schema2.prefixItems.forEach(markPropertySchema);
+    }
+  };
+  const xmlCache = /* @__PURE__ */ new WeakMap();
+  const visited = /* @__PURE__ */ new WeakMap();
+  const fail3 = (path, message) => {
+    errors.push(new Error(`Cannot upgrade to OpenAPI 3.2 at ${path}: ${message}`));
+  };
+  const resolve = (ref, schemaReference = false) => {
+    if (typeof ref !== "string" || !ref.startsWith("#/")) {
+      return void 0;
+    }
+    try {
+      return parseJsonPointerSegments(decodeURIComponent(ref.slice(1))).reduce((value, key) => {
+        if (schemaReference && isObject2(value) && (value.$id !== void 0 || value.$schema !== void 0)) {
+          return void 0;
+        }
+        if (Array.isArray(value) && !/^(0|[1-9]\d*)$/.test(key)) {
+          return void 0;
+        }
+        if (!isObject2(value) && !Array.isArray(value) || !Object.hasOwn(value, key)) {
+          return void 0;
+        }
+        return own(value, key);
+      }, document);
+    } catch {
+      return void 0;
+    }
+  };
+  const repeatedVariables = (value, path) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const names = [...value.matchAll(/\{([^{}]+)\}/g)].map((match) => match[1]);
+    if (new Set(names).size !== names.length) {
+      fail3(path, "Template variables must not be repeated. Rename the repeated variable and define it separately.");
+    }
+  };
+  const requires = (schema2, name, seen = /* @__PURE__ */ new Set()) => {
+    if (schema2 === false) {
+      return true;
+    }
+    if (schema2 === true) {
+      return false;
+    }
+    if (!isObject2(schema2) || schema2.$id !== void 0 || schema2.$schema !== void 0) {
+      return void 0;
+    }
+    if (seen.has(schema2)) {
+      for (const ancestor of seen) {
+        cyclicRequired.add(ancestor);
+      }
+      return void 0;
+    }
+    const cached = requiredCache.get(schema2) ?? /* @__PURE__ */ new Map();
+    if (cached.has(name)) {
+      return cached.get(name);
+    }
+    if (++requiredWork.evaluations > 1e5) {
+      if (requiredWork.evaluations === 100001) {
+        fail3("#", "Discriminator requiredness analysis was truncated after 100,000 evaluations.");
+      }
+      return void 0;
+    }
+    const remember2 = (result) => {
+      if (result !== void 0 || !cyclicRequired.has(schema2)) {
+        cached.set(name, result);
+        requiredCache.set(schema2, cached);
+      }
+      return result;
+    };
+    if (Array.isArray(schema2.required) && schema2.required.includes(name)) {
+      return remember2(true);
+    }
+    const next = /* @__PURE__ */ new Set([...seen, schema2]);
+    const constraints = [];
+    if (schema2.$ref !== void 0) {
+      constraints.push(requires(resolve(schema2.$ref, true), name, next));
+    }
+    if (Array.isArray(schema2.allOf)) {
+      constraints.push(...schema2.allOf.map((item) => requires(item, name, next)));
+    }
+    for (const keyword of ["oneOf", "anyOf"]) {
+      if (Array.isArray(schema2[keyword])) {
+        const alternatives = schema2[keyword].map((item) => requires(item, name, next));
+        if (alternatives.every((value) => value === true)) {
+          constraints.push(true);
+        } else if (alternatives.every((value) => value === false)) {
+          constraints.push(false);
+        } else {
+          constraints.push(void 0);
+        }
+      }
+    }
+    if (constraints.includes(true)) {
+      return remember2(true);
+    }
+    if (constraints.includes(void 0) || ["if", "not", "$dynamicRef", "const", "enum", "minProperties", "dependentRequired", "dependentSchemas"].some((key) => key in schema2)) {
+      return remember2(void 0);
+    }
+    return remember2(false);
+  };
+  const validateXmlNames = (schema2, path, { inferredName, propertyName, dialect, ancestors = /* @__PURE__ */ new Set(), baseChanged = false }) => {
+    if (!isObject2(schema2) || ancestors.has(schema2) || (schema2.$schema ?? dialect) !== void 0) {
+      return;
+    }
+    const changedBase = baseChanged || schema2.$id !== void 0;
+    const context = [inferredName, propertyName, changedBase].join(":");
+    const completed = xmlCache.get(schema2) ?? /* @__PURE__ */ new Set();
+    if (completed.has(context)) {
+      return;
+    }
+    const xml = isObject2(schema2.xml) ? schema2.xml : {};
+    const defaultNodeType = schema2.$ref !== void 0 || schema2.$dynamicRef !== void 0 || schema2.type === "array" ? "none" : "element";
+    const wrappedNodeType = xml.wrapped === true ? "element" : defaultNodeType;
+    const nodeType = xml.nodeType ?? (xml.attribute === true ? "attribute" : wrappedNodeType);
+    if ((nodeType === "element" || nodeType === "attribute") && !inferredName && xml.name === void 0) {
+      fail3(path, "An inline XML element needs an explicit xml.name.");
+    }
+    const childContext = { dialect, ancestors: /* @__PURE__ */ new Set([...ancestors, schema2]), baseChanged: changedBase };
+    if (!changedBase && typeof schema2.$ref === "string") {
+      const target = resolve(schema2.$ref, true);
+      if (isObject2(target)) {
+        const segments2 = parseJsonPointerSegments(decodeURIComponent(schema2.$ref.slice(1)));
+        const componentRoot = segments2.length === 3 && segments2[0] === "components" && segments2[1] === "schemas";
+        const fromProperty = propertySchemas.has(target);
+        validateXmlNames(target, schema2.$ref, {
+          ...childContext,
+          inferredName: componentRoot || fromProperty,
+          propertyName: fromProperty
+        });
+      }
+    }
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+      const branches = schema2[keyword];
+      if (Array.isArray(branches)) {
+        branches.forEach((branch, index) => validateXmlNames(branch, path + "/" + keyword + "/" + index, {
+          ...childContext,
+          inferredName: false,
+          propertyName: false
+        }));
+      }
+    }
+    validateXmlNames(schema2.items, path + "/items", { ...childContext, inferredName: propertyName, propertyName });
+    if (Array.isArray(schema2.prefixItems)) {
+      schema2.prefixItems.forEach((item, index) => validateXmlNames(item, path + "/prefixItems/" + index, {
+        ...childContext,
+        inferredName: propertyName,
+        propertyName
+      }));
+    }
+    if (isObject2(schema2.properties)) {
+      for (const [name, property] of Object.entries(schema2.properties)) {
+        validateXmlNames(property, path + "/properties/" + escapeJsonPointer(name), {
+          ...childContext,
+          inferredName: true,
+          propertyName: true
+        });
+      }
+    }
+    completed.add(context);
+    xmlCache.set(schema2, completed);
+  };
+  const visit = (value, kind, path, dialect = document.jsonSchemaDialect, baseChanged = false) => {
+    if (!isObject2(value)) {
+      return;
+    }
+    const schemaDialect = kind === "schema" ? value.$schema ?? dialect : dialect;
+    const schemaBaseChanged = baseChanged || kind === "schema" && value.$id !== void 0;
+    const visitKey = `${kind}:${String(schemaDialect)}:${schemaBaseChanged}`;
+    const seen = visited.get(value) ?? /* @__PURE__ */ new Set();
+    if (seen.has(visitKey)) {
+      return;
+    }
+    seen.add(visitKey);
+    visited.set(value, seen);
+    const child = (key, type) => visit(own(value, key), type, `${path}/${escapeJsonPointer(key)}`, schemaDialect, schemaBaseChanged);
+    const list = (key, type) => {
+      const items = own(value, key);
+      if (Array.isArray(items)) {
+        items.forEach((item, index) => visit(item, type, `${path}/${key}/${index}`, schemaDialect, schemaBaseChanged));
+      }
+    };
+    const map = (key, type) => {
+      const items = own(value, key);
+      if (isObject2(items)) {
+        for (const [name, item] of Object.entries(items)) {
+          if (key === "responses" && name.startsWith("x-")) {
+            continue;
+          }
+          if (kind === "schema" && key === "properties") {
+            markPropertySchema(item);
+          }
+          visit(item, type, `${path}/${key}/${escapeJsonPointer(name)}`, schemaDialect, schemaBaseChanged);
+        }
+      }
+    };
+    if (kind === "schema") {
+      if (schemaDialect !== void 0) {
+        return;
+      }
+      const xml = own(value, "xml");
+      if (isObject2(xml)) {
+        if (xml.wrapped === true && xml.attribute === true) {
+          fail3(`${path}/xml`, "wrapped and attribute cannot both be true.");
+        }
+        if (xml.wrapped === true || xml.attribute === true) {
+          xml.nodeType = xml.attribute === true ? "attribute" : "element";
+          delete xml.wrapped;
+          delete xml.attribute;
+        }
+      }
+      if (!schemaBaseChanged && value.$ref !== void 0) {
+        visit(resolve(value.$ref, true), "schema", String(value.$ref), schemaDialect);
+      }
+      const discriminator = value.discriminator;
+      if (isObject2(discriminator) && typeof discriminator.propertyName === "string" && discriminator.defaultMapping === void 0 && !schemaBaseChanged && requires(value, discriminator.propertyName) === false) {
+        fail3(`${path}/discriminator`, "An optional discriminating property needs an explicit defaultMapping.");
+      }
+      for (const key of schemaMaps) {
+        map(key, "schema");
+      }
+      for (const key of schemaArrays) {
+        list(key, "schema");
+      }
+      for (const key of schemaSingles) {
+        child(key, "schema");
+      }
+      return;
+    }
+    if (value.$ref !== void 0) {
+      visit(resolve(value.$ref), kind, String(value.$ref), schemaDialect);
+    }
+    switch (kind) {
+      case "document": {
+        const paths = own(value, "paths");
+        if (isObject2(paths)) {
+          for (const [name, item] of Object.entries(paths)) {
+            if (!name.startsWith("/")) {
+              continue;
+            }
+            const location = `${path}/paths/${escapeJsonPointer(name)}`;
+            repeatedVariables(name, location);
+            visit(item, "pathItem", location);
+          }
+        }
+        map("webhooks", "pathItem");
+        list("servers", "server");
+        const componentObjects = own(value, "components");
+        if (isObject2(componentObjects)) {
+          const components = {
+            schemas: "schema",
+            parameters: "parameter",
+            headers: "header",
+            requestBodies: "body",
+            responses: "response",
+            callbacks: "callback",
+            pathItems: "pathItem"
+          };
+          for (const [key, type] of Object.entries(components)) {
+            const entries = own(componentObjects, key);
+            if (isObject2(entries)) {
+              for (const [name, item] of Object.entries(entries)) {
+                visit(item, type, `${path}/components/${key}/${escapeJsonPointer(name)}`);
+              }
+            }
+          }
+        }
+        break;
+      }
+      case "pathItem":
+        for (const method of ["get", "put", "post", "delete", "options", "head", "patch", "trace"]) {
+          child(method, "operation");
+        }
+        list("parameters", "parameter");
+        list("servers", "server");
+        break;
+      case "operation":
+        if (Array.isArray(value.tags)) {
+          for (const tag of value.tags) {
+            if (typeof tag === "string") {
+              operationTags.add(tag);
+            }
+          }
+        }
+        list("parameters", "parameter");
+        list("servers", "server");
+        child("requestBody", "body");
+        map("responses", "response");
+        map("callbacks", "callback");
+        break;
+      case "callback":
+        for (const [name, item] of Object.entries(value)) {
+          if (!name.startsWith("x-") && name !== "$ref") {
+            visit(item, "pathItem", `${path}/${escapeJsonPointer(name)}`, schemaDialect, schemaBaseChanged);
+          }
+        }
+        break;
+      case "parameter":
+        if (value.in === "path" || value.in === "cookie") {
+          delete value.allowReserved;
+        }
+        child("schema", "schema");
+        map("content", "media");
+        break;
+      case "header":
+        child("schema", "schema");
+        map("content", "media");
+        break;
+      case "response":
+        map("headers", "header");
+        map("content", "media");
+        break;
+      case "body":
+        map("content", "media");
+        break;
+      case "media":
+        if (/\/(?:[^;]+\+)?xml(?:\s*;|$)/i.test(path.slice(path.lastIndexOf("/") + 1).replace(/~1/g, "/"))) {
+          xmlRoots.push({ schema: value.schema, path: `${path}/schema`, dialect: schemaDialect });
+        }
+        child("schema", "schema");
+        map("encoding", "encoding");
+        break;
+      case "encoding":
+        map("headers", "header");
+        break;
+      case "server":
+        repeatedVariables(value.url, `${path}/url`);
+        break;
+    }
+  };
+  visit(document, "document", "#");
+  for (const { schema: schema2, path, dialect } of xmlRoots) {
+    validateXmlNames(schema2, path, { inferredName: false, propertyName: false, dialect });
+  }
+  if (errors.length > 0) {
+    throw new UpgradeIncompatibilityError(errors);
+  }
+  return operationTags;
+};
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/3.1-to-3.2/migrate-tag-groups.js
+var migrateTagGroups = (document, operationTags) => {
+  const groups = document["x-tagGroups"];
+  if (!Array.isArray(groups) || groups.length === 0) {
+    return;
+  }
+  if (document.tags !== void 0 && !Array.isArray(document.tags)) {
+    return;
+  }
+  const tags = document.tags ?? [];
+  if (!tags.every((tag) => isObject2(tag) && typeof tag.name === "string")) {
+    return;
+  }
+  const existing = new Map(tags.map((tag) => [tag.name, tag]));
+  const parents = /* @__PURE__ */ new Set();
+  const children = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    if (!isObject2(group) || typeof group.name !== "string" || !group.name || !Array.isArray(group.tags) || !group.tags.every((name) => typeof name === "string") || Object.keys(group).some((key) => key !== "name" && key !== "tags") || parents.has(group.name) || existing.has(group.name) || operationTags.has(group.name)) {
+      return;
+    }
+    parents.add(group.name);
+    for (const name of group.tags) {
+      if (children.has(name) || existing.get(name)?.parent !== void 0) {
+        return;
+      }
+      children.add(name);
+    }
+  }
+  if ([...parents].some((name) => children.has(name)) || existing.size !== tags.length) {
+    return;
+  }
+  const result = [];
+  for (const group of groups) {
+    result.push({ name: group.name, kind: "nav" });
+    for (const name of group.tags) {
+      result.push({ ...existing.get(name) ?? { name }, parent: group.name });
+    }
+  }
+  document.tags = [...result, ...tags.filter((tag) => !children.has(tag.name))];
+};
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/3.1-to-3.2/upgrade-from-three-one-to-three-two.js
+var isThreeOneDocument = (document) => {
+  if (!isObject2(document) || typeof document.openapi !== "string") {
+    return false;
+  }
+  if (/^3\.1\.\d+$/.test(document.openapi)) {
+    return true;
+  }
+  if (/^3\.1(?:\D|$)/.test(document.openapi)) {
+    throw new Error(`Cannot upgrade to OpenAPI 3.2: invalid OpenAPI version "${document.openapi}". Expected 3.1.x with a numeric patch version.`);
+  }
+  return false;
+};
+var migrateThreeOneToThreeTwo = (document) => {
+  if (!isThreeOneDocument(document)) {
+    return document;
+  }
+  const operationTags = migrateObjects(document);
+  migrateTagGroups(document, operationTags);
+  document.openapi = "3.2.0";
+  return document;
+};
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/helpers/traverse.js
+function traverse(content, transform, path = []) {
+  const result = {};
+  for (const [key, value] of Object.entries(content)) {
+    const currentPath = [...path, key];
+    if (Array.isArray(value)) {
+      result[key] = value.map((item, index) => {
+        if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+          return traverse(item, transform, [...currentPath, index.toString()]);
+        }
+        return item;
+      });
+      continue;
+    }
+    if (isObjectLike(value)) {
+      result[key] = traverse(value, transform, currentPath);
+      continue;
+    }
+    result[key] = value;
+  }
+  return transform(result, path);
+}
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/2.0-to-3.0/upgrade-from-two-to-three.js
+var DEFAULT_MEDIA_TYPE = "application/json";
+function extractXExampleExtensions(obj) {
+  const xExample = obj["x-example"];
+  const xExamples = obj["x-examples"];
+  delete obj["x-example"];
+  delete obj["x-examples"];
+  return { xExample, xExamples };
+}
+function isNonEmptyObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function isNamedExamplesCollection(value) {
+  return isNonEmptyObject(value) && Object.values(value).every((v) => typeof v === "object" && v !== null && !Array.isArray(v));
+}
+function isEmptySchema(schema2) {
+  if (!isObjectLike(schema2)) {
+    return true;
+  }
+  const s = schema2;
+  const substantiveValidationKeywords = [
+    "enum",
+    "const",
+    "not",
+    "format",
+    "multipleOf",
+    "maximum",
+    "exclusiveMaximum",
+    "minimum",
+    "exclusiveMinimum",
+    "maxLength",
+    "minLength",
+    "pattern",
+    "maxItems",
+    "minItems",
+    "uniqueItems",
+    "maxProperties",
+    "minProperties",
+    "required"
+  ];
+  if (s.allOf || s.oneOf || s.anyOf || s.items || s.$ref || "additionalProperties" in s || substantiveValidationKeywords.some((key) => key in s)) {
+    return false;
+  }
+  if (typeof s.properties === "object" && s.properties !== null && Object.keys(s.properties).length > 0) {
+    return false;
+  }
+  return true;
+}
+function removeEmptySchemaOnlyContentEntries(content) {
+  const keys = Object.keys(content);
+  const hasEntryWithExample = keys.some((key) => {
+    const entry = content[key];
+    return isObjectLike(entry) && (entry.example !== void 0 || entry.examples !== void 0);
+  });
+  if (!hasEntryWithExample) {
+    return;
+  }
+  for (const key of keys) {
+    const entry = content[key];
+    if (!isObjectLike(entry))
+      continue;
+    const hasExample = entry.example !== void 0 || entry.examples !== void 0;
+    const hasOnlySchema = entry.schema !== void 0 && !hasExample && Object.keys(entry).length === 1;
+    if (hasOnlySchema && isEmptySchema(entry.schema)) {
+      delete content[key];
+    }
+  }
+}
+var EXAMPLE_OBJECT_PROPERTIES = /* @__PURE__ */ new Set(["summary", "description", "value", "externalValue"]);
+function isExampleObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  const hasValueOrExternalValue = "value" in obj || "externalValue" in obj;
+  const onlyHasAllowedProperties = Object.keys(obj).every((key) => EXAMPLE_OBJECT_PROPERTIES.has(key));
+  return hasValueOrExternalValue && onlyHasAllowedProperties;
+}
+function wrapAsExampleObject(value) {
+  if (isExampleObject(value)) {
+    return value;
+  }
+  return { value };
+}
+var MEDIA_TYPE_KEY_PATTERN = /^[a-zA-Z0-9*+.-]+\/[a-zA-Z0-9*+.+-]+$/;
+function isMediaTypeKey(key) {
+  return MEDIA_TYPE_KEY_PATTERN.test(key);
+}
+function transformXExampleToExamples(xExample) {
+  return Object.entries(xExample).reduce((acc, [key, value]) => {
+    acc[key] = { value };
+    return acc;
+  }, {});
+}
+var upgradeFlow = (flow) => {
+  switch (flow) {
+    case "application":
+      return "clientCredentials";
+    case "accessCode":
+      return "authorizationCode";
+    case "implicit":
+      return "implicit";
+    case "password":
+      return "password";
+    default:
+      return flow;
+  }
+};
+function upgradeFromTwoToThree(originalSpecification) {
+  let document = originalSpecification;
+  if (document !== null && typeof document === "object" && typeof document.swagger === "string" && document.swagger?.startsWith("2.0")) {
+    document.openapi = "3.0.4";
+    delete document.swagger;
+  } else {
+    return document;
+  }
+  if (document.host) {
+    const schemes = Array.isArray(document.schemes) && document.schemes?.length ? document.schemes : ["http"];
+    document.servers = schemes.map((scheme) => ({
+      url: `${scheme}://${document.host}${document.basePath ?? ""}`
+    }));
+    delete document.basePath;
+    delete document.schemes;
+    delete document.host;
+  } else if (document.basePath) {
+    document.servers = [{ url: document.basePath }];
+    delete document.basePath;
+  }
+  if (document.definitions) {
+    for (const schema2 of Object.values(document.definitions)) {
+      migrateSchemaNullability(schema2);
+    }
+    document.components = Object.assign({}, document.components, {
+      schemas: document.definitions
+    });
+    delete document.definitions;
+    document = traverse(document, (schema2) => {
+      if (typeof schema2.$ref === "string" && schema2.$ref.startsWith("#/definitions/")) {
+        schema2.$ref = schema2.$ref.replace(/^#\/definitions\//, "#/components/schemas/");
+      }
+      return schema2;
+    });
+  }
+  document = traverse(document, (schema2) => {
+    if (schema2.type === "file") {
+      schema2.type = "string";
+      schema2.format = "binary";
+    }
+    return schema2;
+  });
+  if (Object.hasOwn(document, "parameters")) {
+    document = traverse(document, (schema2) => {
+      if (typeof schema2.$ref === "string" && schema2.$ref.startsWith("#/parameters/")) {
+        const schemaName = schema2.$ref.split("/")[2];
+        if (!schemaName) {
+          return schema2;
+        }
+        const param = isObjectLike(document.parameters) && schemaName in document.parameters ? document.parameters[schemaName] : void 0;
+        if (param && typeof param === "object" && "in" in param && (param.in === "body" || param.in === "formData")) {
+          schema2.$ref = schema2.$ref.replace(/^#\/parameters\//, "#/components/requestBodies/");
+        } else {
+          schema2.$ref = schema2.$ref.replace(/^#\/parameters\//, "#/components/parameters/");
+        }
+      }
+      return schema2;
+    });
+    document.components ??= {};
+    const params = {};
+    const bodyParams = {};
+    const parameters = isObjectLike(document.parameters) ? document.parameters : {};
+    for (const [name, param] of Object.entries(parameters)) {
+      if (param && typeof param === "object") {
+        if ("$ref" in param) {
+          const convertedParam = transformParameterObject(param);
+          params[name] = convertedParam;
+        } else if ("in" in param) {
+          if (param.in === "body") {
+            bodyParams[name] = migrateBodyParameter(param, document.consumes ?? [DEFAULT_MEDIA_TYPE]);
+          } else if (param.in === "formData") {
+            bodyParams[name] = migrateFormDataParameter([param], document.consumes);
+          } else {
+            const convertedParam = transformParameterObject(param);
+            params[name] = convertedParam;
+          }
+        }
+      }
+    }
+    if (Object.keys(params).length > 0) {
+      ;
+      document.components.parameters = params;
+    }
+    if (Object.keys(bodyParams).length > 0) {
+      ;
+      document.components.requestBodies = bodyParams;
+    }
+    delete document.parameters;
+  }
+  if (Object.hasOwn(document, "responses") && typeof document.responses === "object" && document.responses !== null) {
+    document = traverse(document, (schema2) => {
+      if (typeof schema2.$ref === "string" && schema2.$ref.startsWith("#/responses/")) {
+        schema2.$ref = schema2.$ref.replace(/^#\/responses\//, "#/components/responses/");
+      }
+      return schema2;
+    });
+    document.components ??= {};
+    const migratedResponses = {};
+    const responses = document.responses;
+    for (const [name, response] of Object.entries(responses)) {
+      if (isObjectLike(response)) {
+        if ("$ref" in response) {
+          migratedResponses[name] = response;
+        } else {
+          const responseObj = response;
+          const produces = document.produces ?? [DEFAULT_MEDIA_TYPE];
+          if (responseObj.schema) {
+            migrateSchemaNullability(responseObj.schema);
+            if (typeof responseObj.content !== "object") {
+              responseObj.content = {};
+            }
+            for (const type of produces) {
+              ;
+              responseObj.content[type] = {
+                schema: responseObj.schema
+              };
+            }
+            delete responseObj.schema;
+          }
+          if (responseObj.examples && typeof responseObj.examples === "object") {
+            if (typeof responseObj.content !== "object") {
+              responseObj.content = {};
+            }
+            const defaultMediaType = produces[0] ?? DEFAULT_MEDIA_TYPE;
+            for (const [key, exampleValue] of Object.entries(responseObj.examples)) {
+              if (isMediaTypeKey(key)) {
+                if (typeof responseObj.content[key] !== "object") {
+                  ;
+                  responseObj.content[key] = {};
+                }
+                ;
+                responseObj.content[key].example = exampleValue;
+              } else {
+                if (typeof responseObj.content[defaultMediaType] !== "object") {
+                  ;
+                  responseObj.content[defaultMediaType] = {};
+                }
+                const mediaEntry = responseObj.content[defaultMediaType];
+                if (typeof mediaEntry.examples !== "object") {
+                  mediaEntry.examples = {};
+                }
+                ;
+                mediaEntry.examples[key] = wrapAsExampleObject(exampleValue);
+              }
+            }
+            delete responseObj.examples;
+          }
+          if (responseObj.content && typeof responseObj.content === "object") {
+            removeEmptySchemaOnlyContentEntries(responseObj.content);
+          }
+          if (isObjectLike(responseObj.headers)) {
+            responseObj.headers = Object.entries(responseObj.headers).reduce((acc, [headerName, header]) => {
+              if (header && typeof header === "object") {
+                return {
+                  [headerName]: transformResponseHeader(header),
+                  ...acc
+                };
+              }
+              return acc;
+            }, {});
+          }
+          migratedResponses[name] = responseObj;
+        }
+      }
+    }
+    if (Object.keys(migratedResponses).length > 0) {
+      ;
+      document.components.responses = migratedResponses;
+    }
+    delete document.responses;
+  }
+  if (typeof document.paths === "object") {
+    for (const path in document.paths) {
+      if (Object.hasOwn(document.paths, path)) {
+        const pathItem = isObjectLike(document.paths) && path in document.paths ? document.paths[path] : void 0;
+        if (!pathItem || typeof pathItem !== "object") {
+          continue;
+        }
+        let requestBodyObject;
+        for (const methodOrParameters in pathItem) {
+          if (methodOrParameters === "parameters" && Object.hasOwn(pathItem, methodOrParameters)) {
+            const pathItemParameters = migrateParameters(pathItem.parameters, document.consumes ?? [DEFAULT_MEDIA_TYPE]);
+            pathItem.parameters = pathItemParameters.parameters;
+            requestBodyObject = pathItemParameters.requestBody;
+          } else if (Object.hasOwn(pathItem, methodOrParameters)) {
+            const operationItem = pathItem[methodOrParameters];
+            if (requestBodyObject) {
+              operationItem.requestBody = requestBodyObject;
+            }
+            if (operationItem.parameters) {
+              const migrationResult = migrateParameters(operationItem.parameters, operationItem.consumes ?? document.consumes ?? [DEFAULT_MEDIA_TYPE]);
+              operationItem.parameters = migrationResult.parameters;
+              if (migrationResult.requestBody) {
+                operationItem.requestBody = migrationResult.requestBody;
+              }
+            }
+            delete operationItem.consumes;
+            if (operationItem.responses) {
+              for (const response in operationItem.responses) {
+                if (Object.hasOwn(operationItem.responses, response)) {
+                  const responseItem = operationItem.responses[response];
+                  if (responseItem.headers && typeof responseItem.headers === "object") {
+                    responseItem.headers = Object.entries(responseItem.headers).reduce((acc, [name, header]) => {
+                      if (header && typeof header === "object") {
+                        return {
+                          [name]: transformResponseHeader(header),
+                          ...acc
+                        };
+                      }
+                      return acc;
+                    }, {});
+                  }
+                  if (responseItem.schema) {
+                    migrateSchemaNullability(responseItem.schema);
+                    const produces = document.produces ?? operationItem.produces ?? [DEFAULT_MEDIA_TYPE];
+                    if (typeof responseItem.content !== "object") {
+                      responseItem.content = {};
+                    }
+                    for (const type of produces) {
+                      responseItem.content[type] = {
+                        schema: responseItem.schema
+                      };
+                    }
+                    delete responseItem.schema;
+                  }
+                  if (responseItem.examples && typeof responseItem.examples === "object") {
+                    if (typeof responseItem.content !== "object") {
+                      responseItem.content = {};
+                    }
+                    const produces = document.produces ?? operationItem.produces ?? [DEFAULT_MEDIA_TYPE];
+                    const defaultMediaType = produces[0] ?? DEFAULT_MEDIA_TYPE;
+                    for (const [key, exampleValue] of Object.entries(responseItem.examples)) {
+                      if (isMediaTypeKey(key)) {
+                        if (typeof responseItem.content[key] !== "object") {
+                          responseItem.content[key] = {};
+                        }
+                        responseItem.content[key].example = exampleValue;
+                      } else {
+                        if (typeof responseItem.content[defaultMediaType] !== "object") {
+                          responseItem.content[defaultMediaType] = {};
+                        }
+                        const mediaEntry = responseItem.content[defaultMediaType];
+                        if (typeof mediaEntry.examples !== "object") {
+                          mediaEntry.examples = {};
+                        }
+                        mediaEntry.examples[key] = wrapAsExampleObject(exampleValue);
+                      }
+                    }
+                    delete responseItem.examples;
+                  }
+                  if (responseItem.content && typeof responseItem.content === "object") {
+                    removeEmptySchemaOnlyContentEntries(responseItem.content);
+                  }
+                }
+              }
+            }
+            delete operationItem.produces;
+            if (operationItem.parameters?.length === 0) {
+              delete operationItem.parameters;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (document.securityDefinitions) {
+    if (typeof document.components !== "object" || document.components === null) {
+      document.components = {};
+    }
+    if (document.components && typeof document.components === "object") {
+      Object.assign(document.components, { securitySchemes: {} });
+    }
+    for (const [key, securityScheme] of Object.entries(document.securityDefinitions)) {
+      if (typeof securityScheme === "object") {
+        if ("type" in securityScheme && securityScheme.type === "oauth2") {
+          const { flow, authorizationUrl, tokenUrl, scopes } = securityScheme;
+          if (document.components && typeof document.components === "object" && "securitySchemes" in document.components && document.components.securitySchemes) {
+            Object.assign(document.components.securitySchemes, {
+              [key]: {
+                type: "oauth2",
+                flows: {
+                  [upgradeFlow(flow || "implicit")]: Object.assign({}, authorizationUrl && { authorizationUrl }, tokenUrl && { tokenUrl }, scopes && { scopes })
+                }
+              }
+            });
+          }
+        } else if ("type" in securityScheme && securityScheme.type === "basic") {
+          if (document.components && typeof document.components === "object" && "securitySchemes" in document.components && document.components.securitySchemes) {
+            Object.assign(document.components.securitySchemes, {
+              [key]: {
+                type: "http",
+                scheme: "basic"
+              }
+            });
+          }
+        } else {
+          if (document.components && typeof document.components === "object" && "securitySchemes" in document.components && document.components.securitySchemes) {
+            Object.assign(document.components.securitySchemes, {
+              [key]: securityScheme
+            });
+          }
+        }
+      }
+    }
+    delete document.securityDefinitions;
+  }
+  delete document.consumes;
+  delete document.produces;
+  return document;
+}
+var migrateSchemaNullability = (schema2) => {
+  if (!isObjectLike(schema2)) {
+    return;
+  }
+  if (typeof schema2["x-nullable"] === "boolean") {
+    if (schema2["x-nullable"]) {
+      schema2.nullable = true;
+    }
+    delete schema2["x-nullable"];
+  }
+  if (isObjectLike(schema2.properties)) {
+    for (const property of Object.values(schema2.properties)) {
+      migrateSchemaNullability(property);
+    }
+  }
+  migrateSchemaNullability(schema2.items);
+  migrateSchemaNullability(schema2.additionalProperties);
+  if (Array.isArray(schema2.allOf)) {
+    for (const member of schema2.allOf) {
+      migrateSchemaNullability(member);
+    }
+  }
+};
+function transformItemsObject(obj) {
+  const schemaProperties = [
+    "type",
+    "format",
+    "default",
+    "items",
+    "maximum",
+    "exclusiveMaximum",
+    "minimum",
+    "exclusiveMinimum",
+    "maxLength",
+    "minLength",
+    "pattern",
+    "maxItems",
+    "minItems",
+    "uniqueItems",
+    "enum",
+    "multipleOf",
+    "x-nullable"
+  ];
+  const schema2 = schemaProperties.reduce((acc, property) => {
+    if (Object.hasOwn(obj, property)) {
+      acc[property] = obj[property];
+      delete obj[property];
+    }
+    return acc;
+  }, {});
+  migrateSchemaNullability(schema2);
+  return schema2;
+}
+function getParameterLocation(location) {
+  if (location === "formData") {
+    throw new Error("Encountered a formData parameter which should have been filtered out by the caller");
+  }
+  if (location === "body") {
+    throw new Error("Encountered a body parameter which should have been filtered out by the caller");
+  }
+  return location;
+}
+function transformParameterObject(parameter) {
+  if (Object.hasOwn(parameter, "$ref") && typeof parameter.$ref === "string") {
+    return {
+      $ref: parameter.$ref
+    };
+  }
+  const serializationStyle = getParameterSerializationStyle(parameter);
+  const schema2 = transformItemsObject(parameter);
+  const { xExample, xExamples } = extractXExampleExtensions(parameter);
+  if (isNonEmptyObject(xExample)) {
+    parameter.examples = transformXExampleToExamples(xExample);
+  } else if (isNonEmptyObject(xExamples)) {
+    parameter.examples = Object.entries(xExamples).reduce((acc, [key, exampleValue]) => {
+      acc[key] = wrapAsExampleObject(exampleValue);
+      return acc;
+    }, {});
+  }
+  delete parameter.collectionFormat;
+  delete parameter.default;
+  if (!parameter.in) {
+    throw new Error('Parameter object must have an "in" property');
+  }
+  return {
+    schema: schema2,
+    ...serializationStyle,
+    ...parameter,
+    in: getParameterLocation(parameter.in)
+  };
+}
+function transformResponseHeader(header) {
+  if (Object.hasOwn(header, "$ref") && typeof header.$ref === "string") {
+    return {
+      $ref: header.$ref
+    };
+  }
+  const schema2 = transformItemsObject(header);
+  return {
+    ...header,
+    schema: schema2
+  };
+}
+var querySerialization = {
+  ssv: {
+    style: "spaceDelimited",
+    explode: false
+  },
+  pipes: {
+    style: "pipeDelimited",
+    explode: false
+  },
+  multi: {
+    style: "form",
+    explode: true
+  },
+  csv: {
+    style: "form",
+    explode: false
+  },
+  tsv: {}
+};
+var pathAndHeaderSerialization = {
+  ssv: {},
+  pipes: {},
+  multi: {},
+  csv: {
+    style: "simple",
+    explode: false
+  },
+  tsv: {}
+};
+var serializationStyles = {
+  header: pathAndHeaderSerialization,
+  query: querySerialization,
+  path: pathAndHeaderSerialization
+};
+function getParameterSerializationStyle(parameter) {
+  if (parameter.type !== "array" || !(parameter.in === "query" || parameter.in === "path" || parameter.in === "header")) {
+    return {};
+  }
+  const collectionFormat = parameter.collectionFormat ?? "csv";
+  if (parameter.in in serializationStyles && collectionFormat in serializationStyles[parameter.in]) {
+    return serializationStyles[parameter.in][collectionFormat];
+  }
+  return {};
+}
+function getFormDataEncoding(parameter) {
+  if (parameter.type !== "array" || typeof parameter.collectionFormat !== "string") {
+    return void 0;
+  }
+  const encoding = querySerialization[parameter.collectionFormat];
+  if (!encoding || Object.keys(encoding).length === 0) {
+    return void 0;
+  }
+  return encoding;
+}
+function migrateBodyParameter(bodyParameter, consumes) {
+  const { xExample, xExamples } = extractXExampleExtensions(bodyParameter);
+  delete bodyParameter.name;
+  delete bodyParameter.in;
+  const { schema: schema2, ...requestBody } = bodyParameter;
+  migrateSchemaNullability(schema2);
+  const requestBodyObject = {
+    content: {},
+    ...requestBody
+  };
+  if (requestBodyObject.content) {
+    for (const type of consumes) {
+      requestBodyObject.content[type] = {
+        schema: schema2
+      };
+      if (isNonEmptyObject(xExamples) && type in xExamples) {
+        const examples = xExamples[type];
+        const isExamplesCollection = isNonEmptyObject(examples) && Object.values(examples).every((example) => isExampleObject(example));
+        if (isExamplesCollection) {
+          requestBodyObject.content[type].examples = examples;
+        } else if (isNamedExamplesCollection(examples)) {
+          requestBodyObject.content[type].examples = Object.entries(examples).reduce((acc, [key, exampleValue]) => {
+            acc[key] = wrapAsExampleObject(exampleValue);
+            return acc;
+          }, {});
+        } else {
+          requestBodyObject.content[type].examples = {
+            default: wrapAsExampleObject(examples)
+          };
+        }
+      } else if (isNonEmptyObject(xExamples) && !Object.keys(xExamples).some(isMediaTypeKey)) {
+        requestBodyObject.content[type].examples = Object.entries(xExamples).reduce((acc, [key, exampleValue]) => {
+          acc[key] = wrapAsExampleObject(exampleValue);
+          return acc;
+        }, {});
+      }
+      if (!requestBodyObject.content[type].examples && isNonEmptyObject(xExample) && type in xExample) {
+        requestBodyObject.content[type].example = xExample[type];
+      }
+    }
+  }
+  return requestBodyObject;
+}
+function migrateFormDataParameter(parameters, consumes = ["multipart/form-data"]) {
+  const requestBodyObject = {
+    content: {}
+  };
+  const filtered = consumes.filter((type) => type === "multipart/form-data" || type === "application/x-www-form-urlencoded");
+  const contentTypes = filtered.length > 0 ? filtered : ["multipart/form-data"];
+  if (requestBodyObject.content) {
+    for (const contentType of contentTypes) {
+      requestBodyObject.content[contentType] = {
+        schema: {
+          type: "object",
+          properties: {},
+          required: []
+          // Initialize required array
+        }
+      };
+      const formContent = requestBodyObject.content?.[contentType];
+      if (formContent?.schema && typeof formContent.schema === "object" && "properties" in formContent.schema) {
+        for (const param of parameters) {
+          if (param.name && formContent.schema.properties) {
+            formContent.schema.properties[param.name] = {
+              ...transformItemsObject(structuredClone(param)),
+              // Only carry the description over when it exists, so a parameter without one does not
+              // end up with an explicit `description: undefined` on its schema.
+              ...param.description !== void 0 ? { description: param.description } : {}
+            };
+            const encoding = getFormDataEncoding(param);
+            if (encoding) {
+              formContent.encoding ??= {};
+              formContent.encoding[param.name] = encoding;
+            }
+            if (param.required && Array.isArray(formContent.schema.required)) {
+              formContent.schema.required.push(param.name);
+            }
+          }
+        }
+      }
+    }
+  }
+  return requestBodyObject;
+}
+function migrateParameters(parameters, consumes) {
+  const result = {
+    parameters: parameters.filter((parameter) => !(parameter.in === "body" || parameter.in === "formData")).map((parameter) => transformParameterObject(parameter))
+  };
+  const bodyParameter = structuredClone(parameters.find((parameter) => parameter.in === "body") ?? {});
+  if (bodyParameter && Object.keys(bodyParameter).length) {
+    result.requestBody = migrateBodyParameter(bodyParameter, consumes);
+  }
+  const formDataParameters = parameters.filter((parameter) => parameter.in === "formData");
+  if (formDataParameters.length > 0) {
+    const requestBodyObject = migrateFormDataParameter(formDataParameters, consumes);
+    if (typeof result.requestBody !== "object") {
+      result.requestBody = requestBodyObject;
+    } else {
+      result.requestBody = {
+        ...result.requestBody,
+        content: {
+          ...result.requestBody.content,
+          ...requestBodyObject.content
+        }
+      };
+    }
+    if (typeof result.requestBody !== "object") {
+      result.requestBody = {
+        content: {}
+      };
+    }
+  }
+  return result;
+}
+
+// ../../node_modules/.bun/@scalar+helpers@0.14.0/node_modules/@scalar/helpers/dist/openapi/is-schema-path.js
+var SCHEMA_SEGMENTS = /* @__PURE__ */ new Set([
+  "properties",
+  "items",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "not",
+  "additionalProperties",
+  "schema",
+  // Reusable schemas live under `components/schemas`, and `schemas` is not a
+  // fixed keyword anywhere else in the document.
+  "schemas"
+]);
+var USER_KEYED_MAPS = /* @__PURE__ */ new Set([
+  "paths",
+  "webhooks",
+  "responses",
+  "content",
+  "headers",
+  "examples",
+  "links",
+  "encoding",
+  "variables",
+  "parameters",
+  "requestBodies",
+  "securitySchemes",
+  "pathItems",
+  "scopes"
+]);
+var isSchemaPath = (path) => {
+  if (!path) {
+    return false;
+  }
+  const segments2 = path[0] === "x-ext" && path[1] !== void 0 ? path.slice(2) : path;
+  let userKeySegments = 0;
+  for (const segment of segments2) {
+    if (userKeySegments > 0) {
+      userKeySegments--;
+      continue;
+    }
+    if (SCHEMA_SEGMENTS.has(segment) || segment.endsWith("Schema")) {
+      return true;
+    }
+    if (segment === "callbacks") {
+      userKeySegments = 2;
+      continue;
+    }
+    if (USER_KEYED_MAPS.has(segment)) {
+      userKeySegments = 1;
+    }
+  }
+  return false;
+};
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/3.0-to-3.1/upgrade-from-three-to-three-one.js
+var NAMED_SCHEMA_MAP_SEGMENTS = /* @__PURE__ */ new Set(["properties", "patternProperties", "$defs", "definitions"]);
+function isNamedSchemaMap(path) {
+  const last = path?.[path.length - 1];
+  if (last === void 0) {
+    return false;
+  }
+  if (last === "schemas" && path?.[path.length - 2] === "components") {
+    return true;
+  }
+  return NAMED_SCHEMA_MAP_SEGMENTS.has(last);
+}
+var DATA_KEYWORDS = /* @__PURE__ */ new Set(["example", "default", "const", "enum"]);
+function isInsideDataValue(path) {
+  if (!path) {
+    return false;
+  }
+  for (const [index, segment] of path.entries()) {
+    if (DATA_KEYWORDS.has(segment) && !isNamedSchemaMap(path.slice(0, index))) {
+      return true;
+    }
+    if (segment === "value" && path[index - 2] === "examples" && !isNamedSchemaMap(path.slice(0, index - 2))) {
+      return true;
+    }
+  }
+  return false;
+}
+function upgradeFromThreeToThreeOne(originalContent) {
+  let content = originalContent;
+  if (content === null || typeof content.openapi !== "string" || !content.openapi.startsWith("3.0")) {
+    return content;
+  }
+  content.openapi = "3.1.1";
+  content = traverse(content, applyChangesToDocument);
+  return content;
+}
+var applyChangesToDocument = (schema2, path) => {
+  if (isInsideDataValue(path)) {
+    return schema2;
+  }
+  if (schema2.type !== void 0 && schema2.nullable === true) {
+    schema2.type = [schema2.type, "null"];
+    delete schema2.nullable;
+  } else if (schema2.nullable === true && schema2.type === void 0) {
+    if (typeof schema2.$ref === "string") {
+      const { nullable: _nullable, $ref, ...rest2 } = schema2;
+      return { ...rest2, anyOf: [{ $ref }, { type: "null" }] };
+    }
+    if (Array.isArray(schema2.allOf)) {
+      const { nullable: _nullable, allOf, ...rest2 } = schema2;
+      const base = allOf.length === 1 ? allOf[0] : { allOf };
+      return { ...rest2, anyOf: [base, { type: "null" }] };
+    }
+  }
+  if (schema2.exclusiveMinimum === true && schema2.minimum !== void 0) {
+    schema2.exclusiveMinimum = schema2.minimum;
+    delete schema2.minimum;
+  } else if (typeof schema2.exclusiveMinimum === "boolean") {
+    delete schema2.exclusiveMinimum;
+  }
+  if (schema2.exclusiveMaximum === true && schema2.maximum !== void 0) {
+    schema2.exclusiveMaximum = schema2.maximum;
+    delete schema2.maximum;
+  } else if (typeof schema2.exclusiveMaximum === "boolean") {
+    delete schema2.exclusiveMaximum;
+  }
+  const isInsideExamplesMap = path?.some((segment, index) => {
+    if (segment === "examples" && index > 0) {
+      return !isNamedSchemaMap(path.slice(0, index));
+    }
+    return false;
+  });
+  if (schema2.example !== void 0 && !isInsideExamplesMap && !isNamedSchemaMap(path)) {
+    if (isSchemaPath(path)) {
+      schema2.examples = [schema2.example];
+    } else {
+      schema2.examples = {
+        default: {
+          value: schema2.example
+        }
+      };
+    }
+    delete schema2.example;
+  }
+  const { format: _, ...rest } = schema2;
+  if (schema2.type === "string" || Array.isArray(schema2.type) && schema2.type.includes("string")) {
+    if (schema2.format === "binary") {
+      const { type: _type, ...binarySchema } = rest;
+      const hasMediaType = path?.at(-1) === "schema" && path.at(-3) === "content";
+      return hasMediaType ? binarySchema : { contentMediaType: "application/octet-stream", ...binarySchema };
+    }
+    if (schema2.format === "base64" || schema2.format === "byte") {
+      return {
+        ...rest,
+        contentEncoding: "base64"
+      };
+    }
+  }
+  if (schema2["x-webhooks"] !== void 0 && (path === void 0 || path.length === 0)) {
+    schema2.webhooks = schema2["x-webhooks"];
+    delete schema2["x-webhooks"];
+  }
+  return schema2;
+};
+
+// ../../node_modules/.bun/@scalar+openapi-upgrader@0.3.1/node_modules/@scalar/openapi-upgrader/dist/upgrade.js
+function upgrade(value, targetVersion, options) {
+  if (targetVersion === "3.2") {
+    const input = cloneDocument(value);
+    const openapi302 = upgradeFromTwoToThree(input);
+    const openapi31 = upgradeFromThreeToThreeOne(openapi302);
+    try {
+      const document = migrateThreeOneToThreeTwo(openapi31);
+      return options?.onIncompatible === "collect" ? { document, diagnostics: [] } : document;
+    } catch (error) {
+      if (options?.onIncompatible !== "collect" || !(error instanceof UpgradeIncompatibilityError)) {
+        throw error;
+      }
+      return {
+        document: upgrade(cloneDocument(value), "3.1"),
+        diagnostics: error.errors
+      };
+    }
+  }
+  const openapi30 = upgradeFromTwoToThree(value);
+  return targetVersion === "3.0" ? openapi30 : upgradeFromThreeToThreeOne(openapi30);
+}
+
+// src/implementation/openapi-document.ts
+var record = Schema_exports.decodeUnknownSync(JsonObject);
+function fail(code, reason) {
+  throw new OpenapiCompileError({ code, reason });
+}
+async function openApiDocument(input) {
+  const root = record(upgrade(structuredClone(record(input)), "3.1"));
+  const spec = Schema_exports.decodeUnknownSync(Specification)(root);
+  if (!spec.openapi.startsWith("3.1."))
+    fail("openapi_version", "This importer supports Swagger 2.0 and OpenAPI 3.0 and 3.1.");
+  const components = spec.components?.schemas ?? {};
+  const convert = JsonSchema_exports.fromSchemaOpenApi3_1;
+  const schemas = [];
+  const componentsObject = root.components === void 0 ? {} : record(root.components);
+  const masked = JSON.parse(
+    JSON.stringify(
+      { ...root, components: { ...componentsObject, schemas: {} } },
+      (key, value) => {
+        if (key !== "schema") return value;
+        const index = schemas.push(Schema_exports.decodeUnknownSync(Schema_exports.Json)(value)) - 1;
+        return { "x-executor-schema": index };
+      }
+    )
+  );
+  const resolved2 = await (await loadSwaggerClient()).resolve({
+    spec: masked,
+    skipNormalization: true,
+    useCircularStructures: false,
+    // Spec import uses the host's guarded download. References must not acquire
+    // a second, unguarded network capability inside the resolver.
+    requestInterceptor: () => fail("external_reference", "External OpenAPI references are not supported yet.")
+  });
+  const restored = record(
+    JSON.parse(JSON.stringify(resolved2.spec), (key, value) => {
+      if (key !== "schema") return value;
+      const marker = record(value)["x-executor-schema"];
+      if (typeof marker !== "number" || schemas[marker] === void 0)
+        return fail("invalid_document", "The API resolver did not preserve a schema.");
+      return schemas[marker];
+    })
+  );
+  const parsed = Schema_exports.decodeUnknownSync(Specification)({
+    ...restored,
+    components: { ...record(restored.components), schemas: components }
+  });
+  const definitions = /* @__PURE__ */ new Map();
+  const references2 = /* @__PURE__ */ new Map();
+  return {
+    spec: parsed,
+    definitions,
+    /** Inspect a component schema without expanding its children. OpenAPI object refs must already be resolved by Swagger. */
+    resolve(value) {
+      const visited = /* @__PURE__ */ new Set();
+      while (value.$ref !== void 0) {
+        const ref = value.$ref;
+        const path = typeof ref === "string" ? JsonPointer_exports.parseUriFragment(ref) : void 0;
+        if (typeof ref !== "string" || path?.length !== 3 || path[0] !== "components" || path[1] !== "schemas" || path[2] === void 0)
+          fail("external_reference", "An OpenAPI object reference could not be resolved locally.");
+        if (visited.has(ref))
+          fail("circular_reference", "A circular schema alias cannot be imported.");
+        visited.add(ref);
+        value = record(Object.hasOwn(components, path[2]) ? components[path[2]] : void 0);
+      }
+      return value;
+    },
+    /** Compose a Draft 2020-12 schema around API Schema Objects. Only values passed to
+     * `api` use the document's OpenAPI dialect; Executor-authored wrappers are already
+     * Draft 2020-12 and must not be reinterpreted. Reached components are converted once into
+     * the shared `definitions` and stay references here; nothing is inlined or copied per operation.
+     */
+    schema(build) {
+      const added = [];
+      const direct = /* @__PURE__ */ new Set();
+      const local = {};
+      const visit = (input2, direct2) => {
+        const document = convert(input2, {
+          onReference(ref) {
+            const path = JsonPointer_exports.parseUriFragment(ref);
+            const name = path?.[2];
+            if (path?.length !== 3 || path[0] !== "components" || path[1] !== "schemas" || name === void 0)
+              fail("schema_reference", "Only local component schema references are supported.");
+            const component = Object.hasOwn(components, name) ? components[name] : void 0;
+            if (component === void 0)
+              fail("missing_component", "An API schema references a missing component.");
+            direct2.add(name);
+            if (!definitions.has(name)) {
+              added.push(name);
+              definitions.set(name, {});
+              const names = /* @__PURE__ */ new Set();
+              definitions.set(name, visit(component, names));
+              references2.set(name, names);
+            }
+          }
+        });
+        return record({
+          ...document.schema,
+          ...Object.keys(document.definitions).length ? { $defs: document.definitions } : {}
+        });
+      };
+      const api = (input2) => {
+        const { $defs, ...converted } = visit(record(input2), direct);
+        for (const [name, definition] of Object.entries($defs === void 0 ? {} : record($defs))) {
+          if (Object.hasOwn(local, name) && JSON.stringify(local[name]) !== JSON.stringify(definition))
+            fail("schema_reference", "An API schema has conflicting local definitions.");
+          local[name] = definition;
+        }
+        return converted;
+      };
+      try {
+        const converted = build(api);
+        if (Object.keys(local).length) {
+          const reached = /* @__PURE__ */ new Set();
+          const pending = [...direct];
+          for (let name = pending.pop(); name !== void 0; name = pending.pop()) {
+            if (reached.has(name)) continue;
+            reached.add(name);
+            pending.push(...references2.get(name) ?? []);
+          }
+          if ([...reached].some((name) => Object.hasOwn(local, name)))
+            fail(
+              "schema_reference",
+              "An API schema has conflicting local and component definitions."
+            );
+        }
+        return {
+          ...converted,
+          ...Object.keys(local).length ? { $defs: local } : {},
+          $schema: JsonSchema_exports.META_SCHEMA_URI_DRAFT_2020_12
+        };
+      } catch (error) {
+        for (const name of added) {
+          definitions.delete(name);
+          references2.delete(name);
+        }
+        if (error instanceof OpenapiCompileError) throw error;
+        return fail(
+          "schema_keyword",
+          "An API schema cannot be converted without changing its constraints."
+        );
+      }
+    }
+  };
+}
+
+// src/implementation/openapi-names.ts
+var words = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+var camel = (value) => {
+  const [first, ...rest] = words(value);
+  return first === void 0 ? "" : `${first}${rest.map((word) => `${word[0]?.toUpperCase() ?? ""}${word.slice(1)}`).join("")}`;
+};
+var pascal = (value) => {
+  const name = camel(value);
+  return `${name[0]?.toUpperCase() ?? ""}${name.slice(1)}`;
+};
+var version = /^v\d+(?:[._-]\d+)?$/i;
+var segments = (path) => path.split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+var resourceSegments = (path) => segments(path).filter(
+  (segment) => !version.test(segment) && segment.toLowerCase() !== "api" && !(segment.startsWith("{") && segment.endsWith("}")) && camel(segment) !== ""
+);
+var groupOf = (input) => camel(input.tag ?? "") || camel(resourceSegments(input.path)[0] ?? "") || // Keep "root" for an operation on `/` or a path of only versions and parameters.
+"root";
+var fallbackLeaf = (input, group) => {
+  const resources = resourceSegments(input.path).map(camel);
+  const others = resources.filter((segment) => segment !== group);
+  const suffix = (others.length ? others : resources).map(pascal).join("");
+  return camel(`${input.method.toLowerCase()}${suffix || "Operation"}`);
+};
+var leafOf = (input, group) => {
+  if (input.operationId === void 0) return fallbackLeaf(input, group);
+  const [first, ...rest] = input.operationId.split(/[._/]+/).filter((part) => part.length > 0);
+  const seed = first !== void 0 && rest.length > 0 && camel(first).toLowerCase() === group.toLowerCase() ? rest.join(" ") : input.operationId;
+  const leaf = camel(seed);
+  return leaf === "" || leaf === group ? fallbackLeaf(input, group) : leaf;
+};
+var hash = (input) => {
+  const text = JSON.stringify([input.method.toUpperCase(), input.path, input.operationId ?? null]);
+  let value = 0;
+  for (let i = 0; i < text.length; i++) value = (value << 5) - value + text.charCodeAt(i) | 0;
+  return Math.abs(value).toString(36).padStart(8, "0").slice(0, 8);
+};
+var planOperationNames = (inputs) => {
+  const staged = inputs.map((input) => {
+    const group = groupOf(input);
+    const leaf = leafOf(input, group);
+    const versionSegment = segments(input.path).map((segment) => segment.toLowerCase()).find((segment) => version.test(segment));
+    const prefix = versionSegment === void 0 ? group : `${group}.${camel(versionSegment)}`;
+    return { input, group, leaf, prefix, versionSegment, name: `${group}.${leaf}` };
+  });
+  const refine = (rename) => {
+    const buckets = /* @__PURE__ */ new Map();
+    for (const item of staged) buckets.set(item.name, [...buckets.get(item.name) ?? [], item]);
+    for (const bucket of buckets.values())
+      if (bucket.length > 1) for (const item of bucket) item.name = rename(item);
+  };
+  refine((item) => item.versionSegment === void 0 ? item.name : `${item.prefix}.${item.leaf}`);
+  refine((item) => `${item.prefix}.${item.leaf}${pascal(item.input.method)}`);
+  refine((item) => `${item.prefix}.${item.leaf}${pascal(item.input.method)}${hash(item.input)}`);
+  return staged.map((item) => item.name);
+};
+
+// src/implementation/openapi-compile.ts
+function fail2(code, reason) {
+  throw new OpenapiCompileError({ code, reason });
+}
+var record2 = (value) => Schema_exports.decodeUnknownSync(JsonObject)(value);
+var OperationNaming = Schema_exports.Struct({
+  operationId: Schema_exports.optionalKey(Schema_exports.String),
+  tags: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.String))
+});
+var identifier = (name) => name.replace(/[^a-zA-Z0-9_]/g, "_");
+function absolute(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && url.protocol !== "http:")
+    fail2("server_protocol", "Only HTTP APIs can be imported.");
+  if (url.username || url.password || url.hash || url.search || /[{}]/.test(value))
+    fail2("server_url", "This API needs a configured server URL before import.");
+  return url.href.replace(/\/$/, "");
+}
+function serverAddress(swagger, server, connectUrl, documentServer) {
+  const variables = { ...documentServer?.variables, ...server.variables };
+  const request = record2(
+    swagger.buildRequest({
+      spec: {
+        openapi: "3.1.0",
+        servers: [{ url: server.url, variables }],
+        paths: { "/": { get: { operationId: "server" } } }
+      },
+      operationId: "server"
+    })
+  );
+  return absolute(new URL(Schema_exports.decodeUnknownSync(Schema_exports.String)(request.url), connectUrl).href);
+}
+var binaryInput = {
+  type: "string",
+  description: "File bytes encoded as base64.",
+  contentEncoding: "base64"
+};
+function responseSchema(document, operation, method) {
+  if (method === "HEAD") return { type: "null" };
+  const success = Object.entries(operation.responses ?? {}).filter(
+    ([status]) => /^2(?:[0-9]{2}|XX)$/i.test(status)
+  );
+  if (success.length === 0) return void 0;
+  const shapes = [];
+  for (const [status, response] of success) {
+    if (status === "204") {
+      shapes.push(() => ({ type: "null" }));
+      continue;
+    }
+    const content = document.resolve(response).content;
+    if (content === void 0) return void 0;
+    const media = Object.entries(record2(content));
+    if (media.length === 0) return void 0;
+    for (const [type, body] of media) {
+      if (!type.includes("json")) {
+        shapes.push(
+          () => isOpenapiTextMedia(type) ? { type: "string" } : openapiBinaryResultSchema
+        );
+        continue;
+      }
+      const schema2 = record2(body).schema;
+      if (schema2 === void 0) return void 0;
+      shapes.push((api) => api(schema2));
+    }
+  }
+  return document.schema((api) => ({
+    anyOf: shapes.map((shape) => shape(api))
+  }));
+}
+function resolvedOrUndefined(document, value) {
+  try {
+    return document.resolve(record2(value));
+  } catch (error) {
+    if (!(error instanceof OpenapiCompileError) && !Schema_exports.isSchemaError(error)) throw error;
+    return void 0;
+  }
+}
+function errorContent(document, response) {
+  try {
+    return document.resolve(response).content;
+  } catch (error) {
+    if (!(error instanceof OpenapiCompileError) && !Schema_exports.isSchemaError(error)) throw error;
+    return void 0;
+  }
+}
+function errorResponses(document, operation) {
+  const errors = [];
+  const tagged = Schema_exports.Struct({
+    description: Schema_exports.optionalKey(Schema_exports.String),
+    required: Schema_exports.Array(Schema_exports.String),
+    properties: Schema_exports.Record(Schema_exports.String, JsonObject)
+  });
+  const visit = (status, input, visited = /* @__PURE__ */ new Set(), parents = []) => {
+    const object2 = Schema_exports.decodeUnknownOption(JsonObject)(input);
+    if (Option_exports.isNone(object2)) return;
+    const value = object2.value;
+    try {
+      if (typeof value.$ref === "string" && visited.has(value.$ref)) return;
+      const next = typeof value.$ref === "string" ? /* @__PURE__ */ new Set([...visited, value.$ref]) : visited;
+      const shape = document.resolve(value);
+      const variants = shape.anyOf;
+      if (Array.isArray(variants)) {
+        for (const variant of variants) visit(status, variant, next, [...parents, value]);
+        return;
+      }
+      const parsed = Schema_exports.decodeUnknownOption(tagged)(shape);
+      if (Option_exports.isNone(parsed) || !parsed.value.required.includes("_tag")) return;
+      const tag = parsed.value.properties._tag;
+      if (tag === void 0) return;
+      const code = typeof tag.const === "string" ? tag.const : Array.isArray(tag.enum) && tag.enum.length === 1 ? tag.enum[0] : void 0;
+      const message = parsed.value.properties.message;
+      const messageShape = message === void 0 ? void 0 : document.resolve(message);
+      const hasMessage = messageShape !== void 0 && (messageShape.type === "string" || typeof messageShape.const === "string" || Array.isArray(messageShape.enum) && messageShape.enum.length > 0 && messageShape.enum.every((value2) => typeof value2 === "string"));
+      const declaration = Schema_exports.decodeUnknownOption(OpenapiErrorResponse)({
+        code,
+        status,
+        message: hasMessage ? { source: "body" } : { source: "schema", value: parsed.value.description },
+        schema: document.schema((api) => ({ allOf: [...parents, value].map(api) }))
+      });
+      if (Option_exports.isSome(declaration)) errors.push(declaration.value);
+    } catch (error) {
+      if (!(error instanceof OpenapiCompileError) && !Schema_exports.isSchemaError(error)) throw error;
+    }
+  };
+  for (const [status, response] of Object.entries(operation.responses ?? {})) {
+    if (!/^[45][0-9]{2}$/.test(status)) continue;
+    const content = errorContent(document, response);
+    if (content === void 0) continue;
+    for (const [type, body] of Object.entries(record2(content))) {
+      if (!type.split(";")[0]?.trim().match(/^application\/(?:[\w.-]+\+)?json$/i))
+        continue;
+      const schema2 = record2(body).schema;
+      if (schema2 !== void 0) visit(Number(status), schema2);
+    }
+  }
+  return errors;
+}
+var compileOpenApiDocument = (entry, inputDocument, options = {}) => Effect_exports.tryPromise({
+  try: async () => {
+    const document = await openApiDocument(inputDocument);
+    const swagger = await loadSwaggerClient();
+    const { spec } = document;
+    const schemes = { ...options.securitySchemes ?? spec.components?.securitySchemes };
+    const bindings = /* @__PURE__ */ new Map();
+    const oauth = [];
+    for (const [name, source] of Object.entries(schemes)) {
+      const scheme = document.resolve(source);
+      if (scheme.type === "http" && scheme.scheme === "bearer" || scheme.type === "apiKey" && (scheme.in === "header" || scheme.in === "query" || scheme.in === "cookie") && typeof scheme.name === "string") {
+        bindings.set(name, [
+          {
+            scheme: name,
+            field: "token",
+            part: "value",
+            prefix: ""
+          }
+        ]);
+      } else if (scheme.type === "http" && scheme.scheme === "basic") {
+        bindings.set(name, [
+          { scheme: name, field: "username", part: "username", prefix: "" },
+          { scheme: name, field: "password", part: "password", prefix: "" }
+        ]);
+      } else if (scheme.type === "oauth2") {
+        const code = record2(scheme.flows).authorizationCode;
+        if (code !== void 0) {
+          const flow = record2(code);
+          if (typeof flow.authorizationUrl === "string" && typeof flow.tokenUrl === "string")
+            oauth.push({
+              name,
+              config: entry.oauthDiscoveryUrl === void 0 ? {
+                authorizationUrl: absolute(
+                  new URL(flow.authorizationUrl, entry.connectUrl).href
+                ),
+                tokenUrl: absolute(new URL(flow.tokenUrl, entry.connectUrl).href),
+                scopes: [
+                  ...entry.scopes ?? Object.keys(record2(flow.scopes ?? {}))
+                ].sort()
+              } : { discover: absolute(entry.oauthDiscoveryUrl) }
+            });
+        }
+      }
+    }
+    let fallback = options.fallbackSecurity;
+    if (bindings.size === 0 && Object.keys(schemes).length === 0 && entry.auth?.header !== void 0) {
+      const header = /^([!#$%&'*+.^_`|~A-Za-z0-9-]+):\s*([^{}\r\n]*)\{[A-Za-z0-9_]+\}$/.exec(
+        entry.auth.header
+      );
+      if (!header?.[1] || header[2] === void 0)
+        fail2("auth_helper", "This catalog entry needs a custom authentication helper.");
+      bindings.set("apiKey", [
+        {
+          scheme: "apiKey",
+          field: "token",
+          part: "value",
+          prefix: header[2]
+        }
+      ]);
+      schemes.apiKey = { type: "apiKey", in: "header", name: header[1] };
+      fallback = [{ apiKey: [] }];
+    }
+    if (!fallback && !Object.keys(schemes).length && entry.auth && !["none", "public"].includes(entry.auth.kind))
+      fail2(
+        "auth_missing",
+        "This entry does not declare enough authentication details to generate an app."
+      );
+    const methods = /* @__PURE__ */ new Map();
+    const operations = [];
+    const skipped = /* @__PURE__ */ new Set();
+    const causes = /* @__PURE__ */ new Map();
+    const built = [];
+    const documentServer = spec.servers?.[0];
+    const candidates = Object.entries(spec.paths).flatMap(([path, source]) => {
+      const item = document.resolve(source);
+      return ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"].filter((method) => item[method.toLowerCase()] !== void 0).map((method) => ({ path, item, method }));
+    });
+    if (!candidates.length) fail2("no_operations", "This API does not contain any operations.");
+    const names = planOperationNames(
+      candidates.map(({ path, item, method }) => {
+        const naming = Schema_exports.decodeUnknownOption(OperationNaming)(
+          resolvedOrUndefined(document, item[method.toLowerCase()])
+        ).pipe(Option_exports.getOrUndefined);
+        return {
+          operationId: naming?.operationId,
+          tag: naming?.tags?.find((tag) => tag.trim() !== ""),
+          method,
+          path
+        };
+      })
+    );
+    for (const [index, { path, item, method }] of candidates.entries()) {
+      try {
+        if (!path.startsWith("/") || path.includes("?") || path.includes("#"))
+          fail2("operation_path", "An operation has an invalid API path.");
+        const operationMethods = [];
+        const resolved2 = document.resolve(record2(item[method.toLowerCase()]));
+        const operation = Schema_exports.decodeUnknownSync(Operation)(resolved2);
+        const tags = Option_exports.getOrUndefined(
+          Schema_exports.decodeUnknownOption(Schema_exports.Array(Schema_exports.NonEmptyString))(resolved2.tags)
+        );
+        const name = names[index] ?? fail2("operation_path", "An operation has no name.");
+        if (built.some((op) => op.operation.name === name))
+          fail2(
+            "duplicate_operation",
+            "The API has duplicate tool names. Update its operation IDs first."
+          );
+        const serverList = operation.servers ?? (Array.isArray(item.servers) ? Schema_exports.decodeUnknownSync(Specification.fields.servers)(item.servers) : void 0) ?? spec.servers;
+        const server = serverList?.[0];
+        const serverUrl = options.baseUrl ?? server?.url;
+        if (serverUrl === void 0)
+          fail2("server_missing", "The API has no server URL. Set an API base URL and try again.");
+        const baseUrl = serverAddress(
+          swagger,
+          options.baseUrl === void 0 && server !== void 0 ? server : { url: serverUrl },
+          entry.connectUrl,
+          documentServer
+        );
+        const combined = [
+          ...Array.isArray(item.parameters) ? item.parameters : [],
+          ...operation.parameters ?? []
+        ];
+        const parameters = /* @__PURE__ */ new Map();
+        for (const parameter of combined) {
+          const p = Schema_exports.decodeUnknownSync(OpenapiParameter)(document.resolve(record2(parameter)));
+          parameters.set(`${p.in}:${p.name}`, p);
+        }
+        const groups = /* @__PURE__ */ new Map();
+        for (const p of parameters.values()) {
+          const key = p.in === "header" ? "headers" : p.in;
+          const group = groups.get(key) ?? { properties: {}, required: [] };
+          const content = p.content === void 0 ? void 0 : Object.values(p.content)[0];
+          group.properties[p.name] = p.schema ?? (content === void 0 ? {} : record2(content).schema ?? {});
+          if (p.required || p.in === "path") group.required.push(p.name);
+          groups.set(key, group);
+        }
+        const properties = {};
+        const required = [];
+        for (const [key, group] of groups) {
+          properties[key] = (api) => ({
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(group.properties).map(([name2, schema2]) => [name2, api(schema2)])
+            ),
+            required: group.required,
+            additionalProperties: false
+          });
+          if (group.required.length) required.push(key);
+        }
+        const bodyVariants = [];
+        let retainedBody;
+        if (operation.requestBody) {
+          const request = Schema_exports.decodeUnknownSync(OpenapiRequestBody)(
+            document.resolve(operation.requestBody)
+          );
+          const retainedContent = {};
+          for (const [contentType, content] of Object.entries(request.content)) {
+            const kind = openapiMediaKind(contentType);
+            const schema2 = document.resolve(content.schema ?? {});
+            const declared = content.schema ?? {};
+            const retainedFiles = {};
+            let inputSchema = kind === "binary" ? () => binaryInput : kind === "text" ? () => ({ type: "string" }) : (api) => api(declared);
+            if (kind === "multipart") {
+              const fields = { ...record2(schema2.properties ?? {}) };
+              const files = {};
+              for (const [key, field] of Object.entries(fields)) {
+                const shape = document.resolve(record2(field));
+                if (isOpenapiFileSchema(shape)) {
+                  delete fields[key];
+                  files[key] = binaryInput;
+                  retainedFiles[key] = shape;
+                }
+              }
+              const form = schema2;
+              inputSchema = (api) => {
+                const converted = api({ ...form, properties: fields });
+                return {
+                  ...converted,
+                  properties: { ...record2(converted.properties ?? {}), ...files }
+                };
+              };
+            }
+            retainedContent[contentType] = {
+              ...content.encoding === void 0 ? {} : { encoding: content.encoding },
+              ...Object.keys(retainedFiles).length ? { schema: { type: "object", properties: retainedFiles } } : {}
+            };
+            const first = bodyVariants.length === 0;
+            bodyVariants.push((api) => ({
+              properties: { contentType: { enum: [contentType] }, body: inputSchema(api) },
+              ...first ? {} : { required: ["contentType"] }
+            }));
+          }
+          retainedBody = { ...request, content: retainedContent };
+          if (!bodyVariants.length)
+            fail2("request_body", `Tool ${name} has no request media types.`);
+          properties.body = () => ({});
+          properties.contentType = () => ({
+            type: "string",
+            enum: Object.keys(request.content),
+            description: "Request media type. Defaults to the first declared type."
+          });
+          if (request.required) required.push("body");
+        }
+        const security = operation.security ?? spec.security ?? fallback ?? [];
+        for (const requirement of security) {
+          const keys = Object.keys(requirement).sort();
+          if (!keys.length) continue;
+          if (!keys.every((key) => bindings.has(key))) continue;
+          const parts = keys.flatMap((key) => bindings.get(key) ?? []);
+          const methodName = bindings.size === 1 && keys.length === 1 ? "apiKey" : keys.join("_and_");
+          operationMethods.push({
+            name: methodName,
+            label: parts.length === 1 ? "API key" : keys.join(" + "),
+            bindings: parts.map((part) => ({
+              ...part,
+              field: keys.length === 1 ? part.field : `${identifier(part.scheme)}_${part.field}`
+            }))
+          });
+        }
+        const input = document.schema((api) => ({
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(properties).map(([key, shape]) => [key, shape(api)])
+          ),
+          required,
+          ...bodyVariants.length ? { anyOf: bodyVariants.map((variant) => variant(api)) } : {},
+          additionalProperties: false
+        }));
+        try {
+          jsonSchema(input);
+        } catch {
+          fail2(
+            "input_schema",
+            `Tool ${name} has an input schema this importer cannot preserve yet.`
+          );
+        }
+        const outputSchema = responseSchema(document, operation, method);
+        const streaming = Object.values(operation.responses ?? {}).some((response) => {
+          const content = errorContent(document, response);
+          return content !== void 0 && Object.hasOwn(record2(content), "text/event-stream");
+        });
+        built.push({
+          methods: operationMethods,
+          operation: {
+            ...streaming ? { streaming: true } : {},
+            ...tags === void 0 || tags.length === 0 ? {} : { tags },
+            name,
+            ...operation.operationId === void 0 ? {} : { operationId: operation.operationId },
+            description: operation.summary ?? operation.description ?? name,
+            method,
+            path,
+            baseUrl,
+            openapi: spec.openapi,
+            securitySchemes: Object.fromEntries(
+              [...new Set(security.flatMap(Object.keys))].map((key) => [
+                key,
+                schemes[key] ?? fail2("auth_method", "A security requirement names a missing scheme.")
+              ])
+            ),
+            request: {
+              parameters: [...parameters.values()],
+              ...retainedBody === void 0 ? {} : { requestBody: retainedBody },
+              security,
+              responses: Object.fromEntries(
+                Object.entries(operation.responses ?? {}).flatMap(([status, response]) => {
+                  const content = errorContent(document, response);
+                  return content === void 0 ? [] : [
+                    [
+                      status,
+                      {
+                        content: Object.fromEntries(
+                          Object.keys(record2(content)).map((type) => [type, {}])
+                        )
+                      }
+                    ]
+                  ];
+                })
+              )
+            },
+            input,
+            ...outputSchema === void 0 ? {} : { outputSchema },
+            errorResponses: errorResponses(document, operation)
+          }
+        });
+      } catch (error) {
+        if (!(error instanceof OpenapiCompileError) && !Schema_exports.isSchemaError(error)) throw error;
+        const code = error instanceof OpenapiCompileError ? error.code : "invalid_document";
+        if (error instanceof OpenapiCompileError && !causes.has(code)) causes.set(code, error);
+        skipped.add(code);
+      }
+    }
+    const counts = /* @__PURE__ */ new Map();
+    for (const { operation } of built) {
+      const origin = new URL(operation.baseUrl).origin;
+      counts.set(origin, (counts.get(origin) ?? 0) + 1);
+    }
+    let documentOrigin;
+    try {
+      if (documentServer !== void 0)
+        documentOrigin = new URL(serverAddress(swagger, documentServer, entry.connectUrl)).origin;
+    } catch (error) {
+      if (!(error instanceof OpenapiCompileError)) throw error;
+    }
+    let pinnedOrigin = options.allowedOrigin;
+    for (const [origin, count] of options.allowedOrigin === void 0 ? counts : []) {
+      const best = pinnedOrigin === void 0 ? 0 : counts.get(pinnedOrigin) ?? 0;
+      if (count > best || count === best && origin === documentOrigin) pinnedOrigin = origin;
+    }
+    for (const { operation, methods: operationMethods } of built) {
+      if (new URL(operation.baseUrl).origin !== pinnedOrigin) {
+        skipped.add("multiple_hosts");
+        continue;
+      }
+      operations.push(operation);
+      for (const method of operationMethods) methods.set(method.name, method);
+    }
+    if (!operations.length) {
+      const [only, ...others] = causes.values();
+      if (only !== void 0 && others.length === 0 && [...skipped].every((reason) => reason === only.code))
+        throw only;
+      fail2(
+        "no_supported_operations",
+        "Executor cannot import any operation in this API definition."
+      );
+    }
+    if (!operations.some(
+      (operation) => operation.streaming !== true && (operation.request.security.length === 0 || operation.request.security.some((requirement) => {
+        const keys = Object.keys(requirement);
+        return keys.every((key) => bindings.has(key)) || keys.length === 1 && oauth.some((method) => method.name === keys[0]);
+      }))
+    ))
+      fail2(
+        "no_supported_operations",
+        "This API has no operations supported by the available authentication and response transports."
+      );
+    return {
+      operations,
+      definitions: Object.fromEntries(document.definitions),
+      methods: Object.fromEntries(
+        [...methods.values()].map((method) => [method.name, method.bindings])
+      ),
+      secrets: [...methods.values()],
+      oauth,
+      schemes,
+      pinnedOrigin,
+      fallback
+    };
+  },
+  catch: (error) => error instanceof OpenapiCompileError ? error : new OpenapiCompileError({
+    code: "invalid_document",
+    reason: "This API definition could not be read. It may contain unsupported OpenAPI features."
+  })
+});
+
+// src/implementation/openapi-source.ts
+var Manifest = Schema_exports.Struct({
+  revision: Schema_exports.String,
+  pages: Schema_exports.Number,
+  meta: Schema_exports.optionalKey(RouterMeta)
+});
+var DocumentInfo = Schema_exports.Struct({
+  info: Schema_exports.optionalKey(
+    Schema_exports.Struct({
+      title: Schema_exports.optionalKey(Schema_exports.String),
+      summary: Schema_exports.optionalKey(Schema_exports.String),
+      description: Schema_exports.optionalKey(Schema_exports.String)
+    })
   ),
+  tags: Schema_exports.optionalKey(
+    Schema_exports.Array(
+      Schema_exports.Struct({
+        name: Schema_exports.NonEmptyString,
+        description: Schema_exports.optionalKey(Schema_exports.String)
+      })
+    )
+  )
+});
+var documentMeta = (document) => {
+  const parsed = Schema_exports.decodeUnknownOption(DocumentInfo)(document);
+  if (Option_exports.isNone(parsed)) return void 0;
+  const { info, tags } = parsed.value;
+  const description = info?.description ?? info?.summary;
+  const labels = (tags ?? []).flatMap(
+    (tag) => tag.description === void 0 ? [] : [[tag.name, tag.description]]
+  );
+  const meta = {
+    ...info?.title === void 0 ? {} : { title: info.title },
+    ...description === void 0 ? {} : { description },
+    ...labels.length === 0 ? {} : { tags: Object.fromEntries(labels) }
+  };
+  return Object.keys(meta).length === 0 ? void 0 : meta;
+};
+var Names = Schema_exports.Array(Schema_exports.String);
+var StoredEntry = Schema_exports.fromJsonString(Schema_exports.Struct({ value: JsonValue }));
+var schema = (decoder) => wrap(decoder, false);
+var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
+var invalid = () => new OpenapiError({ reason: "invalid_definition" });
+var pageSize = 64;
+var format = "openapi-v2";
+var sha256 = (text) => invoke(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))).pipe(
+  Effect_exports.map(
+    (hash2) => Array.from(new Uint8Array(hash2), (byte) => byte.toString(16).padStart(2, "0")).join("")
+  )
+);
+var partConcurrency = 4;
+var resolved = /* @__PURE__ */ new Map();
+var resolvedBytes = 0;
+var remember = (key, entry) => {
+  const bytes2 = new TextEncoder().encode(
+    JSON.stringify([entry.operation, entry.definitions])
+  ).byteLength;
+  if (bytes2 > 8e6) return;
+  const previous = resolved.get(key);
+  if (previous !== void 0) {
+    resolvedBytes -= previous.bytes;
+    resolved.delete(key);
+  }
+  while (resolved.size >= 32 || resolvedBytes + bytes2 > 8e6) {
+    const oldest = resolved.keys().next().value;
+    if (oldest === void 0) break;
+    resolvedBytes -= resolved.get(oldest)?.bytes ?? 0;
+    resolved.delete(oldest);
+  }
+  resolved.set(key, { ...entry, bytes: bytes2 });
+  resolvedBytes += bytes2;
+};
+var stored = /* @__PURE__ */ new Map();
+var storedBytes = 0;
+var storedPart = (kind, name) => JSON.stringify([kind, name]);
+var retain = (revision, parts, bytes2) => {
+  if (bytes2 > 8e6) return;
+  const previous = stored.get(revision);
+  if (previous !== void 0) {
+    storedBytes -= previous.bytes;
+    stored.delete(revision);
+  }
+  while (stored.size >= 4 || storedBytes + bytes2 > 8e6) {
+    const oldest = stored.keys().next().value;
+    if (oldest === void 0) break;
+    storedBytes -= stored.get(oldest)?.bytes ?? 0;
+    stored.delete(oldest);
+  }
+  stored.set(revision, { parts, bytes: bytes2 });
+  storedBytes += bytes2;
+};
+function patchOpenapi(root, patches) {
+  let result = root;
+  for (const patch of patches ?? []) {
+    if (!patch.path.startsWith("/")) throw invalid();
+    const path = patch.path.slice(1).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+    if (path.some((part) => ["__proto__", "constructor", "prototype"].includes(part)))
+      throw invalid();
+    const update = (node, parts) => {
+      const [head, ...rest] = parts;
+      if (head === void 0) throw invalid();
+      if (rest.length)
+        return {
+          ...node,
+          [head]: update(
+            Schema_exports.decodeUnknownSync(JsonObject)(
+              Object.hasOwn(node, head) ? node[head] : void 0
+            ),
+            rest
+          )
+        };
+      if (patch.op !== "add" && !Object.hasOwn(node, head)) throw invalid();
+      if (patch.op === "remove")
+        return Object.fromEntries(Object.entries(node).filter(([name]) => name !== head));
+      if (patch.value === void 0) throw invalid();
+      return { ...node, [head]: patch.value };
+    };
+    result = update(result, path);
+  }
+  return result;
+}
+var download = (url, context) => Effect_exports.gen(function* () {
+  const response = yield* invoke(
+    () => context.fetch(url, { signal: context.signal, redirect: "manual" })
+  );
+  if (!response.ok || response.body === null) return yield* invalid();
+  const reader = response.body.getReader();
+  const text = yield* Effect_exports.acquireUseRelease(
+    Effect_exports.succeed(reader),
+    (reader2) => Effect_exports.gen(function* () {
+      const decoder = new TextDecoder();
+      const chunks = [];
+      let bytes2 = 0;
+      while (true) {
+        const chunk = yield* invoke(() => reader2.read());
+        if (chunk.done) break;
+        bytes2 += chunk.value.byteLength;
+        if (bytes2 > 4e7) return yield* invalid();
+        chunks.push(decoder.decode(chunk.value, { stream: true }));
+      }
+      chunks.push(decoder.decode());
+      return chunks.join("");
+    }),
+    (reader2) => invoke(() => reader2.cancel()).pipe(Effect_exports.catch(() => Effect_exports.void))
+  );
+  return yield* Effect_exports.try({
+    try: () => Schema_exports.decodeUnknownSync(JsonObject)(
+      text.trimStart().startsWith("{") ? JSON.parse(text) : parse(text)
+    ),
+    catch: invalid
+  });
+});
+var liveOpenapiRouter = (options) => {
+  const freshFor = options.freshFor ?? "5 minutes";
+  const staleFor = options.staleFor ?? "1 day";
+  const retention = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)) + Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor)) + 3e5;
+  const identity = Effect_exports.cached(
+    Effect_exports.tryPromise({
+      try: async () => {
+        const bytes2 = new TextEncoder().encode(
+          JSON.stringify({
+            source: options.source,
+            allowedOrigin: options.allowedOrigin,
+            baseUrl: options.baseUrl,
+            securitySchemes: options.securitySchemes,
+            patches: options.patches,
+            fallbackSecurity: options.fallbackSecurity
+          })
+        );
+        const hash2 = await crypto.subtle.digest("SHA-256", bytes2);
+        return Array.from(new Uint8Array(hash2), (byte) => byte.toString(16).padStart(2, "0")).join(
+          ""
+        );
+      },
+      catch: invalid
+    })
+  );
+  const sourceId = Effect_exports.runSync(identity);
+  const pointer = sourceId.pipe(Effect_exports.map((id) => [format, id, "current"]));
+  const partKey = (revision, kind, name) => [
+    format,
+    revision,
+    kind,
+    name
+  ];
+  const refresh = (context) => Effect_exports.gen(function* () {
+    const raw = "url" in options.source ? yield* download(options.source.url, context) : options.source.document;
+    const document = patchOpenapi(raw, options.patches);
+    const compiled = yield* compileOpenApiDocument(
+      { name: "API", ..."url" in options.source ? { connectUrl: options.source.url } : {} },
+      document,
+      {
+        allowedOrigin: options.allowedOrigin,
+        securitySchemes: options.securitySchemes,
+        ...options.fallbackSecurity === void 0 ? {} : { fallbackSecurity: options.fallbackSecurity },
+        ...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl }
+      }
+    );
+    const revision = yield* sha256(JSON.stringify([format, yield* sourceId, document]));
+    const names = compiled.operations.map((operation) => operation.name);
+    const parts = [
+      ...compiled.operations.map((operation) => ({
+        kind: "operation",
+        name: operation.name,
+        value: operation
+      })),
+      ...Object.entries(compiled.definitions).map(([name, value]) => ({
+        kind: "definition",
+        name,
+        value
+      }))
+    ];
+    const pages = Math.ceil(names.length / pageSize);
+    for (let page = 0; page < pages; page++)
+      parts.push({
+        kind: "names",
+        name: page,
+        value: names.slice(page * pageSize, (page + 1) * pageSize)
+      });
+    const batches = [];
+    let batch = [];
+    let size = 0;
+    const retained = /* @__PURE__ */ new Map();
+    let retainedBytes = 0;
+    for (const part of parts) {
+      const entry = { key: partKey(revision, part.kind, part.name), value: part.value };
+      const text = JSON.stringify(entry);
+      const bytes2 = new TextEncoder().encode(text).byteLength;
+      if (batch.length && (batch.length >= 64 || size + bytes2 > 4e6)) {
+        batches.push({ entries: batch, bytes: size });
+        batch = [];
+        size = 0;
+      }
+      batch.push(entry);
+      size += bytes2;
+      retainedBytes += bytes2;
+      if (retainedBytes <= 8e6)
+        retained.set(
+          storedPart(part.kind, part.name),
+          Schema_exports.decodeUnknownSync(StoredEntry)(text).value
+        );
+    }
+    if (batch.length) batches.push({ entries: batch, bytes: size });
+    yield* Effect_exports.forEach(
+      batches,
+      ({ entries, bytes: bytes2 }, index) => fromPromise(context.cache.write)(entries, retention).pipe(
+        Effect_exports.withSpan("app.cache.flush", {
+          attributes: {
+            "cache.flush.index": index,
+            "cache.flush.count": batches.length,
+            "cache.flush.entries": entries.length,
+            "cache.flush.bytes": bytes2
+          }
+        })
+      ),
+      {
+        concurrency: partConcurrency,
+        discard: true
+      }
+    );
+    retain(revision, retained, retainedBytes);
+    const meta = documentMeta(document);
+    return { revision, pages, ...meta === void 0 ? {} : { meta } };
+  });
+  let reading;
+  const current = Effect_exports.suspend(() => {
+    const shared = reading;
+    if (shared !== void 0) return Deferred_exports.await(shared);
+    const deferred = Deferred_exports.makeUnsafe();
+    reading = deferred;
+    return pointer.pipe(
+      Effect_exports.flatMap(
+        (key) => fromPromise(options.cache.get)({
+          key,
+          schema: schema(Manifest),
+          freshFor,
+          staleFor,
+          load: toPromise(refresh)
+        })
+      ),
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (reading === deferred) reading = void 0;
+        }).pipe(Effect_exports.andThen(Deferred_exports.done(deferred, exit)))
+      )
+    );
+  });
+  const read = (revision, kind, names, decoder) => {
+    const retained = stored.get(revision);
+    return retained === void 0 ? fromPromise(options.cache.readMany)(
+      names.map((name) => partKey(revision, kind, name)),
+      schema(decoder)
+    ) : Effect_exports.forEach(names, (name) => {
+      const value = retained.parts.get(storedPart(kind, name));
+      return value === void 0 ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoder)(value);
+    });
+  };
+  const namesFor = (manifest) => Effect_exports.gen(function* () {
+    const names = [];
+    for (let page = 0; page < manifest.pages; page += pageSize) {
+      const pages = yield* read(
+        manifest.revision,
+        "names",
+        Array.from({ length: Math.min(pageSize, manifest.pages - page) }, (_, i) => page + i),
+        Names
+      );
+      for (const values of pages) {
+        if (values === void 0) return void 0;
+        names.push(...values);
+      }
+    }
+    return names;
+  });
+  const definitionsFor = (revision, operation) => Effect_exports.gen(function* () {
+    const definitions = {};
+    const seen = /* @__PURE__ */ new Set();
+    let pending = [...references(operation)];
+    while (pending.length) {
+      const names = [...new Set(pending.splice(0, pageSize * partConcurrency))].filter(
+        (name) => !seen.has(name)
+      );
+      names.forEach((name) => seen.add(name));
+      if (!names.length) continue;
+      const values = (yield* Effect_exports.forEach(
+        Array.from(
+          { length: Math.ceil(names.length / pageSize) },
+          (_, page) => names.slice(page * pageSize, (page + 1) * pageSize)
+        ),
+        (batch) => read(revision, "definition", batch, JsonObject),
+        { concurrency: partConcurrency }
+      )).flat();
+      for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        const value = values[i];
+        if (name === void 0 || value === void 0) return void 0;
+        definitions[name] = value;
+        pending.push(...references(value));
+      }
+    }
+    return definitions;
+  });
+  const defaultedNames = JSON.stringify(
+    Object.entries(options.parameterDefaults ?? {}).map(([group, values]) => [
+      group,
+      Object.keys(values ?? {}).sort()
+    ])
+  );
+  const kindOf = (op) => {
+    const key = op.operationId ?? op.name;
+    const kinds = options.kinds ?? {};
+    return Object.hasOwn(kinds, key) ? kinds[key] ?? "mutation" : ["GET", "HEAD", "OPTIONS"].includes(op.method) ? "query" : "mutation";
+  };
+  const readOnly = (op) => kindOf(op) === "query";
+  const operationsFor = (manifest) => Effect_exports.gen(function* () {
+    const names = yield* namesFor(manifest);
+    if (names === void 0) return void 0;
+    const pages = yield* Effect_exports.forEach(
+      Array.from(
+        { length: Math.ceil(names.length / pageSize) },
+        (_, page) => names.slice(page * pageSize, (page + 1) * pageSize)
+      ),
+      (batch) => read(manifest.revision, "operation", batch, OpenapiOperation),
+      { concurrency: partConcurrency }
+    );
+    const all = [];
+    for (const operations of pages) {
+      for (const operation of operations) {
+        if (operation === void 0) return void 0;
+        all.push(operation);
+      }
+    }
+    return all;
+  });
+  const summarize = (operation) => ({
+    name: operation.name,
+    description: operation.description,
+    readOnly: readOnly(operation),
+    ...operation.tags === void 0 ? {} : { tags: operation.tags }
+  });
+  const describe = (operation, bundle) => ({
+    ...summarize(operation),
+    inputSchema: bundle(parameterDefaultsInput(operation, options.parameterDefaults, true)),
+    ...operation.outputSchema === void 0 ? {} : { outputSchema: bundle(operation.outputSchema) }
+  });
+  const withRevision = (work) => Effect_exports.gen(function* () {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const result = yield* work(yield* current);
+      if (result !== void 0) return result.value;
+      yield* fromPromise(options.cache.invalidate)(yield* pointer);
+    }
+    return yield* invalid();
+  });
+  return routerDeclaration({
+    kind: "dynamic",
+    meta: () => current.pipe(Effect_exports.map((manifest) => manifest.meta ?? {})),
+    resolve: (name) => withRevision(
+      (manifest) => Effect_exports.gen(function* () {
+        const raw = name;
+        const memoKey = `${manifest.revision}/${defaultedNames}/${raw}`;
+        const memo = resolved.get(memoKey);
+        const operation = memo?.operation ?? (yield* read(manifest.revision, "operation", [raw], OpenapiOperation))[0];
+        if (operation === void 0) {
+          const names = yield* namesFor(manifest);
+          return names === void 0 || names.includes(raw) ? void 0 : { value: void 0 };
+        }
+        const definitions = memo?.definitions ?? (yield* definitionsFor(manifest.revision, operation));
+        if (definitions === void 0) return void 0;
+        const schemas = memo?.schemas ?? (yield* prepareOpenapiOperation(operation, definitions, options.parameterDefaults));
+        if (memo === void 0) remember(memoKey, { operation, definitions, schemas });
+        const tools = yield* openapiToolsEffect(
+          { ...options, operations: [operation], definitions },
+          /* @__PURE__ */ new Map([[operation.name, schemas]])
+        );
+        const declarations = protocolOperations(tools, {
+          [operation.name]: kindOf(operation)
+        });
+        const declaration = Object.hasOwn(declarations, raw) ? declarations[raw] : void 0;
+        return { value: declaration === void 0 ? void 0 : nativeOperation(declaration) };
+      })
+    ),
+    list: () => withRevision(
+      (manifest) => Effect_exports.gen(function* () {
+        const all = yield* operationsFor(manifest);
+        if (all === void 0) return void 0;
+        const definitions = yield* definitionsFor(manifest.revision, all);
+        if (definitions === void 0) return void 0;
+        const bundle = bundler(definitions);
+        const request = createRequest(options);
+        return {
+          value: all.filter((op) => request.available(op, options.account)).map((operation) => describe(operation, bundle))
+        };
+      })
+    ),
+    summaries: () => withRevision(
+      (manifest) => Effect_exports.gen(function* () {
+        const all = yield* operationsFor(manifest);
+        if (all === void 0) return void 0;
+        const request = createRequest(options);
+        return {
+          value: all.filter((op) => request.available(op, options.account)).map((operation) => summarize(operation))
+        };
+      })
+    ),
+    describe: (name) => withRevision(
+      (manifest) => Effect_exports.gen(function* () {
+        const raw = name;
+        const operation = (yield* read(
+          manifest.revision,
+          "operation",
+          [raw],
+          OpenapiOperation
+        ))[0];
+        if (operation === void 0) {
+          const names = yield* namesFor(manifest);
+          return names === void 0 || names.includes(raw) ? void 0 : { value: void 0 };
+        }
+        if (!createRequest(options).available(operation, options.account))
+          return { value: void 0 };
+        const definitions = yield* definitionsFor(manifest.revision, operation);
+        if (definitions === void 0) return void 0;
+        return { value: describe(operation, bundler(definitions)) };
+      })
+    )
+  });
+};
+
+// src/openapi.ts
+var openapiRouter = (options, kinds = {}) => Effect_exports.runPromise(
+  openapiToolsEffect(options).pipe(Effect_exports.map((operations) => protocolRouter(operations, kinds))),
   options.signal === void 0 ? {} : { signal: options.signal }
 );
 export {
+  OpenapiCompileError,
+  OpenapiCompileErrorCode,
   OpenapiError,
-  openapiOperations
+  OpenapiErrorResponse,
+  OpenapiParameter,
+  OpenapiRequestBody,
+  isOpenapiTextMedia,
+  liveOpenapiRouter,
+  openapiBinaryResultSchema,
+  openapiMediaKind,
+  openapiRouter
 };