@ours.network/cowork 0.3.6 → 0.4.0

package/dist/daemon.js

@@ -861,8 +861,8 @@ var init_parseUtil = __esm({
   "node_modules/zod/v3/helpers/parseUtil.js"() {
     init_errors();
     init_en();
-    makeIssue = (params) => {
-      const { data, path, errorMaps, issueData } = params;
+    makeIssue = (params2) => {
+      const { data, path, errorMaps, issueData } = params2;
       const fullPath = [...path, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
@@ -971,17 +971,17 @@ var init_errorUtil = __esm({
 });
 
 // node_modules/zod/v3/types.js
-function processCreateParams(params) {
-  if (!params)
+function processCreateParams(params2) {
+  if (!params2)
     return {};
-  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
+  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params2;
   if (errorMap2 && (invalid_type_error || required_error)) {
     throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
   }
   if (errorMap2)
     return { errorMap: errorMap2, description };
   const customMap = (iss, ctx) => {
-    const { message } = params;
+    const { message } = params2;
     if (iss.code === "invalid_enum_value") {
       return { message: message ?? ctx.defaultError };
     }
@@ -1128,15 +1128,15 @@ function mergeValues(a, b) {
     return { valid: false };
   }
 }
-function createZodEnum(values, params) {
+function createZodEnum(values, params2) {
   return new ZodEnum({
     values,
     typeName: ZodFirstPartyTypeKind.ZodEnum,
-    ...processCreateParams(params)
+    ...processCreateParams(params2)
   });
 }
-function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+function cleanParams(params2, data) {
+  const p = typeof params2 === "function" ? params2(data) : typeof params2 === "string" ? { message: params2 } : params2;
   const p2 = typeof p === "string" ? { message: p } : p;
   return p2;
 }
@@ -1147,16 +1147,16 @@ function custom(check, _params = {}, fatal) {
       if (r instanceof Promise) {
         return r.then((r2) => {
           if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+            const params2 = cleanParams(_params, data);
+            const _fatal = params2.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params2, fatal: _fatal });
           }
         });
       }
       if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+        const params2 = cleanParams(_params, data);
+        const _fatal = params2.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params2, fatal: _fatal });
       }
       return;
     });
@@ -1249,20 +1249,20 @@ var init_types = __esm({
         const result = this._parse(input);
         return Promise.resolve(result);
       }
-      parse(data, params) {
-        const result = this.safeParse(data, params);
+      parse(data, params2) {
+        const result = this.safeParse(data, params2);
         if (result.success)
           return result.data;
         throw result.error;
       }
-      safeParse(data, params) {
+      safeParse(data, params2) {
         const ctx = {
           common: {
             issues: [],
-            async: params?.async ?? false,
-            contextualErrorMap: params?.errorMap
+            async: params2?.async ?? false,
+            contextualErrorMap: params2?.errorMap
           },
-          path: params?.path || [],
+          path: params2?.path || [],
           schemaErrorMap: this._def.errorMap,
           parent: null,
           data,
@@ -1307,20 +1307,20 @@ var init_types = __esm({
           issues: ctx.common.issues
         });
       }
-      async parseAsync(data, params) {
-        const result = await this.safeParseAsync(data, params);
+      async parseAsync(data, params2) {
+        const result = await this.safeParseAsync(data, params2);
         if (result.success)
           return result.data;
         throw result.error;
       }
-      async safeParseAsync(data, params) {
+      async safeParseAsync(data, params2) {
         const ctx = {
           common: {
             issues: [],
-            contextualErrorMap: params?.errorMap,
+            contextualErrorMap: params2?.errorMap,
             async: true
           },
-          path: params?.path || [],
+          path: params2?.path || [],
           schemaErrorMap: this._def.errorMap,
           parent: null,
           data,
@@ -2046,12 +2046,12 @@ var init_types = __esm({
         return max;
       }
     };
-    ZodString.create = (params) => {
+    ZodString.create = (params2) => {
       return new ZodString({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodString,
-        coerce: params?.coerce ?? false,
-        ...processCreateParams(params)
+        coerce: params2?.coerce ?? false,
+        ...processCreateParams(params2)
       });
     };
     ZodNumber = class _ZodNumber extends ZodType {
@@ -2278,12 +2278,12 @@ var init_types = __esm({
         return Number.isFinite(min) && Number.isFinite(max);
       }
     };
-    ZodNumber.create = (params) => {
+    ZodNumber.create = (params2) => {
       return new ZodNumber({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodNumber,
-        coerce: params?.coerce || false,
-        ...processCreateParams(params)
+        coerce: params2?.coerce || false,
+        ...processCreateParams(params2)
       });
     };
     ZodBigInt = class _ZodBigInt extends ZodType {
@@ -2450,12 +2450,12 @@ var init_types = __esm({
         return max;
       }
     };
-    ZodBigInt.create = (params) => {
+    ZodBigInt.create = (params2) => {
       return new ZodBigInt({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodBigInt,
-        coerce: params?.coerce ?? false,
-        ...processCreateParams(params)
+        coerce: params2?.coerce ?? false,
+        ...processCreateParams(params2)
       });
     };
     ZodBoolean = class extends ZodType {
@@ -2476,11 +2476,11 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodBoolean.create = (params) => {
+    ZodBoolean.create = (params2) => {
       return new ZodBoolean({
         typeName: ZodFirstPartyTypeKind.ZodBoolean,
-        coerce: params?.coerce || false,
-        ...processCreateParams(params)
+        coerce: params2?.coerce || false,
+        ...processCreateParams(params2)
       });
     };
     ZodDate = class _ZodDate extends ZodType {
@@ -2584,12 +2584,12 @@ var init_types = __esm({
         return max != null ? new Date(max) : null;
       }
     };
-    ZodDate.create = (params) => {
+    ZodDate.create = (params2) => {
       return new ZodDate({
         checks: [],
-        coerce: params?.coerce || false,
+        coerce: params2?.coerce || false,
         typeName: ZodFirstPartyTypeKind.ZodDate,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodSymbol = class extends ZodType {
@@ -2607,10 +2607,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodSymbol.create = (params) => {
+    ZodSymbol.create = (params2) => {
       return new ZodSymbol({
         typeName: ZodFirstPartyTypeKind.ZodSymbol,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodUndefined = class extends ZodType {
@@ -2628,10 +2628,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodUndefined.create = (params) => {
+    ZodUndefined.create = (params2) => {
       return new ZodUndefined({
         typeName: ZodFirstPartyTypeKind.ZodUndefined,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodNull = class extends ZodType {
@@ -2649,10 +2649,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodNull.create = (params) => {
+    ZodNull.create = (params2) => {
       return new ZodNull({
         typeName: ZodFirstPartyTypeKind.ZodNull,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodAny = class extends ZodType {
@@ -2664,10 +2664,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodAny.create = (params) => {
+    ZodAny.create = (params2) => {
       return new ZodAny({
         typeName: ZodFirstPartyTypeKind.ZodAny,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodUnknown = class extends ZodType {
@@ -2679,10 +2679,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodUnknown.create = (params) => {
+    ZodUnknown.create = (params2) => {
       return new ZodUnknown({
         typeName: ZodFirstPartyTypeKind.ZodUnknown,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodNever = class extends ZodType {
@@ -2696,10 +2696,10 @@ var init_types = __esm({
         return INVALID;
       }
     };
-    ZodNever.create = (params) => {
+    ZodNever.create = (params2) => {
       return new ZodNever({
         typeName: ZodFirstPartyTypeKind.ZodNever,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodVoid = class extends ZodType {
@@ -2717,10 +2717,10 @@ var init_types = __esm({
         return OK(input.data);
       }
     };
-    ZodVoid.create = (params) => {
+    ZodVoid.create = (params2) => {
       return new ZodVoid({
         typeName: ZodFirstPartyTypeKind.ZodVoid,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodArray = class _ZodArray extends ZodType {
@@ -2814,14 +2814,14 @@ var init_types = __esm({
         return this.min(1, message);
       }
     };
-    ZodArray.create = (schema, params) => {
+    ZodArray.create = (schema, params2) => {
       return new ZodArray({
         type: schema,
         minLength: null,
         maxLength: null,
         exactLength: null,
         typeName: ZodFirstPartyTypeKind.ZodArray,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodObject = class _ZodObject extends ZodType {
@@ -3135,31 +3135,31 @@ var init_types = __esm({
         return createZodEnum(util.objectKeys(this.shape));
       }
     };
-    ZodObject.create = (shape, params) => {
+    ZodObject.create = (shape, params2) => {
       return new ZodObject({
         shape: () => shape,
         unknownKeys: "strip",
         catchall: ZodNever.create(),
         typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
-    ZodObject.strictCreate = (shape, params) => {
+    ZodObject.strictCreate = (shape, params2) => {
       return new ZodObject({
         shape: () => shape,
         unknownKeys: "strict",
         catchall: ZodNever.create(),
         typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
-    ZodObject.lazycreate = (shape, params) => {
+    ZodObject.lazycreate = (shape, params2) => {
       return new ZodObject({
         shape,
         unknownKeys: "strip",
         catchall: ZodNever.create(),
         typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodUnion = class extends ZodType {
@@ -3246,11 +3246,11 @@ var init_types = __esm({
         return this._def.options;
       }
     };
-    ZodUnion.create = (types, params) => {
+    ZodUnion.create = (types, params2) => {
       return new ZodUnion({
         options: types,
         typeName: ZodFirstPartyTypeKind.ZodUnion,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     getDiscriminator = (type) => {
@@ -3337,7 +3337,7 @@ var init_types = __esm({
        * @param types an array of object schemas
        * @param params
        */
-      static create(discriminator, options, params) {
+      static create(discriminator, options, params2) {
         const optionsMap = /* @__PURE__ */ new Map();
         for (const type of options) {
           const discriminatorValues = getDiscriminator(type.shape[discriminator]);
@@ -3356,7 +3356,7 @@ var init_types = __esm({
           discriminator,
           options,
           optionsMap,
-          ...processCreateParams(params)
+          ...processCreateParams(params2)
         });
       }
     };
@@ -3405,12 +3405,12 @@ var init_types = __esm({
         }
       }
     };
-    ZodIntersection.create = (left, right, params) => {
+    ZodIntersection.create = (left, right, params2) => {
       return new ZodIntersection({
         left,
         right,
         typeName: ZodFirstPartyTypeKind.ZodIntersection,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodTuple = class _ZodTuple extends ZodType {
@@ -3469,7 +3469,7 @@ var init_types = __esm({
         });
       }
     };
-    ZodTuple.create = (schemas, params) => {
+    ZodTuple.create = (schemas, params2) => {
       if (!Array.isArray(schemas)) {
         throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
       }
@@ -3477,7 +3477,7 @@ var init_types = __esm({
         items: schemas,
         typeName: ZodFirstPartyTypeKind.ZodTuple,
         rest: null,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodRecord = class _ZodRecord extends ZodType {
@@ -3591,12 +3591,12 @@ var init_types = __esm({
         }
       }
     };
-    ZodMap.create = (keyType, valueType, params) => {
+    ZodMap.create = (keyType, valueType, params2) => {
       return new ZodMap({
         valueType,
         keyType,
         typeName: ZodFirstPartyTypeKind.ZodMap,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodSet = class _ZodSet extends ZodType {
@@ -3675,13 +3675,13 @@ var init_types = __esm({
         return this.min(1, message);
       }
     };
-    ZodSet.create = (valueType, params) => {
+    ZodSet.create = (valueType, params2) => {
       return new ZodSet({
         valueType,
         minSize: null,
         maxSize: null,
         typeName: ZodFirstPartyTypeKind.ZodSet,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodFunction = class _ZodFunction extends ZodType {
@@ -3721,18 +3721,18 @@ var init_types = __esm({
             }
           });
         }
-        const params = { errorMap: ctx.common.contextualErrorMap };
+        const params2 = { errorMap: ctx.common.contextualErrorMap };
         const fn = ctx.data;
         if (this._def.returns instanceof ZodPromise) {
           const me = this;
           return OK(async function(...args) {
             const error = new ZodError([]);
-            const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+            const parsedArgs = await me._def.args.parseAsync(args, params2).catch((e) => {
               error.addIssue(makeArgsIssue(args, e));
               throw error;
             });
             const result = await Reflect.apply(fn, this, parsedArgs);
-            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
+            const parsedReturns = await me._def.returns._def.type.parseAsync(result, params2).catch((e) => {
               error.addIssue(makeReturnsIssue(result, e));
               throw error;
             });
@@ -3741,12 +3741,12 @@ var init_types = __esm({
         } else {
           const me = this;
           return OK(function(...args) {
-            const parsedArgs = me._def.args.safeParse(args, params);
+            const parsedArgs = me._def.args.safeParse(args, params2);
             if (!parsedArgs.success) {
               throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
             }
             const result = Reflect.apply(fn, this, parsedArgs.data);
-            const parsedReturns = me._def.returns.safeParse(result, params);
+            const parsedReturns = me._def.returns.safeParse(result, params2);
             if (!parsedReturns.success) {
               throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
             }
@@ -3780,12 +3780,12 @@ var init_types = __esm({
         const validatedFunc = this.parse(func);
         return validatedFunc;
       }
-      static create(args, returns, params) {
+      static create(args, returns, params2) {
         return new _ZodFunction({
           args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
           returns: returns || ZodUnknown.create(),
           typeName: ZodFirstPartyTypeKind.ZodFunction,
-          ...processCreateParams(params)
+          ...processCreateParams(params2)
         });
       }
     };
@@ -3799,11 +3799,11 @@ var init_types = __esm({
         return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
       }
     };
-    ZodLazy.create = (getter, params) => {
+    ZodLazy.create = (getter, params2) => {
       return new ZodLazy({
         getter,
         typeName: ZodFirstPartyTypeKind.ZodLazy,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodLiteral = class extends ZodType {
@@ -3823,11 +3823,11 @@ var init_types = __esm({
         return this._def.value;
       }
     };
-    ZodLiteral.create = (value, params) => {
+    ZodLiteral.create = (value, params2) => {
       return new ZodLiteral({
         value,
         typeName: ZodFirstPartyTypeKind.ZodLiteral,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodEnum = class _ZodEnum extends ZodType {
@@ -3926,11 +3926,11 @@ var init_types = __esm({
         return this._def.values;
       }
     };
-    ZodNativeEnum.create = (values, params) => {
+    ZodNativeEnum.create = (values, params2) => {
       return new ZodNativeEnum({
         values,
         typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodPromise = class extends ZodType {
@@ -3956,11 +3956,11 @@ var init_types = __esm({
         }));
       }
     };
-    ZodPromise.create = (schema, params) => {
+    ZodPromise.create = (schema, params2) => {
       return new ZodPromise({
         type: schema,
         typeName: ZodFirstPartyTypeKind.ZodPromise,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodEffects = class extends ZodType {
@@ -4086,20 +4086,20 @@ var init_types = __esm({
         util.assertNever(effect);
       }
     };
-    ZodEffects.create = (schema, effect, params) => {
+    ZodEffects.create = (schema, effect, params2) => {
       return new ZodEffects({
         schema,
         typeName: ZodFirstPartyTypeKind.ZodEffects,
         effect,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
-    ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+    ZodEffects.createWithPreprocess = (preprocess, schema, params2) => {
       return new ZodEffects({
         schema,
         effect: { type: "preprocess", transform: preprocess },
         typeName: ZodFirstPartyTypeKind.ZodEffects,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodOptional = class extends ZodType {
@@ -4114,11 +4114,11 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodOptional.create = (type, params) => {
+    ZodOptional.create = (type, params2) => {
       return new ZodOptional({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodOptional,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodNullable = class extends ZodType {
@@ -4133,11 +4133,11 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodNullable.create = (type, params) => {
+    ZodNullable.create = (type, params2) => {
       return new ZodNullable({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodNullable,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     ZodDefault = class extends ZodType {
@@ -4157,12 +4157,12 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodDefault.create = (type, params) => {
+    ZodDefault.create = (type, params2) => {
       return new ZodDefault({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodDefault,
-        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
-        ...processCreateParams(params)
+        defaultValue: typeof params2.default === "function" ? params2.default : () => params2.default,
+        ...processCreateParams(params2)
       });
     };
     ZodCatch = class extends ZodType {
@@ -4210,12 +4210,12 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodCatch.create = (type, params) => {
+    ZodCatch.create = (type, params2) => {
       return new ZodCatch({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodCatch,
-        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-        ...processCreateParams(params)
+        catchValue: typeof params2.catch === "function" ? params2.catch : () => params2.catch,
+        ...processCreateParams(params2)
       });
     };
     ZodNaN = class extends ZodType {
@@ -4233,10 +4233,10 @@ var init_types = __esm({
         return { status: "valid", value: input.data };
       }
     };
-    ZodNaN.create = (params) => {
+    ZodNaN.create = (params2) => {
       return new ZodNaN({
         typeName: ZodFirstPartyTypeKind.ZodNaN,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     BRAND = Symbol("zod_brand");
@@ -4324,11 +4324,11 @@ var init_types = __esm({
         return this._def.innerType;
       }
     };
-    ZodReadonly.create = (type, params) => {
+    ZodReadonly.create = (type, params2) => {
       return new ZodReadonly({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodReadonly,
-        ...processCreateParams(params)
+        ...processCreateParams(params2)
       });
     };
     late = {
@@ -4372,9 +4372,9 @@ var init_types = __esm({
       ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
       ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
     })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-    instanceOfType = (cls, params = {
+    instanceOfType = (cls, params2 = {
       message: `Input not instance of ${cls.name}`
-    }) => custom((data) => data instanceof cls, params);
+    }) => custom((data) => data instanceof cls, params2);
     stringType = ZodString.create;
     numberType = ZodNumber.create;
     nanType = ZodNaN.create;
@@ -8611,6 +8611,716 @@ var init_storage = __esm({
   }
 });
 
+// src/openapi.ts
+function params(properties, required) {
+  return { type: "object", additionalProperties: false, properties, required: [...required] };
+}
+function schemaBaseName(method) {
+  return method.split(".").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function errorResponseSpec(description, codes) {
+  return {
+    description,
+    content: {
+      "application/json": {
+        schema: { $ref: "#/components/schemas/RpcErrorResponse" },
+        example: {
+          version: 1,
+          id: "req-1",
+          error: { code: codes[0], message: "see the daemon response for detail" }
+        }
+      }
+    }
+  };
+}
+function documentResponseSpec(description, mediaType) {
+  return { description, content: { [mediaType]: { schema: { type: "string" } } } };
+}
+function buildOpenApiDocument() {
+  const schemas = {
+    RpcId: {
+      description: "Caller-chosen correlation id echoed in the response.",
+      oneOf: [
+        { type: "string", minLength: 1, maxLength: 256 },
+        { type: "integer", minimum: 0 }
+      ]
+    },
+    RpcError: {
+      type: "object",
+      additionalProperties: false,
+      required: ["code", "message"],
+      properties: {
+        code: {
+          type: "string",
+          enum: RPC_ERROR_CODES.map(([code]) => code),
+          description: RPC_ERROR_CODES.map(([code, text]) => `\`${code}\`: ${text}`).join(" ")
+        },
+        message: { type: "string", description: "Human-readable detail. Not machine-parsed." }
+      }
+    },
+    RpcSuccessResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["version", "id", "result"],
+      properties: {
+        version: { type: "integer", const: 1 },
+        id: { $ref: "#/components/schemas/RpcId" },
+        result: {
+          description: "Method-specific result. See the individual method descriptions."
+        }
+      }
+    },
+    RpcErrorResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["version", "id", "error"],
+      properties: {
+        version: { type: "integer", const: 1 },
+        id: {
+          description: "The request id, or null when it could not be recovered from the body.",
+          oneOf: [{ $ref: "#/components/schemas/RpcId" }, { type: "null" }]
+        },
+        error: { $ref: "#/components/schemas/RpcError" }
+      }
+    }
+  };
+  const requestSchemaNames = [];
+  const discriminatorMapping = {};
+  for (const entry of ROOM_RPC_METHODS) {
+    const base = schemaBaseName(entry.method);
+    const paramsName = `${base}Params`;
+    const requestName = `${base}Request`;
+    schemas[paramsName] = { ...entry.params, description: `Parameters for \`${entry.method}\`.` };
+    schemas[requestName] = {
+      type: "object",
+      additionalProperties: false,
+      required: ["version", "id", "method", "params"],
+      title: entry.summary,
+      description: `${entry.description}
+
+Result: ${entry.result}`,
+      properties: {
+        version: { type: "integer", const: 1 },
+        id: { $ref: "#/components/schemas/RpcId" },
+        method: { type: "string", const: entry.method },
+        params: { $ref: `#/components/schemas/${paramsName}` }
+      },
+      examples: [{ version: 1, id: "req-1", method: entry.method, params: entry.example }]
+    };
+    requestSchemaNames.push(requestName);
+    discriminatorMapping[entry.method] = `#/components/schemas/${requestName}`;
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "ours-cowork room management API",
+      version: API_VERSION,
+      summary: "Loopback REST control surface for cowork mission rooms.",
+      description: [
+        'Every room-management operation is carried by a single REST route, `POST /rpc`, using the versioned RPC envelope `{ "version": 1, "id": ..., "method": ..., "params": ... }`. The `method` field selects the operation; the request schemas below are discriminated on it.',
+        "",
+        "The listener binds `127.0.0.1` only and has no authentication, so it accepts requests whose `Host` header is `127.0.0.1:<port>` or `localhost:<port>`, rejects cross-site fetches, and must not be exposed to other hosts through forwarding or a proxy.",
+        "",
+        "Requests must declare `Content-Type: application/json` and stay within 1 MiB. Operations that need an invite secret are not served here: they are reachable only over the daemon's private Unix socket."
+      ].join("\n"),
+      license: { name: "FSL-1.1-Apache-2.0" }
+    },
+    servers: [{ url: "/", description: "This cowork daemon, on its loopback REST port." }],
+    tags: [
+      { name: "rooms", description: "Room management over the RPC envelope." },
+      { name: "documentation", description: "The API description and its browser UI." }
+    ],
+    paths: {
+      [RPC_PATH]: {
+        post: {
+          tags: ["rooms"],
+          operationId: "roomManagementRpc",
+          summary: "Invoke a room-management method",
+          description: "Dispatches one room-management method. The HTTP status reflects the envelope outcome: 200 on success, 404 when the method is not served over REST, 500 on an internal failure, and 400 for every other error code \u2014 including `not_found`.",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  oneOf: requestSchemaNames.map((name) => ({ $ref: `#/components/schemas/${name}` })),
+                  discriminator: { propertyName: "method", mapping: discriminatorMapping }
+                }
+              }
+            }
+          },
+          responses: {
+            200: {
+              description: "The method completed. `result` is method-specific.",
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/RpcSuccessResponse" }
+                }
+              }
+            },
+            400: errorResponseSpec(
+              "The envelope, parameters, or room state rejected the call.",
+              [
+                "invalid_params",
+                "invalid_json",
+                "invalid_request",
+                "not_found",
+                "invalid_state",
+                "shutting_down"
+              ]
+            ),
+            403: errorResponseSpec(
+              "The Host header was not a loopback console authority, the Origin did not match it, or the fetch was cross-site.",
+              ["forbidden"]
+            ),
+            404: errorResponseSpec(
+              "The method is not part of the REST route table.",
+              ["method_not_found"]
+            ),
+            413: errorResponseSpec("The request body exceeded 1 MiB.", ["request_too_large"]),
+            415: errorResponseSpec(
+              "The request did not declare `application/json`.",
+              ["unsupported_media_type"]
+            ),
+            500: errorResponseSpec("The daemon failed to complete the operation.", ["internal"])
+          }
+        }
+      },
+      [OPENAPI_DOCUMENT_PATH]: {
+        get: {
+          tags: ["documentation"],
+          operationId: "getOpenApiDocument",
+          summary: "Fetch this OpenAPI document",
+          description: "Returns the OpenAPI 3.1 description of the room-management REST API.",
+          responses: {
+            200: {
+              description: "The OpenAPI document.",
+              content: { "application/json": { schema: { type: "object" } } }
+            }
+          }
+        }
+      },
+      [API_DOCS_PATH]: {
+        get: {
+          tags: ["documentation"],
+          operationId: "getApiDocsPage",
+          summary: "Open the API documentation UI",
+          description: `Serves the browser UI that renders \`${OPENAPI_DOCUMENT_PATH}\`.`,
+          responses: { 200: documentResponseSpec("The documentation page.", "text/html") }
+        }
+      },
+      [API_DOCS_SCRIPT_PATH]: {
+        get: {
+          tags: ["documentation"],
+          operationId: "getApiDocsScript",
+          summary: "Fetch the documentation UI script",
+          responses: { 200: documentResponseSpec("The UI script.", "text/javascript") }
+        }
+      },
+      [API_DOCS_STYLESHEET_PATH]: {
+        get: {
+          tags: ["documentation"],
+          operationId: "getApiDocsStylesheet",
+          summary: "Fetch the documentation UI stylesheet",
+          responses: { 200: documentResponseSpec("The UI stylesheet.", "text/css") }
+        }
+      }
+    },
+    components: { schemas }
+  };
+}
+function apiDocsAsset(pathname) {
+  switch (pathname) {
+    case OPENAPI_DOCUMENT_PATH:
+      return {
+        body: `${JSON.stringify(buildOpenApiDocument(), null, 2)}
+`,
+        contentType: "application/json; charset=utf-8"
+      };
+    case API_DOCS_PATH:
+      return { body: DOCS_PAGE, contentType: "text/html; charset=utf-8" };
+    case API_DOCS_SCRIPT_PATH:
+      return { body: DOCS_SCRIPT, contentType: "text/javascript; charset=utf-8" };
+    case API_DOCS_STYLESHEET_PATH:
+      return { body: DOCS_STYLESHEET, contentType: "text/css; charset=utf-8" };
+    default:
+      return void 0;
+  }
+}
+var RPC_PATH, OPENAPI_DOCUMENT_PATH, API_DOCS_PATH, API_DOCS_SCRIPT_PATH, API_DOCS_STYLESHEET_PATH, API_VERSION, EXAMPLE_ROOM_ID, roomIdProperty, roleProperty, missionTextProperty, roomNameProperty, inviteModeProperty, notifyProperty, ROOM_RPC_METHODS, RPC_ERROR_CODES, DOCS_PAGE, DOCS_STYLESHEET, DOCS_SCRIPT;
+var init_openapi = __esm({
+  "src/openapi.ts"() {
+    "use strict";
+    RPC_PATH = "/rpc";
+    OPENAPI_DOCUMENT_PATH = "/openapi.json";
+    API_DOCS_PATH = "/docs";
+    API_DOCS_SCRIPT_PATH = "/docs/ui.js";
+    API_DOCS_STYLESHEET_PATH = "/docs/ui.css";
+    API_VERSION = "1";
+    EXAMPLE_ROOM_ID = "01jd7q4h9m2v8xk3znbc5regty";
+    roomIdProperty = {
+      type: "string",
+      pattern: "^[0-7][0-9a-hjkmnp-tv-z]{25}$",
+      description: "26-character lowercase Crockford ULID identifying the room."
+    };
+    roleProperty = {
+      type: "string",
+      description: "Invite role. At most 256 UTF-8 bytes."
+    };
+    missionTextProperty = (what) => ({
+      type: "string",
+      description: `${what}. At most 262144 UTF-8 bytes.`
+    });
+    roomNameProperty = {
+      type: "string",
+      description: "Friendly room name: 1-64 Unicode characters after trimming and NFC normalization, with no Unicode control or format characters. Duplicates are allowed."
+    };
+    inviteModeProperty = {
+      type: "string",
+      enum: ["one_time", "public"],
+      description: "Invitation mode. `one_time` requires `min_accepts` to be 1."
+    };
+    notifyProperty = {
+      type: "boolean",
+      description: "Announce the membership change to the room. Defaults to the room's quiet setting."
+    };
+    ROOM_RPC_METHODS = [
+      {
+        method: "room.create",
+        summary: "Create a room",
+        description: "Provisions a room, its durable metadata, and its room packet. The room stays in the provisioning state until its invitation requirements are satisfied.",
+        params: params({
+          name: roomNameProperty,
+          goal: missionTextProperty("Mission goal"),
+          briefing: missionTextProperty("Mission briefing"),
+          anonymous: {
+            type: "boolean",
+            description: "Project participants under aliases instead of contact identities."
+          },
+          quiet_membership: {
+            type: "boolean",
+            description: "Suppress membership announcements for this room by default."
+          }
+        }, ["goal", "briefing"]),
+        result: "The created room record, including `room_id`, `room_name`, `state`, mission, invites, and seats.",
+        example: { goal: "Ship the release", briefing: "Coordinate the 1.0 cut.", name: "Release" }
+      },
+      {
+        method: "room.settings",
+        summary: "Update room settings",
+        description: "Updates mutable room settings. At least one setting besides `room_id` is required; omitted settings are left unchanged.",
+        params: params({
+          room_id: roomIdProperty,
+          name: roomNameProperty,
+          goal: missionTextProperty("Replacement mission goal"),
+          briefing: missionTextProperty("Replacement mission briefing"),
+          status: { type: "string", minLength: 1, description: "Operator status line." },
+          quiet_membership: {
+            type: "boolean",
+            description: "Suppress membership announcements for this room."
+          }
+        }, ["room_id"]),
+        result: "The updated room record.",
+        example: { room_id: EXAMPLE_ROOM_ID, name: "Release cut" }
+      },
+      {
+        method: "room.briefing.role.set",
+        summary: "Set a role briefing",
+        description: "Creates or replaces the briefing for one role and bumps its briefing version.",
+        params: params({
+          room_id: roomIdProperty,
+          role: roleProperty,
+          text: missionTextProperty("Role briefing text")
+        }, ["room_id", "role", "text"]),
+        result: "The updated room record with the stored role briefing.",
+        example: { room_id: EXAMPLE_ROOM_ID, role: "Reviewer", text: "Review every merge request." }
+      },
+      {
+        method: "room.briefing.role.delete",
+        summary: "Delete a role briefing",
+        description: "Removes the briefing for one role.",
+        params: params({ room_id: roomIdProperty, role: roleProperty }, ["room_id", "role"]),
+        result: "The updated room record without the removed role briefing.",
+        example: { room_id: EXAMPLE_ROOM_ID, role: "Reviewer" }
+      },
+      {
+        method: "room.invite",
+        summary: "Mint an invitation requirement",
+        description: "Mints one invitation requirement and returns its receipt. The invite secret is returned once in `blob` and is never stored in room metadata or replayed by any later call.",
+        params: params({
+          room_id: roomIdProperty,
+          mode: inviteModeProperty,
+          role: roleProperty,
+          min_accepts: {
+            type: "integer",
+            minimum: 1,
+            description: "Acceptances required before the requirement is satisfied. Must be 1 for `one_time` invites."
+          }
+        }, ["room_id", "mode", "min_accepts"]),
+        result: "An invite receipt: `room_id`, the recorded `invite`, the one-shot `blob` secret, and `reusable`.",
+        example: { room_id: EXAMPLE_ROOM_ID, mode: "one_time", role: "Reviewer", min_accepts: 1 }
+      },
+      {
+        method: "room.participant.remove",
+        summary: "Remove a participant",
+        description: "Removes one participant seat, bumps the membership epoch, and severs the contact. The receipt reports what actually happened, including retained key material.",
+        params: params({
+          room_id: roomIdProperty,
+          participant: {
+            type: "string",
+            minLength: 1,
+            description: "Participant id, identity, display name, or alias."
+          },
+          notify: notifyProperty
+        }, ["room_id", "participant"]),
+        result: "A removal receipt with `participant_id`, `epoch`, `status`, `notified`, and `key_material_retained`.",
+        example: { room_id: EXAMPLE_ROOM_ID, participant: "Reviewer-1", notify: true }
+      },
+      {
+        method: "room.participant.replace",
+        summary: "Replace a participant",
+        description: "Removes one participant seat and mints a replacement invitation requirement in the same operation.",
+        params: params({
+          room_id: roomIdProperty,
+          participant: {
+            type: "string",
+            minLength: 1,
+            description: "Participant id, identity, display name, or alias."
+          },
+          notify: notifyProperty,
+          mode: inviteModeProperty,
+          min_accepts: {
+            type: "integer",
+            minimum: 1,
+            description: "Acceptances required for the replacement invitation requirement."
+          }
+        }, ["room_id", "participant"]),
+        result: "An invite receipt for the replacement, extended with the `removal` receipt.",
+        example: { room_id: EXAMPLE_ROOM_ID, participant: "Reviewer-1", mode: "one_time" }
+      },
+      {
+        method: "room.revoke",
+        summary: "Revoke an invitation requirement",
+        description: "Revokes one live invitation requirement so it can no longer admit a seat.",
+        params: params({
+          room_id: roomIdProperty,
+          invite_id: { type: "string", minLength: 1, description: "Recorded invite identifier." }
+        }, ["room_id", "invite_id"]),
+        result: "The updated room record with the invite marked revoked.",
+        example: { room_id: EXAMPLE_ROOM_ID, invite_id: "inv-01" }
+      },
+      {
+        method: "room.recover",
+        summary: "Recover unusable invitations",
+        description: "Mints recovery invitations for requirements whose secret can no longer admit a seat. Each recovery must be confirmed before it replaces the original.",
+        params: params({ room_id: roomIdProperty }, ["room_id"]),
+        result: "The list of recovery invite receipts, each carrying `recovery_of`.",
+        example: { room_id: EXAMPLE_ROOM_ID }
+      },
+      {
+        method: "room.recover.confirm",
+        summary: "Confirm a recovery invitation",
+        description: "Confirms that a recovery invitation was handed over, retiring the invitation requirement it recovers.",
+        params: params({
+          room_id: roomIdProperty,
+          recovery_of: { type: "string", minLength: 1, description: "Invite id being recovered." },
+          invite_id: { type: "string", minLength: 1, description: "Recovery invite id to confirm." }
+        }, ["room_id", "recovery_of", "invite_id"]),
+        result: "The updated room record with the confirmed recovery.",
+        example: { room_id: EXAMPLE_ROOM_ID, recovery_of: "inv-01", invite_id: "inv-02" }
+      },
+      {
+        method: "room.list",
+        summary: "List rooms",
+        description: "Lists every room held on this host. Takes no parameters.",
+        params: params({}, []),
+        result: "An array of room records.",
+        example: {}
+      },
+      {
+        method: "room.show",
+        summary: "Show one room",
+        description: "Returns the complete durable record for one room.",
+        params: params({ room_id: roomIdProperty }, ["room_id"]),
+        result: "The room record.",
+        example: { room_id: EXAMPLE_ROOM_ID }
+      },
+      {
+        method: "room.participants",
+        summary: "List participants",
+        description: "Returns the room's seats, including pending, active, and removed states.",
+        params: params({ room_id: roomIdProperty }, ["room_id"]),
+        result: "An array of seat records.",
+        example: { room_id: EXAMPLE_ROOM_ID }
+      },
+      {
+        method: "room.history",
+        summary: "Read room history",
+        description: "Reads one page of the room's ordered communication archive. The operator view returns every record kind; the participant view returns message records only, with routing identities removed and authors reduced to alias form in anonymous rooms.",
+        params: params({
+          room_id: roomIdProperty,
+          after: {
+            type: "integer",
+            minimum: 0,
+            description: "Return records with a sequence number greater than this value."
+          },
+          limit: { type: "integer", minimum: 1, description: "Maximum number of records to return." },
+          view: {
+            type: "string",
+            enum: ["operator", "participant"],
+            description: "History projection. Defaults to the operator view."
+          }
+        }, ["room_id"]),
+        result: "An array of communication records, byte-bounded to one page.",
+        example: { room_id: EXAMPLE_ROOM_ID, after: 0, limit: 50, view: "operator" }
+      },
+      {
+        method: "room.message",
+        summary: "Post an operator message",
+        description: "Appends an operator message to the room archive and relays it to active seats. Authorship is assigned by the daemon.",
+        params: params({
+          room_id: roomIdProperty,
+          text: missionTextProperty("Message text")
+        }, ["room_id", "text"]),
+        result: "The appended message record with its `seq` and `record_id`.",
+        example: { room_id: EXAMPLE_ROOM_ID, text: "Standup at 10:00." }
+      },
+      {
+        method: "room.close",
+        summary: "Close a room",
+        description: "Closes the room forward-only. The plaintext local archive is left in place.",
+        params: params({ room_id: roomIdProperty }, ["room_id"]),
+        result: "The closed room record.",
+        example: { room_id: EXAMPLE_ROOM_ID }
+      },
+      {
+        method: "room.delete",
+        summary: "Delete a room",
+        description: "Removes this host's local room state after the room is closed. The scope is this host only.",
+        params: params({
+          room_id: roomIdProperty,
+          confirm: { type: "boolean", const: true, description: "Must be `true`." }
+        }, ["room_id", "confirm"]),
+        result: 'A delete receipt: `{ "version": 1, "room_id": "...", "deleted": true, "scope": "this_host" }`.',
+        example: { room_id: EXAMPLE_ROOM_ID, confirm: true }
+      }
+    ];
+    RPC_ERROR_CODES = [
+      ["invalid_json", "The request body was not valid JSON."],
+      ["invalid_request", "The RPC envelope did not match the strict envelope schema."],
+      ["invalid_params", "The `params` object failed method validation."],
+      ["not_found", "The referenced room or record does not exist."],
+      ["invalid_state", "The room is not in a state that permits the operation."],
+      ["shutting_down", "The daemon stopped accepting work."],
+      ["method_not_found", "The method is not served over REST."],
+      ["unsupported_media_type", "The request did not declare `application/json`."],
+      ["forbidden", "The request origin or Host header was not the loopback console origin."],
+      ["request_too_large", "The request body exceeded 1 MiB."],
+      ["internal", "The daemon failed to complete the operation."]
+    ];
+    DOCS_PAGE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ours-cowork room management API</title>
+<link rel="stylesheet" href="${API_DOCS_STYLESHEET_PATH}">
+</head>
+<body>
+<main id="api-docs" data-document="${OPENAPI_DOCUMENT_PATH}" data-rpc="${RPC_PATH}">
+<p class="loading">Loading <code>${OPENAPI_DOCUMENT_PATH}</code>&hellip;</p>
+</main>
+<script src="${API_DOCS_SCRIPT_PATH}"></script>
+</body>
+</html>
+`;
+    DOCS_STYLESHEET = `:root { color-scheme: light dark; --line: #8883; --accent: #2563eb; }
+* { box-sizing: border-box; }
+body { margin: 0; font: 15px/1.5 ui-sans-serif, system-ui, sans-serif; }
+main { margin: 0 auto; max-width: 60rem; padding: 2rem 1.25rem 4rem; }
+h1 { font-size: 1.6rem; margin: 0 0 .25rem; }
+h2 { font-size: 1.15rem; margin: 2rem 0 .5rem; }
+code, pre, textarea { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .86em; }
+pre { background: #8881; border-radius: 6px; margin: 0; overflow-x: auto; padding: .6rem .75rem; }
+.subtitle { color: #8889; margin: 0 0 1rem; }
+.intro { border-left: 3px solid var(--accent); padding-left: .9rem; white-space: pre-wrap; }
+.route { border: 1px solid var(--line); border-radius: 8px; margin-bottom: .5rem; padding: .6rem .8rem; }
+.verb { background: var(--accent); border-radius: 4px; color: #fff; font-size: .72rem;
+  font-weight: 700; letter-spacing: .04em; margin-right: .5rem; padding: .12rem .4rem; }
+details.method { border: 1px solid var(--line); border-radius: 8px; margin-bottom: .5rem; }
+details.method > summary { cursor: pointer; padding: .6rem .8rem; }
+details.method[open] > summary { border-bottom: 1px solid var(--line); }
+summary .name { font-family: ui-monospace, monospace; font-weight: 600; }
+summary .summary-text { color: #8889; margin-left: .6rem; }
+.body { padding: .8rem; }
+.description { margin: 0 0 .8rem; white-space: pre-wrap; }
+table { border-collapse: collapse; margin-bottom: .8rem; width: 100%; }
+th, td { border-bottom: 1px solid var(--line); padding: .35rem .5rem; text-align: left;
+  vertical-align: top; }
+th { font-size: .78rem; letter-spacing: .04em; text-transform: uppercase; }
+td.param { font-family: ui-monospace, monospace; white-space: nowrap; }
+.required { color: #b91c1c; font-size: .75rem; margin-left: .3rem; }
+textarea { border: 1px solid var(--line); border-radius: 6px; padding: .5rem; width: 100%; }
+button { background: var(--accent); border: 0; border-radius: 6px; color: #fff; cursor: pointer;
+  font: inherit; margin: .5rem 0; padding: .4rem 1rem; }
+.status { font-weight: 600; margin: .5rem 0 .35rem; }
+.status.failed { color: #b91c1c; }
+.error { color: #b91c1c; }
+`;
+    DOCS_SCRIPT = `'use strict';
+(function () {
+  var root = document.getElementById('api-docs');
+  var documentUrl = root.dataset.document;
+  var rpcUrl = root.dataset.rpc;
+
+  function element(tag, className, text) {
+    var node = document.createElement(tag);
+    if (className) node.className = className;
+    if (text !== undefined) node.textContent = text;
+    return node;
+  }
+
+  function resolveRef(spec, ref) {
+    return ref.replace(/^#\\//, '').split('/').reduce(function (node, part) {
+      return node === undefined ? undefined : node[part];
+    }, spec);
+  }
+
+  function typeLabel(schema) {
+    if (!schema) return 'any';
+    if (schema.const !== undefined) return JSON.stringify(schema.const);
+    if (schema.enum) return schema.enum.map(function (value) { return JSON.stringify(value); }).join(' | ');
+    return schema.type || 'any';
+  }
+
+  function parameterTable(schema) {
+    var properties = (schema && schema.properties) || {};
+    var names = Object.keys(properties);
+    if (names.length === 0) return element('p', 'description', 'No parameters.');
+    var required = (schema && schema.required) || [];
+    var table = document.createElement('table');
+    var head = table.insertRow();
+    ['Parameter', 'Type', 'Description'].forEach(function (label) {
+      head.appendChild(element('th', null, label));
+    });
+    names.forEach(function (name) {
+      var property = properties[name];
+      var row = table.insertRow();
+      var cell = element('td', 'param', name);
+      if (required.indexOf(name) >= 0) cell.appendChild(element('span', 'required', 'required'));
+      row.appendChild(cell);
+      row.appendChild(element('td', null, typeLabel(property)));
+      row.appendChild(element('td', null, property.description || ''));
+    });
+    return table;
+  }
+
+  function tryItPanel(example) {
+    var panel = document.createElement('div');
+    var input = document.createElement('textarea');
+    input.rows = Math.min(14, JSON.stringify(example, null, 2).split('\\n').length + 1);
+    input.value = JSON.stringify(example, null, 2);
+    input.setAttribute('aria-label', 'Request body');
+    var send = element('button', null, 'Send request');
+    var output = document.createElement('div');
+    send.addEventListener('click', function () {
+      var body = input.value;
+      try { JSON.parse(body); } catch (error) {
+        output.textContent = '';
+        output.appendChild(element('p', 'status failed', 'Request body is not valid JSON.'));
+        return;
+      }
+      send.disabled = true;
+      output.textContent = '';
+      output.appendChild(element('p', 'status', 'Sending\\u2026'));
+      fetch(rpcUrl, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: body,
+      }).then(function (response) {
+        return response.text().then(function (text) { return { status: response.status, text: text }; });
+      }).then(function (result) {
+        var pretty = result.text;
+        try { pretty = JSON.stringify(JSON.parse(result.text), null, 2); } catch (error) { /* raw */ }
+        output.textContent = '';
+        output.appendChild(element(
+          'p',
+          result.status === 200 ? 'status' : 'status failed',
+          'HTTP ' + result.status
+        ));
+        output.appendChild(element('pre', null, pretty));
+      }).catch(function (error) {
+        output.textContent = '';
+        output.appendChild(element('p', 'status failed', 'Request failed: ' + error));
+      }).then(function () { send.disabled = false; });
+    });
+    panel.appendChild(element('h3', null, 'Try it'));
+    panel.appendChild(input);
+    panel.appendChild(send);
+    panel.appendChild(output);
+    return panel;
+  }
+
+  function methodPanel(spec, ref) {
+    var schema = resolveRef(spec, ref);
+    var method = schema.properties.method.const;
+    var panel = element('details', 'method');
+    var summary = document.createElement('summary');
+    summary.appendChild(element('span', 'name', method));
+    summary.appendChild(element('span', 'summary-text', schema.title || ''));
+    panel.appendChild(summary);
+    var body = element('div', 'body');
+    body.appendChild(element('p', 'description', schema.description || ''));
+    body.appendChild(parameterTable(resolveRef(spec, schema.properties.params.$ref)));
+    body.appendChild(tryItPanel((schema.examples && schema.examples[0]) || {
+      version: 1, id: 'req-1', method: method, params: {},
+    }));
+    panel.appendChild(body);
+    return panel;
+  }
+
+  function renderRoutes(spec) {
+    var section = document.createDocumentFragment();
+    Object.keys(spec.paths).forEach(function (path) {
+      Object.keys(spec.paths[path]).forEach(function (verb) {
+        var operation = spec.paths[path][verb];
+        var route = element('div', 'route');
+        var heading = document.createElement('div');
+        heading.appendChild(element('span', 'verb', verb.toUpperCase()));
+        heading.appendChild(element('code', null, path));
+        route.appendChild(heading);
+        route.appendChild(element('p', 'description', operation.summary || ''));
+        section.appendChild(route);
+      });
+    });
+    return section;
+  }
+
+  function render(spec) {
+    root.textContent = '';
+    root.appendChild(element('h1', null, spec.info.title));
+    root.appendChild(element('p', 'subtitle', 'API version ' + spec.info.version + ' \\u00b7 OpenAPI ' + spec.openapi));
+    root.appendChild(element('p', 'intro', spec.info.description || ''));
+    root.appendChild(element('h2', null, 'Routes'));
+    root.appendChild(renderRoutes(spec));
+    root.appendChild(element('h2', null, 'Room management methods'));
+    var alternatives = spec.paths[rpcUrl].post.requestBody.content['application/json'].schema.oneOf;
+    alternatives.forEach(function (alternative) {
+      root.appendChild(methodPanel(spec, alternative.$ref));
+    });
+  }
+
+  fetch(documentUrl).then(function (response) {
+    if (!response.ok) throw new Error('HTTP ' + response.status);
+    return response.json();
+  }).then(render).catch(function (error) {
+    root.textContent = '';
+    root.appendChild(element('p', 'error', 'Could not load ' + documentUrl + ': ' + error));
+  });
+}());
+`;
+  }
+});
+
 // src/web.ts
 import * as nodeFs4 from "node:fs";
 import { extname, join as join5 } from "node:path";
@@ -8777,8 +9487,8 @@ import * as nodeFs5 from "node:fs";
 import { basename, dirname as dirname5, join as join6 } from "node:path";
 function createServiceRoutes(service) {
   return {
-    "room.create": { auth: true, run: (params) => service.createRoom(params) },
-    "room.settings": { auth: true, run: (params) => {
+    "room.create": { auth: true, run: (params2) => service.createRoom(params2) },
+    "room.settings": { auth: true, run: (params2) => {
       const { room_id, ...input } = external_exports.object({
         room_id: external_exports.string(),
         name: external_exports.unknown().optional(),
@@ -8786,68 +9496,68 @@ function createServiceRoutes(service) {
         briefing: external_exports.unknown().optional(),
         status: external_exports.unknown().optional(),
         quiet_membership: external_exports.unknown().optional()
-      }).strict().parse(params);
+      }).strict().parse(params2);
       return service.updateRoom(room_id, input);
     } },
-    "room.briefing.role.set": { auth: true, run: (params) => {
-      const { room_id, ...input } = RoleBriefingSetParams.parse(params);
+    "room.briefing.role.set": { auth: true, run: (params2) => {
+      const { room_id, ...input } = RoleBriefingSetParams.parse(params2);
       return service.setRoleBriefing(room_id, input);
     } },
-    "room.briefing.role.delete": { auth: true, run: (params) => {
-      const { room_id, ...input } = RoleBriefingDeleteParams.parse(params);
+    "room.briefing.role.delete": { auth: true, run: (params2) => {
+      const { room_id, ...input } = RoleBriefingDeleteParams.parse(params2);
       return service.deleteRoleBriefing(room_id, input);
     } },
-    "room.invite": { auth: true, run: (params) => {
+    "room.invite": { auth: true, run: (params2) => {
       const { room_id, ...input } = external_exports.object({
         room_id: external_exports.string(),
         mode: external_exports.unknown(),
         role: external_exports.unknown().optional(),
         min_accepts: external_exports.unknown()
-      }).strict().parse(params);
+      }).strict().parse(params2);
       return service.createInvite(room_id, input);
     } },
-    "room.participant.remove": { auth: true, run: (params) => {
-      const { room_id, ...input } = ParticipantRemoveParams.parse(params);
+    "room.participant.remove": { auth: true, run: (params2) => {
+      const { room_id, ...input } = ParticipantRemoveParams.parse(params2);
       return service.removeParticipant(room_id, input);
     } },
-    "room.participant.replace": { auth: true, run: (params) => {
-      const { room_id, ...input } = ParticipantReplaceParams.parse(params);
+    "room.participant.replace": { auth: true, run: (params2) => {
+      const { room_id, ...input } = ParticipantReplaceParams.parse(params2);
       return service.replaceParticipant(room_id, input);
     } },
-    "room.revoke": { auth: true, run: (params) => {
-      const value = InviteRevokeParams.parse(params);
+    "room.revoke": { auth: true, run: (params2) => {
+      const value = InviteRevokeParams.parse(params2);
       return service.revokeInvite(value.room_id, value.invite_id);
     } },
-    "room.recover": { auth: true, run: (params) => service.recoverInvites(RoomIdParams.parse(params).room_id) },
-    "room.recover.confirm": { auth: true, run: (params) => {
-      const value = RecoverConfirmParams.parse(params);
+    "room.recover": { auth: true, run: (params2) => service.recoverInvites(RoomIdParams.parse(params2).room_id) },
+    "room.recover.confirm": { auth: true, run: (params2) => {
+      const value = RecoverConfirmParams.parse(params2);
       return service.confirmRecoveredInvite(value.room_id, value.recovery_of, value.invite_id);
     } },
-    "room.list": { auth: true, run: (params) => {
-      external_exports.object({}).strict().parse(params);
+    "room.list": { auth: true, run: (params2) => {
+      external_exports.object({}).strict().parse(params2);
       return service.listRooms();
     } },
-    "room.show": { auth: true, run: (params) => service.showRoom(RoomIdParams.parse(params).room_id) },
-    "room.participants": { auth: true, run: (params) => service.participants(RoomIdParams.parse(params).room_id) },
-    "room.history": { auth: true, run: (params) => {
-      const { room_id, ...options } = HistoryParams.parse(params);
+    "room.show": { auth: true, run: (params2) => service.showRoom(RoomIdParams.parse(params2).room_id) },
+    "room.participants": { auth: true, run: (params2) => service.participants(RoomIdParams.parse(params2).room_id) },
+    "room.history": { auth: true, run: (params2) => {
+      const { room_id, ...options } = HistoryParams.parse(params2);
       return service.history(room_id, options);
     } },
-    "room.message": { auth: true, run: (params) => {
-      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), text: external_exports.unknown() }).strict().parse(params);
+    "room.message": { auth: true, run: (params2) => {
+      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), text: external_exports.unknown() }).strict().parse(params2);
       return service.postMessage(room_id, input);
     } },
-    "room.close": { auth: true, run: (params) => service.closeRoom(RoomIdParams.parse(params).room_id) },
-    "room.delete": { auth: true, run: (params) => {
-      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), confirm: external_exports.unknown() }).strict().parse(params);
+    "room.close": { auth: true, run: (params2) => service.closeRoom(RoomIdParams.parse(params2).room_id) },
+    "room.delete": { auth: true, run: (params2) => {
+      const { room_id, ...input } = external_exports.object({ room_id: external_exports.string(), confirm: external_exports.unknown() }).strict().parse(params2);
       return service.deleteRoom(room_id, input);
     } }
   };
 }
 function createPrivateServiceRoutes(service) {
   return {
-    "room.accept": { auth: true, run: (params) => {
-      const { room_id, ...input } = ExternalInviteAcceptParams.parse(params);
+    "room.accept": { auth: true, run: (params2) => {
+      const { room_id, ...input } = ExternalInviteAcceptParams.parse(params2);
       return service.acceptExternalInvite(room_id, input);
     } }
   };
@@ -8867,6 +9577,23 @@ function isJsonMediaType(value) {
   const mediaType = value.split(";", 1)[0]?.trim().toLowerCase();
   return mediaType === "application/json" || mediaType?.startsWith("application/") === true && mediaType.endsWith("+json");
 }
+async function serveApiDocs(request, response) {
+  const pathname = safePathname(request.url);
+  if (pathname === void 0) return false;
+  const asset = apiDocsAsset(pathname);
+  if (!asset) return false;
+  const body = Buffer.from(asset.body, "utf8");
+  response.writeHead(200, {
+    "content-type": asset.contentType,
+    "content-length": body.length,
+    "cache-control": "no-cache",
+    "content-security-policy": CONTENT_SECURITY_POLICY,
+    "x-content-type-options": "nosniff"
+  });
+  response.end(body);
+  await responseFinished2(response);
+  return true;
+}
 function sendJson(response, status, value) {
   const body = Buffer.from(JSON.stringify(value), "utf8");
   response.writeHead(status, {
@@ -8984,6 +9711,7 @@ var init_transports = __esm({
   "src/transports.ts"() {
     "use strict";
     init_zod();
+    init_openapi();
     init_web();
     MAX_REQUEST_BYTES = 1024 * 1024;
     HTTP_HEADERS_TIMEOUT_MS = 5e3;
@@ -9250,6 +9978,7 @@ var init_transports = __esm({
           if (request.url !== "/rpc") {
             if (request.method === "GET") {
               activateResponse();
+              if (await serveApiDocs(request, response)) return;
               if (await this.staticHandler(request, response)) return;
             }
             activateResponse();
@@ -9514,16 +10243,16 @@ function isIntakeNotification(event) {
 }
 function createDaemonControlRoutes(control) {
   if (!/^[0-9a-f]{32}$/.test(control.session)) throw new TypeError("invalid daemon control session");
-  const requireExact = (params, keys) => {
-    if (Object.keys(params).length !== keys.length || keys.some((key) => !Object.hasOwn(params, key))) {
+  const requireExact = (params2, keys) => {
+    if (Object.keys(params2).length !== keys.length || keys.some((key) => !Object.hasOwn(params2, key))) {
       throw new TypeError("invalid daemon control parameters");
     }
   };
   return {
     "daemon.status": {
       auth: true,
-      run(params) {
-        requireExact(params, []);
+      run(params2) {
+        requireExact(params2, []);
         return {
           version: 1,
           protocol: "cowork-supervisor-control",
@@ -9534,9 +10263,9 @@ function createDaemonControlRoutes(control) {
     },
     "daemon.shutdown": {
       auth: true,
-      async run(params) {
-        requireExact(params, ["session"]);
-        if (params.session !== control.session) throw new TypeError("daemon control session changed");
+      async run(params2) {
+        requireExact(params2, ["session"]);
+        if (params2.session !== control.session) throw new TypeError("daemon control session changed");
         if (!await control.requestSupervisorShutdown()) throw new Error("supervisor IPC rejected shutdown request");
         return { accepted: true, session: control.session };
       }