agent-shim 8.28.0 → 8.30.0

package/dist/cli.cjs

@@ -18556,10 +18556,10 @@ var require_mock_utils = __commonJS({
       }
     }
     function buildHeadersFromArray(headers) {
-      const clone2 = headers.slice();
+      const clone3 = headers.slice();
       const entries = [];
-      for (let index = 0; index < clone2.length; index += 2) {
-        entries.push([clone2[index], clone2[index + 1]]);
+      for (let index = 0; index < clone3.length; index += 2) {
+        entries.push([clone3[index], clone3[index + 1]]);
       }
       return Object.fromEntries(entries);
     }
@@ -48113,9 +48113,9 @@ function compileValidator(schema, parser) {
 function compile(schema, options) {
   try {
     const parser = compileFn(schema);
-    const clone2 = withParser(schema, parser);
-    clone2._zod.bag.validator = compileValidator(schema, parser);
-    return clone2;
+    const clone3 = withParser(schema, parser);
+    clone3._zod.bag.validator = compileValidator(schema, parser);
+    return clone3;
   } catch (err) {
     if (options?.strict)
       throw err;
@@ -48126,7 +48126,7 @@ function withParser(schema, parser) {
   if (isRecursiveSchema(schema)) {
     throw new ZodCompileUnsupportedError("a schema whose subtree contains a reference cycle");
   }
-  const clone2 = clone(schema);
+  const clone3 = clone(schema);
   const liveRun = schema._zod.run;
   const originalRun = liveRun.__originalRun ?? liveRun;
   const wrapped = (payload, ctx) => {
@@ -48146,12 +48146,12 @@ function withParser(schema, parser) {
     return originalRun(payload, ctx);
   };
   wrapped.__originalRun = originalRun;
-  clone2._zod.bag.fallbackRun = originalRun;
-  clone2._zod.bag.validator = parser;
-  clone2._zod.run = wrapped;
+  clone3._zod.bag.fallbackRun = originalRun;
+  clone3._zod.bag.validator = parser;
+  clone3._zod.run = wrapped;
   if (!liveRun.__originalRun)
-    installCompiledUserMethods(clone2, schema, parser);
-  return clone2;
+    installCompiledUserMethods(clone3, schema, parser);
+  return clone3;
 }
 function installCompiledUserMethods(target, source, parser) {
   const targetAny = target;
@@ -61796,7 +61796,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.28.0",
+  version: "8.30.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -61847,6 +61847,7 @@ var package_default = {
   dependencies: {
     "@clack/prompts": "^1.8.0",
     "@orpc/client": "1.15.4",
+    "@orpc/openapi": "1.15.4",
     "@orpc/server": "1.15.4",
     commander: "^15.0.0",
     cosmiconfig: "^10.0.1",
@@ -68796,6 +68797,21 @@ function parseEmptyableJSON(text2) {
 function stringifyJSON(value2) {
   return JSON.stringify(value2);
 }
+function findDeepMatches(check2, payload, segments = [], maps = [], values = []) {
+  if (check2(payload)) {
+    maps.push(segments);
+    values.push(payload);
+  } else if (Array.isArray(payload)) {
+    payload.forEach((v, i2) => {
+      findDeepMatches(check2, v, [...segments, i2], maps, values);
+    });
+  } else if (isObject4(payload)) {
+    for (const key in payload) {
+      findDeepMatches(check2, payload[key], [...segments, key], maps, values);
+    }
+  }
+  return { maps, values };
+}
 function getConstructor(value2) {
   if (!isTypescriptObject(value2)) {
     return null;
@@ -68812,6 +68828,22 @@ function isObject4(value2) {
 function isTypescriptObject(value2) {
   return !!value2 && (typeof value2 === "object" || typeof value2 === "function");
 }
+function clone2(value2) {
+  if (Array.isArray(value2)) {
+    return value2.map(clone2);
+  }
+  if (isObject4(value2)) {
+    const result = {};
+    for (const key in value2) {
+      result[key] = clone2(value2[key]);
+    }
+    for (const sym of Object.getOwnPropertySymbols(value2)) {
+      result[sym] = clone2(value2[sym]);
+    }
+    return result;
+  }
+  return value2;
+}
 function setOwn(object2, key, value2) {
   if (key === "__proto__") {
     Object.defineProperty(object2, key, {
@@ -69874,6 +69906,10 @@ var CheckRunInputSchema = external_exports.strictObject({
   path: external_exports.string().min(1),
   identity: external_exports.string().min(1).optional()
 }).refine((input2) => import_node_path33.default.isAbsolute(input2.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var PoolPickInputSchema = external_exports.strictObject({
+  pool: external_exports.string().min(1),
+  path: external_exports.string().min(1)
+}).refine((input2) => import_node_path33.default.isAbsolute(input2.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var DoctorFindingSchema = external_exports.strictObject({
   section: external_exports.enum(DOCTOR_SECTIONS),
   subject: external_exports.string().optional(),
@@ -70894,6 +70930,12 @@ function eventIterator(yields, returns) {
     }
   };
 }
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema["~standard"][EVENT_ITERATOR_DETAILS_SYMBOL];
+}
 
 // node_modules/.pnpm/@orpc+server@1.15.4/node_modules/@orpc/server/dist/shared/server.DEBcqOjg.mjs
 var LAZY_SYMBOL = /* @__PURE__ */ Symbol("ORPC_LAZY_SYMBOL");
@@ -71234,6 +71276,19 @@ function traverseContractProcedures(options, callback, lazyOptions = []) {
   }
   return lazyOptions;
 }
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
 function createContractedProcedure(procedure, contract) {
   return new Procedure({
     ...procedure["~orpc"],
@@ -71628,6 +71683,1173 @@ var RPCLink = class extends StandardRPCLink {
   }
 };
 
+// node_modules/.pnpm/@orpc+openapi-client@1.15.4/node_modules/@orpc/openapi-client/dist/shared/openapi-client.t9fCAe3x.mjs
+var StandardBracketNotationSerializer = class {
+  maxArrayIndex;
+  constructor(options = {}) {
+    this.maxArrayIndex = options.maxBracketNotationArrayIndex ?? 9999;
+  }
+  serialize(data, segments = [], result = []) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i2) => {
+        this.serialize(item, [...segments, i2], result);
+      });
+    } else if (isObject4(data)) {
+      for (const key in data) {
+        this.serialize(data[key], [...segments, key], result);
+      }
+    } else {
+      result.push([this.stringifyPath(segments), data]);
+    }
+    return result;
+  }
+  deserialize(serialized) {
+    if (serialized.length === 0) {
+      return {};
+    }
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const ref = { value: [] };
+    for (const [path46, value2] of serialized) {
+      const segments = this.parsePath(path46);
+      let currentRef = ref;
+      let nextSegment = "value";
+      segments.forEach((segment, i2) => {
+        if (!Array.isArray(currentRef[nextSegment]) && !isObject4(currentRef[nextSegment])) {
+          currentRef[nextSegment] = [];
+        }
+        if (i2 !== segments.length - 1) {
+          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, this.maxArrayIndex)) {
+            if (arrayPushStyles.has(currentRef[nextSegment])) {
+              arrayPushStyles.delete(currentRef[nextSegment]);
+              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+            } else {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          }
+        } else {
+          if (Array.isArray(currentRef[nextSegment])) {
+            if (segment === "") {
+              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+              }
+            } else {
+              if (arrayPushStyles.has(currentRef[nextSegment])) {
+                arrayPushStyles.delete(currentRef[nextSegment]);
+                currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+              } else if (!isValidArrayIndex(segment, this.maxArrayIndex)) {
+                currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+              }
+            }
+          }
+        }
+        currentRef = currentRef[nextSegment];
+        nextSegment = segment;
+      });
+      if (Array.isArray(currentRef) && nextSegment === "") {
+        arrayPushStyles.add(currentRef);
+        currentRef.push(value2);
+      } else if (nextSegment in currentRef) {
+        if (Array.isArray(currentRef[nextSegment])) {
+          currentRef[nextSegment].push(value2);
+        } else {
+          currentRef[nextSegment] = [currentRef[nextSegment], value2];
+        }
+      } else {
+        currentRef[nextSegment] = value2;
+      }
+    }
+    return ref.value;
+  }
+  stringifyPath(segments) {
+    return segments.map((segment) => {
+      return segment.toString().replace(/[\\[\]]/g, (match) => {
+        switch (match) {
+          case "\\":
+            return "\\\\";
+          case "[":
+            return "\\[";
+          case "]":
+            return "\\]";
+          /* v8 ignore next 2 */
+          default:
+            return match;
+        }
+      });
+    }).reduce((result, segment, i2) => {
+      if (i2 === 0) {
+        return segment;
+      }
+      return `${result}[${segment}]`;
+    }, "");
+  }
+  parsePath(path46) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    let backslashCount = 0;
+    for (let i2 = 0; i2 < path46.length; i2++) {
+      const char = path46[i2];
+      const nextChar = path46[i2 + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i2++;
+      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else if (char === "\\") {
+        backslashCount++;
+      } else {
+        currentSegment += "\\".repeat(backslashCount / 2) + char;
+        backslashCount = 0;
+      }
+    }
+    return inBrackets || segments.length === 0 ? [path46] : segments;
+  }
+};
+function isValidArrayIndex(value2, maxIndex) {
+  return /^0$|^[1-9]\d*$/.test(value2) && Number(value2) <= maxIndex;
+}
+function arrayToObject(array2) {
+  const obj = new NullProtoObj();
+  array2.forEach((item, i2) => {
+    obj[i2] = item;
+  });
+  return obj;
+}
+function pushStyleArrayToObject(array2) {
+  const obj = new NullProtoObj();
+  obj[""] = array2.length === 1 ? array2[0] : array2;
+  return obj;
+}
+
+// node_modules/.pnpm/@orpc+openapi-client@1.15.4/node_modules/@orpc/openapi-client/dist/shared/openapi-client.B2Q9qU5m.mjs
+var StandardOpenAPIJsonSerializer = class {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+  }
+  serialize(data, hasBlobRef = { value: false }) {
+    for (const custom2 of this.customSerializers) {
+      if (custom2.condition(data)) {
+        const result = this.serialize(custom2.serialize(data), hasBlobRef);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      hasBlobRef.value = true;
+      return [data, hasBlobRef.value];
+    }
+    if (data instanceof Set) {
+      return this.serialize(Array.from(data), hasBlobRef);
+    }
+    if (data instanceof Map) {
+      return this.serialize(Array.from(data.entries()), hasBlobRef);
+    }
+    if (Array.isArray(data)) {
+      const json2 = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
+      return [json2, hasBlobRef.value];
+    }
+    if (isObject4(data)) {
+      const json2 = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json2[k] = this.serialize(data[k], hasBlobRef)[0];
+      }
+      return [json2, hasBlobRef.value];
+    }
+    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+      return [data.toString(), hasBlobRef.value];
+    }
+    if (data instanceof Date) {
+      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+    }
+    if (Number.isNaN(data)) {
+      return [null, hasBlobRef.value];
+    }
+    return [data, hasBlobRef.value];
+  }
+};
+function standardizeHTTPPath(path46) {
+  return `/${path46.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path46) {
+  return path46 ? standardizeHTTPPath(path46).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+var StandardOpenAPISerializer = class {
+  constructor(jsonSerializer, bracketNotation) {
+    this.jsonSerializer = jsonSerializer;
+    this.bracketNotation = bracketNotation;
+  }
+  serialize(data, options = {}) {
+    if (isAsyncIteratorObject(data) && !options.outputFormat) {
+      return mapEventIterator(data, {
+        value: async (value2) => this.#serialize(value2, { outputFormat: "plain" }),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, options);
+  }
+  #serialize(data, options) {
+    const [json2, hasBlob] = this.jsonSerializer.serialize(data);
+    if (options.outputFormat === "plain") {
+      return json2;
+    }
+    if (options.outputFormat === "URLSearchParams") {
+      const params = new URLSearchParams();
+      for (const [path46, value2] of this.bracketNotation.serialize(json2)) {
+        if (typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean") {
+          params.append(path46, value2.toString());
+        }
+      }
+      return params;
+    }
+    if (json2 instanceof Blob || json2 === void 0 || !hasBlob) {
+      return json2;
+    }
+    const form = new FormData();
+    for (const [path46, value2] of this.bracketNotation.serialize(json2)) {
+      if (typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean") {
+        form.append(path46, value2.toString());
+      } else if (value2 instanceof Blob) {
+        form.append(path46, value2);
+      }
+    }
+    return form;
+  }
+  deserialize(data) {
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      return this.bracketNotation.deserialize(Array.from(data.entries()));
+    }
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value2) => value2,
+        error: async (e) => {
+          if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+            return createORPCErrorFromJson(e.data, { cause: e });
+          }
+          return e;
+        }
+      });
+    }
+    return data;
+  }
+};
+
+// node_modules/.pnpm/json-schema-typed@8.0.2/node_modules/json-schema-typed/draft_2020_12.js
+var ContentEncoding;
+(function(ContentEncoding2) {
+  ContentEncoding2["7bit"] = "7bit";
+  ContentEncoding2["8bit"] = "8bit";
+  ContentEncoding2["Base64"] = "base64";
+  ContentEncoding2["Binary"] = "binary";
+  ContentEncoding2["IETFToken"] = "ietf-token";
+  ContentEncoding2["QuotedPrintable"] = "quoted-printable";
+  ContentEncoding2["XToken"] = "x-token";
+})(ContentEncoding || (ContentEncoding = {}));
+var Format;
+(function(Format2) {
+  Format2["Date"] = "date";
+  Format2["DateTime"] = "date-time";
+  Format2["Duration"] = "duration";
+  Format2["Email"] = "email";
+  Format2["Hostname"] = "hostname";
+  Format2["IDNEmail"] = "idn-email";
+  Format2["IDNHostname"] = "idn-hostname";
+  Format2["IPv4"] = "ipv4";
+  Format2["IPv6"] = "ipv6";
+  Format2["IRI"] = "iri";
+  Format2["IRIReference"] = "iri-reference";
+  Format2["JSONPointer"] = "json-pointer";
+  Format2["JSONPointerURIFragment"] = "json-pointer-uri-fragment";
+  Format2["RegEx"] = "regex";
+  Format2["RelativeJSONPointer"] = "relative-json-pointer";
+  Format2["Time"] = "time";
+  Format2["URI"] = "uri";
+  Format2["URIReference"] = "uri-reference";
+  Format2["URITemplate"] = "uri-template";
+  Format2["UUID"] = "uuid";
+})(Format || (Format = {}));
+var TypeName;
+(function(TypeName2) {
+  TypeName2["Array"] = "array";
+  TypeName2["Boolean"] = "boolean";
+  TypeName2["Integer"] = "integer";
+  TypeName2["Null"] = "null";
+  TypeName2["Number"] = "number";
+  TypeName2["Object"] = "object";
+  TypeName2["String"] = "string";
+})(TypeName || (TypeName = {}));
+
+// node_modules/.pnpm/@orpc+openapi@1.15.4/node_modules/@orpc/openapi/dist/shared/openapi.BwdtJjDu.mjs
+var OPERATION_EXTENDER_SYMBOL = /* @__PURE__ */ Symbol("ORPC_OPERATION_EXTENDER");
+function getCustomOpenAPIOperation(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function applyCustomOpenAPIOperation(operation, contract) {
+  const operationCustoms = [];
+  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
+    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
+    if (maybeExtender) {
+      operationCustoms.push(maybeExtender);
+    }
+  }
+  if (isProcedure(contract)) {
+    for (const middleware of contract["~orpc"].middlewares) {
+      const maybeExtender = getCustomOpenAPIOperation(middleware);
+      if (maybeExtender) {
+        operationCustoms.push(maybeExtender);
+      }
+    }
+  }
+  let currentOperation = operation;
+  for (const custom2 of operationCustoms) {
+    if (typeof custom2 === "function") {
+      currentOperation = custom2(currentOperation, contract);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...custom2
+      };
+    }
+  }
+  return currentOperation;
+}
+var LOGIC_KEYWORDS = [
+  "$dynamicRef",
+  "$ref",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "dependencies",
+  "dependentRequired",
+  "dependentSchemas",
+  "else",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maximum",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minContains",
+  "minimum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "required",
+  "then",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems"
+];
+function isFileSchema(schema) {
+  return isObject4(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
+function isObjectSchema(schema) {
+  return isObject4(schema) && schema.type === "object";
+}
+function isAnySchema(schema) {
+  if (schema === true) {
+    return true;
+  }
+  if (Object.keys(schema).filter((v) => schema[v] !== void 0).every((k) => !LOGIC_KEYWORDS.includes(k))) {
+    return true;
+  }
+  return false;
+}
+function isNeverSchema(schema) {
+  if (schema === false) {
+    return true;
+  }
+  if (typeof schema === "object" && schema.not !== void 0) {
+    if (schema.not === true) {
+      return true;
+    }
+    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function separateObjectSchema(schema, separatedProperties) {
+  if (Object.keys(schema).some(
+    (k) => !["type", "properties", "required", "additionalProperties"].includes(k) && LOGIC_KEYWORDS.includes(k) && schema[k] !== void 0
+  )) {
+    return [{ type: "object" }, schema];
+  }
+  const matched = { ...schema };
+  const rest = { ...schema };
+  matched.properties = separatedProperties.reduce((acc, key) => {
+    const keySchema = schema.properties?.[key] ?? schema.additionalProperties;
+    if (keySchema !== void 0) {
+      acc[key] = keySchema;
+    }
+    return acc;
+  }, {});
+  if (Object.keys(matched.properties).length === 0) {
+    matched.properties = void 0;
+  }
+  matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
+  if (matched.required?.length === 0) {
+    matched.required = void 0;
+  }
+  matched.examples = schema.examples?.map((example) => {
+    if (!isObject4(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value2]) => {
+      if (separatedProperties.includes(key)) {
+        acc[key] = value2;
+      }
+      return acc;
+    }, {});
+  });
+  rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce((acc = {}, [key, value2]) => {
+    acc[key] = value2;
+    return acc;
+  }, void 0);
+  rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
+  if (rest.required?.length === 0) {
+    rest.required = void 0;
+  }
+  rest.examples = schema.examples?.map((example) => {
+    if (!isObject4(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value2]) => {
+      if (!separatedProperties.includes(key)) {
+        acc[key] = value2;
+      }
+      return acc;
+    }, {});
+  });
+  return [matched, rest];
+}
+function filterSchemaBranches(schema, check2, matches = []) {
+  if (check2(schema)) {
+    matches.push(schema);
+    return [matches, void 0];
+  }
+  if (isObject4(schema)) {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every(
+        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
+      )) {
+        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check2, matches)[1]).filter((v) => !!v);
+        if (rest.length === 1 && typeof rest[0] === "object") {
+          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];
+        }
+        return [matches, { ...schema, [keyword]: rest }];
+      }
+    }
+  }
+  return [matches, schema];
+}
+function applySchemaOptionality(required2, schema) {
+  if (required2) {
+    return schema;
+  }
+  return {
+    anyOf: [
+      schema,
+      { not: {} }
+    ]
+  };
+}
+function expandUnionSchema(schema) {
+  if (typeof schema === "object") {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every(
+        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
+      )) {
+        return schema[keyword].flatMap((s) => expandUnionSchema(s));
+      }
+    }
+  }
+  return [schema];
+}
+function expandArrayableSchema(schema) {
+  const schemas = expandUnionSchema(schema);
+  if (schemas.length !== 2) {
+    return void 0;
+  }
+  const arraySchema = schemas.find(
+    (s) => typeof s === "object" && s.type === "array" && Object.keys(s).filter((k) => LOGIC_KEYWORDS.includes(k)).every((k) => k === "type" || k === "items")
+  );
+  if (arraySchema === void 0) {
+    return void 0;
+  }
+  const items1 = arraySchema.items;
+  const items2 = schemas.find((s) => s !== arraySchema);
+  if (stringifyJSON(items1) !== stringifyJSON(items2)) {
+    return void 0;
+  }
+  return [items2, arraySchema];
+}
+var PRIMITIVE_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  TypeName.String,
+  TypeName.Number,
+  TypeName.Integer,
+  TypeName.Boolean,
+  TypeName.Null
+]);
+function isPrimitiveSchema(schema) {
+  return expandUnionSchema(schema).every((s) => {
+    if (typeof s === "boolean") {
+      return false;
+    }
+    if (typeof s.type === "string" && PRIMITIVE_SCHEMA_TYPES.has(s.type)) {
+      return true;
+    }
+    if (s.const !== void 0) {
+      return true;
+    }
+    return false;
+  });
+}
+function toOpenAPIPath(path46) {
+  return standardizeHTTPPath(path46).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
+}
+function toOpenAPIMethod(method) {
+  return method.toLocaleLowerCase();
+}
+function toOpenAPIContent(schema) {
+  const content = {};
+  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
+  for (const file2 of matches) {
+    content[file2.contentMediaType] = {
+      schema: toOpenAPISchema(file2)
+    };
+  }
+  if (restSchema !== void 0 && !isAnySchema(restSchema) && !isNeverSchema(restSchema)) {
+    content["application/json"] = {
+      schema: toOpenAPISchema(restSchema)
+    };
+    const isStillHasFileSchema = findDeepMatches((v) => isObject4(v) && isFileSchema(v), restSchema).values.length > 0;
+    if (isStillHasFileSchema) {
+      content["multipart/form-data"] = {
+        schema: toOpenAPISchema(restSchema)
+      };
+    }
+  }
+  return content;
+}
+function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
+  return {
+    "text/event-stream": {
+      schema: toOpenAPISchema({
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              event: { const: "message" },
+              data: yieldsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: yieldsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "done" },
+              data: returnsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: returnsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "error" },
+              data: {},
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: ["event"]
+          }
+        ]
+      })
+    }
+  };
+}
+function toOpenAPIParameters(schema, parameterIn) {
+  const parameters = [];
+  for (const key in schema.properties) {
+    const keySchema = schema.properties[key];
+    let isDeepObjectStyle = true;
+    if (parameterIn !== "query") {
+      isDeepObjectStyle = false;
+    } else if (isPrimitiveSchema(keySchema)) {
+      isDeepObjectStyle = false;
+    } else {
+      const [item] = expandArrayableSchema(keySchema) ?? [];
+      if (item !== void 0 && isPrimitiveSchema(item)) {
+        isDeepObjectStyle = false;
+      }
+    }
+    parameters.push({
+      name: key,
+      in: parameterIn,
+      required: schema.required?.includes(key),
+      schema: toOpenAPISchema(keySchema),
+      style: isDeepObjectStyle ? "deepObject" : void 0,
+      explode: isDeepObjectStyle ? true : void 0,
+      allowEmptyValue: parameterIn === "query" ? true : void 0,
+      allowReserved: parameterIn === "query" ? true : void 0
+    });
+  }
+  return parameters;
+}
+function checkParamsSchema(schema, params) {
+  const properties = Object.keys(schema.properties ?? {});
+  const required2 = schema.required ?? [];
+  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {
+    return false;
+  }
+  if (required2.length !== params.length || required2.some((v) => !params.includes(v))) {
+    return false;
+  }
+  return true;
+}
+function toOpenAPISchema(schema) {
+  return schema === true ? {} : schema === false ? { not: {} } : schema;
+}
+var OPENAPI_JSON_SCHEMA_REF_PREFIX = "#/components/schemas/";
+function resolveOpenAPIJsonSchemaRef(doc, schema) {
+  if (typeof schema !== "object" || !schema.$ref?.startsWith(OPENAPI_JSON_SCHEMA_REF_PREFIX)) {
+    return schema;
+  }
+  const name = schema.$ref.slice(OPENAPI_JSON_SCHEMA_REF_PREFIX.length);
+  const resolved = doc.components?.schemas?.[name];
+  return resolved ?? schema;
+}
+function simplifyComposedObjectJsonSchemasAndRefs(schema, doc) {
+  if (doc) {
+    schema = resolveOpenAPIJsonSchemaRef(doc, schema);
+  }
+  if (typeof schema !== "object" || !schema.anyOf && !schema.oneOf && !schema.allOf) {
+    return schema;
+  }
+  const unionSchemas = [
+    ...toArray(schema.anyOf?.map((s) => simplifyComposedObjectJsonSchemasAndRefs(s, doc))),
+    ...toArray(schema.oneOf?.map((s) => simplifyComposedObjectJsonSchemasAndRefs(s, doc)))
+  ];
+  const objectUnionSchemas = [];
+  for (const u3 of unionSchemas) {
+    if (!isObjectSchema(u3)) {
+      return schema;
+    }
+    objectUnionSchemas.push(u3);
+  }
+  const mergedUnionPropertyMap = /* @__PURE__ */ new Map();
+  for (const u3 of objectUnionSchemas) {
+    if (u3.properties) {
+      for (const [key, value2] of Object.entries(u3.properties)) {
+        let entry = mergedUnionPropertyMap.get(key);
+        if (!entry) {
+          const required2 = objectUnionSchemas.every((s) => s.required?.includes(key));
+          entry = { required: required2, schemas: [] };
+          mergedUnionPropertyMap.set(key, entry);
+        }
+        entry.schemas.push(value2);
+      }
+    }
+  }
+  const intersectionSchemas = toArray(schema.allOf?.map((s) => simplifyComposedObjectJsonSchemasAndRefs(s, doc)));
+  const objectIntersectionSchemas = [];
+  for (const u3 of intersectionSchemas) {
+    if (!isObjectSchema(u3)) {
+      return schema;
+    }
+    objectIntersectionSchemas.push(u3);
+  }
+  if (isObjectSchema(schema)) {
+    objectIntersectionSchemas.push(schema);
+  }
+  const mergedInteractionPropertyMap = /* @__PURE__ */ new Map();
+  for (const u3 of objectIntersectionSchemas) {
+    if (u3.properties) {
+      for (const [key, value2] of Object.entries(u3.properties)) {
+        let entry = mergedInteractionPropertyMap.get(key);
+        if (!entry) {
+          const required2 = objectIntersectionSchemas.some((s) => s.required?.includes(key));
+          entry = { required: required2, schemas: [] };
+          mergedInteractionPropertyMap.set(key, entry);
+        }
+        entry.schemas.push(value2);
+      }
+    }
+  }
+  const resultObjectSchema = { type: "object", properties: {}, required: [] };
+  const keys = /* @__PURE__ */ new Set([
+    ...mergedUnionPropertyMap.keys(),
+    ...mergedInteractionPropertyMap.keys()
+  ]);
+  if (keys.size === 0) {
+    return schema;
+  }
+  const deduplicateSchemas = (schemas) => {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const schema2 of schemas) {
+      const key = stringifyJSON(schema2);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(schema2);
+      }
+    }
+    return result;
+  };
+  for (const key of keys) {
+    const unionEntry = mergedUnionPropertyMap.get(key);
+    const intersectionEntry = mergedInteractionPropertyMap.get(key);
+    resultObjectSchema.properties[key] = (() => {
+      const dedupedUnionSchemas = unionEntry ? deduplicateSchemas(unionEntry.schemas) : [];
+      const dedupedIntersectionSchemas = intersectionEntry ? deduplicateSchemas(intersectionEntry.schemas) : [];
+      if (!dedupedUnionSchemas.length) {
+        return dedupedIntersectionSchemas.length === 1 ? dedupedIntersectionSchemas[0] : { allOf: dedupedIntersectionSchemas };
+      }
+      if (!dedupedIntersectionSchemas.length) {
+        return dedupedUnionSchemas.length === 1 ? dedupedUnionSchemas[0] : { anyOf: dedupedUnionSchemas };
+      }
+      const allOf = deduplicateSchemas([
+        ...dedupedIntersectionSchemas,
+        dedupedUnionSchemas.length === 1 ? dedupedUnionSchemas[0] : { anyOf: dedupedUnionSchemas }
+      ]);
+      return allOf.length === 1 ? allOf[0] : { allOf };
+    })();
+    if (unionEntry?.required || intersectionEntry?.required) {
+      resultObjectSchema.required.push(key);
+    }
+  }
+  return resultObjectSchema;
+}
+var CompositeSchemaConverter = class {
+  converters;
+  constructor(converters) {
+    this.converters = converters;
+  }
+  async convert(schema, options) {
+    for (const converter of this.converters) {
+      if (await converter.condition(schema, options)) {
+        return converter.convert(schema, options);
+      }
+    }
+    return [false, {}];
+  }
+};
+var OpenAPIGeneratorError = class extends Error {
+};
+var OpenAPIGenerator = class {
+  serializer;
+  converter;
+  constructor(options = {}) {
+    this.serializer = new StandardOpenAPIJsonSerializer(options);
+    this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));
+  }
+  /**
+   * Generates OpenAPI specifications from oRPC routers/contracts.
+   *
+   * @see {@link https://orpc.dev/docs/openapi/openapi-specification OpenAPI Specification Docs}
+   */
+  async generate(router, { customErrorResponseBodySchema, commonSchemas, filter: baseFilter, exclude, ...baseDoc } = {}) {
+    const filter = baseFilter ?? (({ contract, path: path46 }) => {
+      return !(exclude?.(contract, path46) ?? false);
+    });
+    const doc = {
+      ...clone2(baseDoc),
+      info: baseDoc.info ?? { title: "API Reference", version: "0.0.0" },
+      openapi: "3.1.1"
+    };
+    const { baseSchemaConvertOptions, undefinedErrorJsonSchema } = await this.#resolveCommonSchemas(doc, commonSchemas);
+    const contracts = [];
+    await resolveContractProcedures({ path: [], router }, (traverseOptions) => {
+      if (!value(filter, traverseOptions)) {
+        return;
+      }
+      contracts.push(traverseOptions);
+    });
+    const errors = [];
+    for (const { contract, path: path46 } of contracts) {
+      const stringPath = path46.join(".");
+      try {
+        const def = contract["~orpc"];
+        const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
+        const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path46));
+        let operationObjectRef;
+        if (def.route.spec !== void 0 && typeof def.route.spec !== "function") {
+          operationObjectRef = def.route.spec;
+        } else {
+          operationObjectRef = {
+            operationId: def.route.operationId ?? stringPath,
+            summary: def.route.summary,
+            description: def.route.description,
+            deprecated: def.route.deprecated,
+            tags: def.route.tags?.map((tag) => tag)
+          };
+          await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
+          await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
+          await this.#errorResponse(operationObjectRef, def, baseSchemaConvertOptions, undefinedErrorJsonSchema, customErrorResponseBodySchema);
+        }
+        if (typeof def.route.spec === "function") {
+          operationObjectRef = def.route.spec(operationObjectRef);
+        }
+        doc.paths ??= {};
+        doc.paths[httpPath] ??= {};
+        doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
+      } catch (e) {
+        if (!(e instanceof OpenAPIGeneratorError)) {
+          throw e;
+        }
+        errors.push(
+          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${stringPath}
+${e.message}`
+        );
+      }
+    }
+    if (errors.length) {
+      throw new OpenAPIGeneratorError(
+        `Some error occurred during OpenAPI generation:
+
+${errors.join("\n\n")}`
+      );
+    }
+    return this.serializer.serialize(doc)[0];
+  }
+  async #resolveCommonSchemas(doc, commonSchemas) {
+    let undefinedErrorJsonSchema = {
+      type: "object",
+      properties: {
+        defined: { const: false },
+        code: { type: "string" },
+        status: { type: "number" },
+        message: { type: "string" },
+        data: {}
+      },
+      required: ["defined", "code", "status", "message"]
+    };
+    const baseSchemaConvertOptions = {};
+    if (commonSchemas) {
+      baseSchemaConvertOptions.components = [];
+      for (const key in commonSchemas) {
+        const options = commonSchemas[key];
+        if (options.schema === void 0) {
+          continue;
+        }
+        const { schema, strategy = "input" } = options;
+        const [required2, json2] = await this.converter.convert(schema, { strategy });
+        const allowedStrategies = [strategy];
+        if (strategy === "input") {
+          const [outputRequired, outputJson] = await this.converter.convert(schema, { strategy: "output" });
+          if (outputRequired === required2 && stringifyJSON(outputJson) === stringifyJSON(json2)) {
+            allowedStrategies.push("output");
+          }
+        } else if (strategy === "output") {
+          const [inputRequired, inputJson] = await this.converter.convert(schema, { strategy: "input" });
+          if (inputRequired === required2 && stringifyJSON(inputJson) === stringifyJSON(json2)) {
+            allowedStrategies.push("input");
+          }
+        }
+        baseSchemaConvertOptions.components.push({
+          schema,
+          required: required2,
+          ref: `#/components/schemas/${key}`,
+          allowedStrategies
+        });
+      }
+      doc.components ??= {};
+      doc.components.schemas ??= {};
+      for (const key in commonSchemas) {
+        const options = commonSchemas[key];
+        if (options.schema === void 0) {
+          if (options.error === "UndefinedError") {
+            doc.components.schemas[key] = toOpenAPISchema(undefinedErrorJsonSchema);
+            undefinedErrorJsonSchema = { $ref: `#/components/schemas/${key}` };
+          }
+          continue;
+        }
+        const { schema, strategy = "input" } = options;
+        const [, json2] = await this.converter.convert(
+          schema,
+          {
+            ...baseSchemaConvertOptions,
+            strategy,
+            minStructureDepthForRef: 1
+            // not allow use $ref for root schemas
+          }
+        );
+        doc.components.schemas[key] = toOpenAPISchema(json2);
+      }
+    }
+    return { baseSchemaConvertOptions, undefinedErrorJsonSchema };
+  }
+  async #request(doc, ref, def, baseSchemaConvertOptions) {
+    const method = fallbackContractConfig("defaultMethod", def.route.method);
+    const details = getEventIteratorSchemaDetails(def.inputSchema);
+    if (details) {
+      ref.requestBody = {
+        required: true,
+        content: toOpenAPIEventIteratorContent(
+          await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
+          await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
+        )
+      };
+      return;
+    }
+    const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
+    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
+    let [required2, schema] = await this.converter.convert(
+      def.inputSchema,
+      {
+        ...baseSchemaConvertOptions,
+        strategy: "input"
+      }
+    );
+    let omitResponseBody = false;
+    if (isAnySchema(schema) && !dynamicParams?.length) {
+      return;
+    }
+    if (inputStructure === "detailed" || inputStructure === "compact" && (dynamicParams?.length || method === "GET")) {
+      schema = simplifyComposedObjectJsonSchemasAndRefs(schema, doc);
+    }
+    if (inputStructure === "compact") {
+      if (dynamicParams?.length) {
+        const error210 = new OpenAPIGeneratorError(
+          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
+        );
+        if (!isObjectSchema(schema)) {
+          throw error210;
+        }
+        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
+        schema = rest;
+        required2 = rest.required ? rest.required.length !== 0 : false;
+        omitResponseBody = !required2 && !rest.properties;
+        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
+          throw error210;
+        }
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+      }
+      if (method === "GET") {
+        if (!isObjectSchema(schema)) {
+          throw new OpenAPIGeneratorError(
+            'When method is "GET", input schema must satisfy: object | any | unknown'
+          );
+        }
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(schema, "query"));
+      } else if (!omitResponseBody) {
+        ref.requestBody = {
+          required: required2,
+          content: toOpenAPIContent(schema)
+        };
+      }
+      return;
+    }
+    const error62 = new OpenAPIGeneratorError(
+      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
+    );
+    if (!isObjectSchema(schema)) {
+      throw error62;
+    }
+    const resolvedParamSchema = schema.properties?.params !== void 0 ? simplifyComposedObjectJsonSchemasAndRefs(schema.properties.params, doc) : void 0;
+    if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) {
+      throw new OpenAPIGeneratorError(
+        'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
+      );
+    }
+    for (const from of ["params", "query", "headers"]) {
+      const fromSchema = schema.properties?.[from];
+      if (fromSchema !== void 0) {
+        const resolvedSchema = simplifyComposedObjectJsonSchemasAndRefs(fromSchema, doc);
+        if (!isObjectSchema(resolvedSchema)) {
+          throw error62;
+        }
+        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
+      }
+    }
+    if (schema.properties?.body !== void 0) {
+      ref.requestBody = {
+        required: schema.required?.includes("body"),
+        content: toOpenAPIContent(schema.properties.body)
+      };
+    }
+  }
+  async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
+    const outputSchema = def.outputSchema;
+    const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
+    const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
+    const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route.outputStructure);
+    if (eventIteratorSchemaDetails) {
+      ref.responses ??= {};
+      ref.responses[status] = {
+        description,
+        content: toOpenAPIEventIteratorContent(
+          await this.converter.convert(eventIteratorSchemaDetails.yields, { ...baseSchemaConvertOptions, strategy: "output" }),
+          await this.converter.convert(eventIteratorSchemaDetails.returns, { ...baseSchemaConvertOptions, strategy: "output" })
+        )
+      };
+      return;
+    }
+    const [required2, json2] = await this.converter.convert(
+      outputSchema,
+      {
+        ...baseSchemaConvertOptions,
+        strategy: "output",
+        minStructureDepthForRef: outputStructure === "detailed" ? 1 : 0
+      }
+    );
+    if (outputStructure === "compact") {
+      ref.responses ??= {};
+      ref.responses[status] = {
+        description
+      };
+      ref.responses[status].content = toOpenAPIContent(applySchemaOptionality(required2, json2));
+      return;
+    }
+    const handledStatuses = /* @__PURE__ */ new Set();
+    for (const item of expandUnionSchema(json2)) {
+      const error62 = new OpenAPIGeneratorError(`
+        When output structure is "detailed", output schema must satisfy:
+        { 
+          status?: number, // must be a literal number and in the range of 200-399
+          headers?: Record<string, unknown>, 
+          body?: unknown 
+        }
+        
+        But got: ${stringifyJSON(item)}
+      `);
+      const simplifiedItem = simplifyComposedObjectJsonSchemasAndRefs(item, doc);
+      if (!isObjectSchema(simplifiedItem)) {
+        throw error62;
+      }
+      let schemaStatus;
+      let schemaDescription;
+      if (simplifiedItem.properties?.status !== void 0) {
+        const statusSchema = resolveOpenAPIJsonSchemaRef(doc, simplifiedItem.properties.status);
+        if (typeof statusSchema !== "object" || statusSchema.const === void 0 || typeof statusSchema.const !== "number" || !Number.isInteger(statusSchema.const) || isORPCErrorStatus(statusSchema.const)) {
+          throw error62;
+        }
+        schemaStatus = statusSchema.const;
+        schemaDescription = statusSchema.description;
+      }
+      const itemStatus = schemaStatus ?? status;
+      const itemDescription = schemaDescription ?? description;
+      if (handledStatuses.has(itemStatus)) {
+        throw new OpenAPIGeneratorError(`
+          When output structure is "detailed", each success status must be unique.
+          But got status: ${itemStatus} used more than once.
+        `);
+      }
+      handledStatuses.add(itemStatus);
+      ref.responses ??= {};
+      ref.responses[itemStatus] = {
+        description: itemDescription
+      };
+      if (simplifiedItem.properties?.headers !== void 0) {
+        const headersSchema = simplifyComposedObjectJsonSchemasAndRefs(simplifiedItem.properties.headers, doc);
+        if (!isObjectSchema(headersSchema)) {
+          throw error62;
+        }
+        for (const key in headersSchema.properties) {
+          const headerSchema = headersSchema.properties[key];
+          if (headerSchema !== void 0) {
+            ref.responses[itemStatus].headers ??= {};
+            ref.responses[itemStatus].headers[key] = {
+              schema: toOpenAPISchema(headerSchema),
+              required: simplifiedItem.required?.includes("headers") && headersSchema.required?.includes(key)
+            };
+          }
+        }
+      }
+      if (simplifiedItem.properties?.body !== void 0) {
+        ref.responses[itemStatus].content = toOpenAPIContent(
+          applySchemaOptionality(simplifiedItem.required?.includes("body") ?? false, simplifiedItem.properties.body)
+        );
+      }
+    }
+  }
+  async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema, customErrorResponseBodySchema) {
+    const errorMap = def.errorMap;
+    const errorResponsesByStatus = {};
+    for (const code in errorMap) {
+      const config2 = errorMap[code];
+      if (!config2) {
+        continue;
+      }
+      const status = fallbackORPCErrorStatus(code, config2.status);
+      const defaultMessage = fallbackORPCErrorMessage(code, config2.message);
+      errorResponsesByStatus[status] ??= { status, definedErrorDefinitions: [], errorSchemaVariants: [] };
+      const [dataRequired, dataSchema] = await this.converter.convert(config2.data, { ...baseSchemaConvertOptions, strategy: "output" });
+      errorResponsesByStatus[status].definedErrorDefinitions.push([code, defaultMessage, dataRequired, dataSchema]);
+      errorResponsesByStatus[status].errorSchemaVariants.push({
+        type: "object",
+        properties: {
+          defined: { const: true },
+          code: { const: code },
+          status: { const: status },
+          message: { type: "string", default: defaultMessage },
+          data: dataSchema
+        },
+        required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
+      });
+    }
+    ref.responses ??= {};
+    for (const statusString in errorResponsesByStatus) {
+      const errorResponse2 = errorResponsesByStatus[statusString];
+      const customBodySchema = value(customErrorResponseBodySchema, errorResponse2.definedErrorDefinitions, errorResponse2.status);
+      ref.responses[statusString] = {
+        description: statusString,
+        content: toOpenAPIContent(customBodySchema ?? {
+          oneOf: [
+            ...errorResponse2.errorSchemaVariants,
+            undefinedErrorSchema
+          ]
+        })
+      };
+    }
+  }
+};
+
 // node_modules/.pnpm/@orpc+standard-server-node@1.15.4/node_modules/@orpc/standard-server-node/dist/index.mjs
 var import_node_buffer = require("node:buffer");
 var import_node_stream = require("node:stream");
@@ -72156,21 +73378,386 @@ var RPCHandler = class extends NodeHttpHandler {
   }
 };
 
+// node_modules/.pnpm/rou3@0.7.12/node_modules/rou3/dist/index.mjs
+var NullProtoObj2 = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  return e.prototype = /* @__PURE__ */ Object.create(null), Object.freeze(e.prototype), e;
+})();
+function createRouter() {
+  return {
+    root: { key: "" },
+    static: new NullProtoObj2()
+  };
+}
+function splitPath(path46) {
+  const [_, ...s] = path46.split("/");
+  return s[s.length - 1] === "" ? s.slice(0, -1) : s;
+}
+function getMatchParams(segments, paramsMap) {
+  const params = new NullProtoObj2();
+  for (const [index, name] of paramsMap) {
+    const segment = index < 0 ? segments.slice(-(index + 1)).join("/") : segments[index];
+    if (typeof name === "string") params[name] = segment;
+    else {
+      const match = segment.match(name);
+      if (match) for (const key in match.groups) params[key] = match.groups[key];
+    }
+  }
+  return params;
+}
+function addRoute(ctx, method = "", path46, data) {
+  method = method.toUpperCase();
+  if (path46.charCodeAt(0) !== 47) path46 = `/${path46}`;
+  path46 = path46.replace(/\\:/g, "%3A");
+  const segments = splitPath(path46);
+  let node2 = ctx.root;
+  let _unnamedParamIndex = 0;
+  const paramsMap = [];
+  const paramsRegexp = [];
+  for (let i2 = 0; i2 < segments.length; i2++) {
+    let segment = segments[i2];
+    if (segment.startsWith("**")) {
+      if (!node2.wildcard) node2.wildcard = { key: "**" };
+      node2 = node2.wildcard;
+      paramsMap.push([
+        -(i2 + 1),
+        segment.split(":")[1] || "_",
+        segment.length === 2
+      ]);
+      break;
+    }
+    if (segment === "*" || segment.includes(":")) {
+      if (!node2.param) node2.param = { key: "*" };
+      node2 = node2.param;
+      if (segment === "*") paramsMap.push([
+        i2,
+        `_${_unnamedParamIndex++}`,
+        true
+      ]);
+      else if (segment.includes(":", 1)) {
+        const regexp = getParamRegexp(segment);
+        paramsRegexp[i2] = regexp;
+        node2.hasRegexParam = true;
+        paramsMap.push([
+          i2,
+          regexp,
+          false
+        ]);
+      } else paramsMap.push([
+        i2,
+        segment.slice(1),
+        false
+      ]);
+      continue;
+    }
+    if (segment === "\\*") segment = segments[i2] = "*";
+    else if (segment === "\\*\\*") segment = segments[i2] = "**";
+    const child = node2.static?.[segment];
+    if (child) node2 = child;
+    else {
+      const staticNode = { key: segment };
+      if (!node2.static) node2.static = new NullProtoObj2();
+      node2.static[segment] = staticNode;
+      node2 = staticNode;
+    }
+  }
+  const hasParams = paramsMap.length > 0;
+  if (!node2.methods) node2.methods = new NullProtoObj2();
+  node2.methods[method] ??= [];
+  node2.methods[method].push({
+    data: data || null,
+    paramsRegexp,
+    paramsMap: hasParams ? paramsMap : void 0
+  });
+  if (!hasParams) ctx.static["/" + segments.join("/")] = node2;
+}
+function getParamRegexp(segment) {
+  const regex = segment.replace(/:(\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\./g, "\\.");
+  return /* @__PURE__ */ new RegExp(`^${regex}$`);
+}
+function findRoute(ctx, method = "", path46, opts) {
+  if (path46.charCodeAt(path46.length - 1) === 47) path46 = path46.slice(0, -1);
+  const staticNode = ctx.static[path46];
+  if (staticNode && staticNode.methods) {
+    const staticMatch = staticNode.methods[method] || staticNode.methods[""];
+    if (staticMatch !== void 0) return staticMatch[0];
+  }
+  const segments = splitPath(path46);
+  const match = _lookupTree(ctx, ctx.root, method, segments, 0)?.[0];
+  if (match === void 0) return;
+  if (opts?.params === false) return match;
+  return {
+    data: match.data,
+    params: match.paramsMap ? getMatchParams(segments, match.paramsMap) : void 0
+  };
+}
+function _lookupTree(ctx, node2, method, segments, index) {
+  if (index === segments.length) {
+    if (node2.methods) {
+      const match = node2.methods[method] || node2.methods[""];
+      if (match) return match;
+    }
+    if (node2.param && node2.param.methods) {
+      const match = node2.param.methods[method] || node2.param.methods[""];
+      if (match) {
+        const pMap = match[0].paramsMap;
+        if (pMap?.[pMap?.length - 1]?.[2]) return match;
+      }
+    }
+    if (node2.wildcard && node2.wildcard.methods) {
+      const match = node2.wildcard.methods[method] || node2.wildcard.methods[""];
+      if (match) {
+        const pMap = match[0].paramsMap;
+        if (pMap?.[pMap?.length - 1]?.[2]) return match;
+      }
+    }
+    return;
+  }
+  const segment = segments[index];
+  if (node2.static) {
+    const staticChild = node2.static[segment];
+    if (staticChild) {
+      const match = _lookupTree(ctx, staticChild, method, segments, index + 1);
+      if (match) return match;
+    }
+  }
+  if (node2.param) {
+    const match = _lookupTree(ctx, node2.param, method, segments, index + 1);
+    if (match) {
+      if (node2.param.hasRegexParam) {
+        const exactMatch = match.find((m2) => m2.paramsRegexp[index]?.test(segment)) || match.find((m2) => !m2.paramsRegexp[index]);
+        return exactMatch ? [exactMatch] : void 0;
+      }
+      return match;
+    }
+  }
+  if (node2.wildcard && node2.wildcard.methods) return node2.wildcard.methods[method] || node2.wildcard.methods[""];
+}
+
+// node_modules/.pnpm/@orpc+openapi@1.15.4/node_modules/@orpc/openapi/dist/shared/openapi.DPiCV5hl.mjs
+var StandardOpenAPICodec = class {
+  constructor(serializer, options = {}) {
+    this.serializer = serializer;
+    this.customErrorResponseBodyEncoder = options.customErrorResponseBodyEncoder;
+  }
+  customErrorResponseBodyEncoder;
+  async decode(request7, params, procedure) {
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    if (inputStructure === "compact") {
+      const data = request7.method === "GET" ? this.serializer.deserialize(request7.url.searchParams) : this.serializer.deserialize(await request7.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject4(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return this.serializer.deserialize(request7.url.searchParams);
+    };
+    return {
+      params,
+      get query() {
+        const value2 = deserializeSearchParams();
+        Object.defineProperty(this, "query", { value: value2, writable: true });
+        return value2;
+      },
+      set query(value2) {
+        Object.defineProperty(this, "query", { value: value2, writable: true });
+      },
+      headers: request7.headers,
+      body: this.serializer.deserialize(await request7.body())
+    };
+  }
+  encode(output2, procedure) {
+    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      if (output2 instanceof ReadableStream) {
+        return {
+          status: successStatus,
+          headers: {},
+          body: output2
+        };
+      }
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output2)
+      };
+    }
+    if (!this.#isDetailedOutput(output2)) {
+      throw new Error(`
+        Invalid "detailed" output structure:
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[]>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output2)}
+      `);
+    }
+    if (output2.body instanceof ReadableStream) {
+      return {
+        status: output2.status ?? successStatus,
+        headers: output2.headers ?? {},
+        body: output2.body
+      };
+    }
+    return {
+      status: output2.status ?? successStatus,
+      headers: output2.headers ?? {},
+      body: this.serializer.serialize(output2.body)
+    };
+  }
+  encodeError(error62) {
+    const body = this.customErrorResponseBodyEncoder?.(error62) ?? error62.toJSON();
+    return {
+      status: error62.status,
+      headers: {},
+      body: this.serializer.serialize(body, { outputFormat: "plain" })
+    };
+  }
+  #isDetailedOutput(output2) {
+    if (!isObject4(output2)) {
+      return false;
+    }
+    if (output2.headers && !isObject4(output2.headers)) {
+      return false;
+    }
+    if (output2.status !== void 0 && (typeof output2.status !== "number" || !Number.isInteger(output2.status) || isORPCErrorStatus(output2.status))) {
+      return false;
+    }
+    return true;
+  }
+};
+function toRou3Pattern(path46) {
+  return standardizeHTTPPath(path46).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value2]) => [key, tryDecodeURIComponent(value2)]));
+}
+var StandardOpenAPIMatcher = class {
+  filter;
+  tree = createRouter();
+  pendingRouters = [];
+  constructor(options = {}) {
+    this.filter = options.filter ?? true;
+  }
+  init(router, path46 = []) {
+    const laziedOptions = traverseContractProcedures({ router, path: path46 }, (traverseOptions) => {
+      if (!value(this.filter, traverseOptions)) {
+        return;
+      }
+      const { path: path210, contract } = traverseOptions;
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path210));
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path210,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path210,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: toHttpPath(option.path),
+      laziedPrefix: getLazyMeta(option.router).prefix
+    })));
+  }
+  async match(method, pathname) {
+    while (true) {
+      const pendingRouter = this.pendingRouters.find(
+        (pendingRouter2) => !pendingRouter2.laziedPrefix || pathname.startsWith(pendingRouter2.laziedPrefix) || pathname.startsWith(pendingRouter2.httpPathPrefix)
+      );
+      if (!pendingRouter) {
+        break;
+      }
+      pendingRouter.initPromise ??= unlazy(pendingRouter.router).then(({ default: router }) => {
+        this.init(router, pendingRouter.path);
+        this.pendingRouters.splice(this.pendingRouters.indexOf(pendingRouter), 1);
+      }).catch((error62) => {
+        pendingRouter.initPromise = void 0;
+        throw error62;
+      });
+      await pendingRouter.initPromise;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+};
+var StandardOpenAPIHandler = class extends StandardHandler {
+  constructor(router, options) {
+    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
+    const bracketNotationSerializer = new StandardBracketNotationSerializer(options);
+    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
+    const matcher = new StandardOpenAPIMatcher(options);
+    const codec2 = new StandardOpenAPICodec(serializer, options);
+    super(router, matcher, codec2, options);
+  }
+};
+
+// node_modules/.pnpm/@orpc+openapi@1.15.4/node_modules/@orpc/openapi/dist/adapters/node/index.mjs
+var OpenAPIHandler = class extends NodeHttpHandler {
+  constructor(router, options = {}) {
+    super(new StandardOpenAPIHandler(router, options), options);
+  }
+};
+
 // src/frontdoor/rcApi.ts
 var import_undici2 = __toESM(require_undici(), 1);
 var RC_ORPC_PATH_PREFIX = "/__agent-shim/orpc";
+var RC_OPENAPI_DOC_PATH = "/openapi.json";
 var RC_SUBSCRIBER_BUFFER_EVENTS = 100;
+function doorApiBearer(headers) {
+  const presented = headers.authorization;
+  const bearerPrefix = "bearer ".length;
+  return typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
+}
 function doorApiAuth(expectedToken) {
   return os7.$context().use(({ context, next }) => {
-    const presented = context.headers.authorization;
-    const bearerPrefix = "bearer ".length;
-    const token = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
+    const token = doorApiBearer(context.headers);
     if (token === void 0 || !isLiveCapability(token, [expectedToken])) {
       throw new ORPCError("UNAUTHORIZED", { message: "the front door's typed API demands this generation's control token as a Bearer credential" });
     }
     return next();
   });
 }
+var RC_API_TAG = "remote-control";
 function createRcApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const delivered = (sessionId, result) => {
@@ -72190,41 +73777,41 @@ function createRcApiRouter(deps) {
   };
   return {
     rc: {
-      list: authed.output(RcListOutputSchema).handler(() => ({ sessions: deps.list() })),
-      status: authed.input(RcSessionQuerySchema).output(RcStatusOutputSchema).handler(({ input: input2 }) => {
+      list: authed.route({ method: "GET", path: "/rest/rc/sessions", summary: "List the observed Remote Control sessions", tags: [RC_API_TAG] }).output(RcListOutputSchema).handler(() => ({ sessions: deps.list() })),
+      status: authed.route({ method: "GET", path: "/rest/rc/status", summary: "Read session status, one session's when named", tags: [RC_API_TAG] }).input(RcSessionQuerySchema).output(RcStatusOutputSchema).handler(({ input: input2 }) => {
         const statuses = deps.statusOf(input2.session);
         if (input2.session !== void 0 && !statuses.some((entry) => entry.id === input2.session)) {
           throw new ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input2.session) });
         }
         return { statuses };
       }),
-      pending: authed.input(RcSessionQuerySchema).output(RcPendingOutputSchema).handler(({ input: input2 }) => {
+      pending: authed.route({ method: "GET", path: "/rest/rc/pending", summary: "Read the control requests awaiting an answer", tags: [RC_API_TAG] }).input(RcSessionQuerySchema).output(RcPendingOutputSchema).handler(({ input: input2 }) => {
         const pending = deps.pendingOf(input2.session);
         if (input2.session !== void 0 && deps.statusOf(input2.session).length === 0) {
           throw new ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input2.session) });
         }
         return { pending };
       }),
-      send: authed.input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.inject(input2.session, input2.text)) })),
-      answer: authed.input(RcAnswerInputSchema).output(RcAnswerOutputSchema).handler(async ({ input: input2 }) => {
+      send: authed.route({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", tags: [RC_API_TAG] }).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.inject(input2.session, input2.text)) })),
+      answer: authed.route({ method: "POST", path: "/rest/rc/answer", summary: "Answer one pending control request", tags: [RC_API_TAG] }).input(RcAnswerInputSchema).output(RcAnswerOutputSchema).handler(async ({ input: input2 }) => {
         const decision = { approve: input2.approve, message: input2.approve || input2.text === void 0 ? void 0 : input2.text };
         return { session: input2.session, request: input2.request, sequenceNums: delivered(input2.session, await deps.answer(input2.session, input2.request, decision)) };
       }),
-      interrupt: authed.input(RcInterruptInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.interrupt(input2.session)) })),
-      setModel: authed.input(RcSetModelInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.setModel(input2.session, input2.model)) })),
-      setPermissionMode: authed.input(RcSetPermissionModeInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.setPermissionMode(input2.session, input2.mode)) })),
-      endSession: authed.input(RcEndSessionInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.endSession(input2.session, input2.reason)) })),
-      getUsage: authed.input(RcGetUsageInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.getUsage(input2.session, input2.skipBehaviors)) })),
-      getContextUsage: authed.input(RcGetContextUsageInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.getContextUsage(input2.session, input2.detail)) })),
-      readFile: authed.input(RcReadFileInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.readFile(input2.session, input2.path, { ...input2.maxBytes === void 0 ? {} : { maxBytes: input2.maxBytes }, ...input2.encoding === void 0 ? {} : { encoding: input2.encoding } })) })),
-      fileSuggestions: authed.input(RcFileSuggestionsInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.fileSuggestions(input2.session, input2.query)) })),
-      keepAlive: authed.input(RcKeepAliveInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.keepAlive(input2.session)) })),
-      mcpStatus: authed.input(RcMcpStatusInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpStatus(input2.session)) })),
-      mcpReconnect: authed.input(RcMcpReconnectInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpReconnect(input2.session, input2.serverName)) })),
-      mcpAuthenticate: authed.input(RcMcpAuthenticateInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpAuthenticate(input2.session, input2.serverName, input2.redirectUri)) })),
-      mcpOAuthCallbackUrl: authed.input(RcMcpOAuthCallbackUrlInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpOAuthCallbackUrl(input2.session, input2.serverName, input2.callbackUrl)) })),
-      teleport: authed.input(RcTeleportInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.teleport(input2.session, input2.marker)) })),
-      subscribe: authed.input(RcSessionQuerySchema).output(eventIterator(RcStreamEventSchema)).handler(async function* ({ input: input2, signal }) {
+      interrupt: authed.route({ method: "POST", path: "/rest/rc/interrupt", summary: "Interrupt a session's running turn", tags: [RC_API_TAG] }).input(RcInterruptInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.interrupt(input2.session)) })),
+      setModel: authed.route({ method: "POST", path: "/rest/rc/set-model", summary: "Switch a session's model", tags: [RC_API_TAG] }).input(RcSetModelInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.setModel(input2.session, input2.model)) })),
+      setPermissionMode: authed.route({ method: "POST", path: "/rest/rc/set-permission-mode", summary: "Switch a session's permission mode", tags: [RC_API_TAG] }).input(RcSetPermissionModeInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.setPermissionMode(input2.session, input2.mode)) })),
+      endSession: authed.route({ method: "POST", path: "/rest/rc/end-session", summary: "End a session", tags: [RC_API_TAG] }).input(RcEndSessionInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.endSession(input2.session, input2.reason)) })),
+      getUsage: authed.route({ method: "POST", path: "/rest/rc/get-usage", summary: "Ask a session for its usage snapshot", tags: [RC_API_TAG] }).input(RcGetUsageInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.getUsage(input2.session, input2.skipBehaviors)) })),
+      getContextUsage: authed.route({ method: "POST", path: "/rest/rc/get-context-usage", summary: "Ask a session for its context usage", tags: [RC_API_TAG] }).input(RcGetContextUsageInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.getContextUsage(input2.session, input2.detail)) })),
+      readFile: authed.route({ method: "POST", path: "/rest/rc/read-file", summary: "Ask a session to read one file", tags: [RC_API_TAG] }).input(RcReadFileInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.readFile(input2.session, input2.path, { ...input2.maxBytes === void 0 ? {} : { maxBytes: input2.maxBytes }, ...input2.encoding === void 0 ? {} : { encoding: input2.encoding } })) })),
+      fileSuggestions: authed.route({ method: "POST", path: "/rest/rc/file-suggestions", summary: "Ask a session for file-path suggestions", tags: [RC_API_TAG] }).input(RcFileSuggestionsInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.fileSuggestions(input2.session, input2.query)) })),
+      keepAlive: authed.route({ method: "POST", path: "/rest/rc/keep-alive", summary: "Keep a session's bridge alive", tags: [RC_API_TAG] }).input(RcKeepAliveInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.keepAlive(input2.session)) })),
+      mcpStatus: authed.route({ method: "POST", path: "/rest/rc/mcp-status", summary: "Ask a session for its MCP servers' status", tags: [RC_API_TAG] }).input(RcMcpStatusInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpStatus(input2.session)) })),
+      mcpReconnect: authed.route({ method: "POST", path: "/rest/rc/mcp-reconnect", summary: "Ask a session to reconnect one MCP server", tags: [RC_API_TAG] }).input(RcMcpReconnectInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpReconnect(input2.session, input2.serverName)) })),
+      mcpAuthenticate: authed.route({ method: "POST", path: "/rest/rc/mcp-authenticate", summary: "Start OAuth for one MCP server on a session", tags: [RC_API_TAG] }).input(RcMcpAuthenticateInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpAuthenticate(input2.session, input2.serverName, input2.redirectUri)) })),
+      mcpOAuthCallbackUrl: authed.route({ method: "POST", path: "/rest/rc/mcp-oauth-callback-url", summary: "Hand a completed MCP OAuth callback to a session", tags: [RC_API_TAG] }).input(RcMcpOAuthCallbackUrlInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpOAuthCallbackUrl(input2.session, input2.serverName, input2.callbackUrl)) })),
+      teleport: authed.route({ method: "POST", path: "/rest/rc/teleport", summary: "Teleport a session to a conversation marker", tags: [RC_API_TAG] }).input(RcTeleportInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.teleport(input2.session, input2.marker)) })),
+      subscribe: authed.route({ method: "GET", path: "/rest/rc/events", summary: "Stream a session's Remote Control events (SSE)", tags: [RC_API_TAG] }).input(RcSessionQuerySchema).output(eventIterator(RcStreamEventSchema)).handler(async function* ({ input: input2, signal }) {
         const queue = [];
         let wake;
         const detach = deps.fanout.subscribe(input2.session, (event) => {
@@ -72261,11 +73848,40 @@ function createRcApiRouter(deps) {
     }
   };
 }
-function doorApiNodeHandlerOf(router) {
-  const handler = new RPCHandler(router, { plugins: [new BodyLimitPlugin({ maxBodySize: CONTROL_BODY_CAP_BYTES })] });
+function doorApiNodeHandlerOf(router, expectedToken) {
+  const plugins = [new BodyLimitPlugin({ maxBodySize: CONTROL_BODY_CAP_BYTES })];
+  const rpcHandler = new RPCHandler(router, { plugins });
+  const restHandler = new OpenAPIHandler(router, { plugins });
+  let document;
+  const documentOf = async () => document ??= new OpenAPIGenerator().generate(router, { info: { title: "agent-shim front door API", version: package_default.version } });
   return {
     pathPrefix: RC_ORPC_PATH_PREFIX,
-    handle: async (request7, response) => await handler.handle(request7, response, { context: { headers: request7.headers }, prefix: RC_ORPC_PATH_PREFIX })
+    handle: async (request7, response) => {
+      if (request7.method === "GET" && request7.url === `${RC_ORPC_PATH_PREFIX}${RC_OPENAPI_DOC_PATH}`) {
+        const token = doorApiBearer(request7.headers);
+        if (token === void 0 || !isLiveCapability(token, [expectedToken])) {
+          const refusal = new ORPCError("UNAUTHORIZED", { message: "the front door's OpenAPI document demands this generation's control token as a Bearer credential" });
+          response.writeHead(HTTP_STATUS.unauthorized, { "content-type": "application/json" });
+          response.end(JSON.stringify(refusal.toJSON()));
+          return { matched: true };
+        }
+        try {
+          const doc = await documentOf();
+          response.writeHead(HTTP_STATUS.ok, { "content-type": "application/json" });
+          response.end(JSON.stringify(doc));
+        } catch (error62) {
+          const refusal = new ORPCError("INTERNAL_SERVER_ERROR", { message: `the OpenAPI document could not be generated from the door's own router: ${error62 instanceof Error ? error62.message : String(error62)}` });
+          response.writeHead(HTTP_STATUS.internalServerError, { "content-type": "application/json" });
+          response.end(JSON.stringify(refusal.toJSON()));
+        }
+        return { matched: true };
+      }
+      const rest = await restHandler.handle(request7, response, { context: { headers: request7.headers }, prefix: RC_ORPC_PATH_PREFIX });
+      if (rest.matched) {
+        return rest;
+      }
+      return await rpcHandler.handle(request7, response, { context: { headers: request7.headers }, prefix: RC_ORPC_PATH_PREFIX });
+    }
   };
 }
 function frontDoorApiLink(port, ca, token) {
@@ -72311,11 +73927,12 @@ var LaunchLifecycleEventSchema = external_exports.strictObject({
 });
 
 // src/frontdoor/eventsApi.ts
+var EVENTS_API_TAG = "events";
 function createEventsApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     events: {
-      subscribe: authed.input(DoorEventSourceQuerySchema).output(eventIterator(DoorEventSchema)).handler(async function* ({ input: input2, signal }) {
+      subscribe: authed.route({ method: "GET", path: "/rest/events", summary: "Stream the door's every event source (SSE)", tags: [EVENTS_API_TAG] }).input(DoorEventSourceQuerySchema).output(eventIterator(DoorEventSchema)).handler(async function* ({ input: input2, signal }) {
         if (input2.sources !== void 0) {
           const live = deps.events.sources();
           const unknown2 = input2.sources.filter((source) => !live.includes(source));
@@ -72348,12 +73965,17 @@ function createEventsApiRouter(deps) {
 }
 
 // src/frontdoor/controlApi.ts
+var USAGE_API_TAG = "usage";
+var FRONTDOOR_API_TAG = "frontdoor";
+var CHECK_API_TAG = "check";
+var DOCTOR_API_TAG = "doctor";
+var POOL_API_TAG = "pool";
 function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     usage: {
-      list: authed.output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
-      effectiveWindow: authed.input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input: input2 }) => {
+      list: authed.route({ method: "GET", path: "/rest/usage/snapshots", summary: "List every identity's usage snapshot", tags: [USAGE_API_TAG] }).output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
+      effectiveWindow: authed.route({ method: "GET", path: "/rest/usage/windows", summary: "Read one identity's effective quota windows", tags: [USAGE_API_TAG] }).input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input: input2 }) => {
         const snapshot = deps.usageSnapshotOf(input2.identity);
         if (snapshot === void 0) {
           throw new ORPCError("NOT_FOUND", { message: `identity ${input2.identity} has no usage snapshot yet, so no quota window has been observed for it` });
@@ -72370,7 +73992,7 @@ function createControlApiRouter(deps) {
           ...unified?.sevenDay === void 0 ? {} : { sevenDay: effectiveWindow(unified.sevenDay, now) }
         };
       }),
-      live: authed.input(RcSessionQuerySchema).output(UsageLiveOutputSchema).handler(({ input: input2 }) => {
+      live: authed.route({ method: "GET", path: "/rest/usage/live", summary: "Read the live rate-limit observations the event backbone files", tags: [USAGE_API_TAG] }).input(RcSessionQuerySchema).output(UsageLiveOutputSchema).handler(({ input: input2 }) => {
         const sessions = deps.liveRateLimits(input2.session);
         if (input2.session !== void 0 && sessions.length === 0) {
           if (deps.list().some((session) => session.id === input2.session)) {
@@ -72382,15 +74004,27 @@ function createControlApiRouter(deps) {
       })
     },
     frontdoor: {
-      status: authed.output(FrontDoorStatusOutputSchema).handler(() => deps.frontDoorStatus()),
-      sessions: authed.output(FrontDoorSessionsOutputSchema).handler(() => ({ sessions: deps.frontDoorStatus().sessions }))
+      status: authed.route({ method: "GET", path: "/rest/frontdoor/status", summary: "Read the front door's status", tags: [FRONTDOOR_API_TAG] }).output(FrontDoorStatusOutputSchema).handler(() => deps.frontDoorStatus()),
+      sessions: authed.route({ method: "GET", path: "/rest/frontdoor/sessions", summary: "Read the front door's session registry", tags: [FRONTDOOR_API_TAG] }).output(FrontDoorSessionsOutputSchema).handler(() => ({ sessions: deps.frontDoorStatus().sessions }))
     },
     check: {
       // The report's own JSON shape is the contract (the same one `check --json` prints and `checkReportSchema.ts` defines), so the procedure returns exactly that conversion.
-      run: authed.input(CheckRunInputSchema).output(CheckReportJsonSchema).handler(({ input: input2 }) => checkReportToJson(deps.checkReport(input2.path, input2.identity)))
+      run: authed.route({ method: "GET", path: "/rest/check", summary: "Run the check report for one directory", tags: [CHECK_API_TAG] }).input(CheckRunInputSchema).output(CheckReportJsonSchema).handler(({ input: input2 }) => checkReportToJson(deps.checkReport(input2.path, input2.identity)))
     },
     doctor: {
-      run: authed.output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+      run: authed.route({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] }).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+    },
+    pool: {
+      pick: authed.route({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] }).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input: input2 }) => {
+        const report = deps.poolPick(input2.pool, input2.path);
+        if (report === void 0) {
+          const live = deps.poolNames();
+          throw new ORPCError("NOT_FOUND", {
+            message: live.length === 0 ? `no pools are configured, so none is named ${input2.pool}` : `no pool is named ${input2.pool}; the live pools are ${live.map((name) => `"${name}"`).join(", ")}`
+          });
+        }
+        return report;
+      })
     }
   };
 }
@@ -72398,7 +74032,7 @@ function createDoorApiRouter(deps) {
   return { ...createRcApiRouter(deps), ...createControlApiRouter(deps), ...createEventsApiRouter(deps) };
 }
 function createDoorApiNodeHandler(deps) {
-  return doorApiNodeHandlerOf(createDoorApiRouter(deps));
+  return doorApiNodeHandlerOf(createDoorApiRouter(deps), deps.expectedToken);
 }
 
 // src/frontdoor/eventHub.ts
@@ -72689,10 +74323,10 @@ function createRoutedResponse(response, context) {
   let headersSent = false;
   let bodyObservers = [];
   let finished = false;
-  const observeBody = (call) => {
+  const observeBody = (call2) => {
     bodyObservers = bodyObservers.filter((observer) => {
       try {
-        call(observer);
+        call2(observer);
         return true;
       } catch (error62) {
         deps.log(`front door: response body observer threw for ${route}: ${describeThrown(error62)}`);
@@ -76997,7 +78631,13 @@ function realFrontDoorSupervisorPorts(paths) {
         now: () => Date.now(),
         frontDoorStatus: () => collectFrontDoorStatus(realFarmFs, realHeadroomSocketTrust, paths, realIsProcessRunning),
         checkReport: (target, identity) => collectCheckReport({ paths, cwd: target, ...identity === void 0 ? {} : { identity }, env: process.env }),
-        doctorReport: () => collectDoctorReport({ paths, env: process.env })
+        doctorReport: () => collectDoctorReport({ paths, env: process.env }),
+        // The pool table is read per call, not captured here, so a pool created or removed after the door started is ranked or refused by its live name the same moment the CLI would see it.
+        poolPick: (pool, directory) => {
+          const pools = readPools(paths);
+          return pools[pool] === void 0 ? void 0 : collectPoolPick({ paths, fs: realFsPort, usageFs: realFarmFs, poolName: pool, pools, directory, nowMs: Date.now() });
+        },
+        poolNames: () => Object.keys(readPools(paths)).sort()
       };
       realFarmFs.mkdirp(paths.frontdoorDir);
       realFarmFs.writeFilePrivate(paths.frontdoorControlTokenFile, `${rcControlToken}