@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/generated/internal.js

@@ -0,0 +1,2627 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/@asteasolutions+zod-to-openapi@9.1.0_zod@4.6.5/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/.pnpm/@asteasolutions+zod-to-openapi@9.1.0_zod@4.6.5/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs"(exports) {
+    "use strict";
+    function __rest(s, e) {
+      var t = {};
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+      if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+            t[p[i]] = s[p[i]];
+        }
+      return t;
+    }
+    var ZodTypeKeys = {
+      ZodAny: "any",
+      ZodArray: "array",
+      ZodBigInt: "bigint",
+      ZodBoolean: "boolean",
+      ZodDefault: "default",
+      ZodPrefault: "prefault",
+      ZodTransform: "transform",
+      ZodEnum: "enum",
+      ZodIntersection: "intersection",
+      ZodLazy: "lazy",
+      ZodLiteral: "literal",
+      ZodNever: "never",
+      ZodNull: "null",
+      ZodNullable: "nullable",
+      ZodNumber: "number",
+      ZodNonOptional: "nonoptional",
+      ZodObject: "object",
+      ZodOptional: "optional",
+      ZodPipe: "pipe",
+      ZodReadonly: "readonly",
+      ZodRecord: "record",
+      ZodString: "string",
+      ZodTuple: "tuple",
+      ZodType: "type",
+      ZodUnion: "union",
+      ZodDiscriminatedUnion: "union",
+      ZodUnknown: "unknown",
+      ZodVoid: "void",
+      ZodDate: "date",
+      ZodTemplateLiteral: "template_literal"
+    };
+    function isZodType(schema, typeNames) {
+      const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
+      return typeNamesArray.some((typeName) => {
+        var _a;
+        const typeNameMatch = ((_a = schema === null || schema === void 0 ? void 0 : schema.def) === null || _a === void 0 ? void 0 : _a.type) === ZodTypeKeys[typeName];
+        if (typeName === "ZodDiscriminatedUnion") {
+          return typeNameMatch && "discriminator" in schema.def;
+        }
+        return typeNameMatch;
+      });
+    }
+    function isAnyZodType(schema) {
+      return schema && "def" in schema;
+    }
+    function isNullableSchema(schema) {
+      return schema.safeParse(null).success;
+    }
+    function isOptionalSchema(schema) {
+      return schema.safeParse(void 0).success;
+    }
+    var $ZodRegistry = class {
+      constructor() {
+        this._map = /* @__PURE__ */ new Map();
+        this._idmap = /* @__PURE__ */ new Map();
+      }
+      add(schema, ..._meta) {
+        const meta = _meta[0];
+        this._map.set(schema, meta);
+        if (meta && typeof meta === "object" && "id" in meta) {
+          if (this._idmap.has(meta.id)) {
+            throw new Error(`ID ${meta.id} already exists in the registry`);
+          }
+          this._idmap.set(meta.id, schema);
+        }
+        return this;
+      }
+      clear() {
+        this._map = /* @__PURE__ */ new Map();
+        this._idmap = /* @__PURE__ */ new Map();
+        return this;
+      }
+      remove(schema) {
+        const meta = this._map.get(schema);
+        if (meta && typeof meta === "object" && "id" in meta) {
+          this._idmap.delete(meta.id);
+        }
+        this._map.delete(schema);
+        return this;
+      }
+      get(schema) {
+        const p = schema._zod.parent;
+        if (p) {
+          const pm = { ...this.get(p) ?? {} };
+          delete pm.id;
+          return { ...pm, ...this._map.get(schema) };
+        }
+        return this._map.get(schema);
+      }
+      has(schema) {
+        return this._map.has(schema);
+      }
+    };
+    function registry() {
+      return new $ZodRegistry();
+    }
+    function isEqual(x, y) {
+      if (x === null || x === void 0 || y === null || y === void 0) {
+        return x === y;
+      }
+      if (x === y || x.valueOf() === y.valueOf()) {
+        return true;
+      }
+      if (Array.isArray(x)) {
+        if (!Array.isArray(y)) {
+          return false;
+        }
+        if (x.length !== y.length) {
+          return false;
+        }
+      }
+      if (!(x instanceof Object) || !(y instanceof Object)) {
+        return false;
+      }
+      const keysX = Object.keys(x);
+      return Object.keys(y).every((keyY) => keysX.indexOf(keyY) !== -1) && keysX.every((key) => isEqual(x[key], y[key]));
+    }
+    var ObjectSet = class {
+      constructor() {
+        this.buckets = /* @__PURE__ */ new Map();
+      }
+      put(value) {
+        const hashCode = this.hashCodeOf(value);
+        const itemsByCode = this.buckets.get(hashCode);
+        if (!itemsByCode) {
+          this.buckets.set(hashCode, [value]);
+          return;
+        }
+        const alreadyHasItem = itemsByCode.some((_) => isEqual(_, value));
+        if (!alreadyHasItem) {
+          itemsByCode.push(value);
+        }
+      }
+      contains(value) {
+        const hashCode = this.hashCodeOf(value);
+        const itemsByCode = this.buckets.get(hashCode);
+        if (!itemsByCode) {
+          return false;
+        }
+        return itemsByCode.some((_) => isEqual(_, value));
+      }
+      values() {
+        return [...this.buckets.values()].flat();
+      }
+      stats() {
+        let totalBuckets = 0;
+        let totalValues = 0;
+        let collisions = 0;
+        for (const bucket of this.buckets.values()) {
+          totalBuckets += 1;
+          totalValues += bucket.length;
+          if (bucket.length > 1) {
+            collisions += 1;
+          }
+        }
+        const hashEffectiveness = totalBuckets / totalValues;
+        return { totalBuckets, collisions, totalValues, hashEffectiveness };
+      }
+      hashCodeOf(object2) {
+        let hashCode = 0;
+        if (Array.isArray(object2)) {
+          for (let i = 0; i < object2.length; i++) {
+            hashCode ^= this.hashCodeOf(object2[i]) * i;
+          }
+          return hashCode;
+        }
+        if (typeof object2 === "string") {
+          for (let i = 0; i < object2.length; i++) {
+            hashCode ^= object2.charCodeAt(i) * i;
+          }
+          return hashCode;
+        }
+        if (typeof object2 === "number") {
+          return object2;
+        }
+        if (typeof object2 === "object") {
+          for (const [key, value] of Object.entries(object2)) {
+            hashCode ^= this.hashCodeOf(key) + this.hashCodeOf(value !== null && value !== void 0 ? value : "");
+          }
+        }
+        return hashCode;
+      }
+    };
+    function isUndefined(value) {
+      return value === void 0;
+    }
+    function mapValues(object2, mapper) {
+      const result = {};
+      Object.entries(object2).forEach(([key, value]) => {
+        result[key] = mapper(value);
+      });
+      return result;
+    }
+    function omit(object2, keys) {
+      const result = {};
+      Object.entries(object2).forEach(([key, value]) => {
+        if (!keys.some((keyToOmit) => keyToOmit === key)) {
+          result[key] = value;
+        }
+      });
+      return result;
+    }
+    function omitBy(object2, predicate) {
+      const result = {};
+      Object.entries(object2).forEach(([key, value]) => {
+        if (!predicate(value, key)) {
+          result[key] = value;
+        }
+      });
+      return result;
+    }
+    function compact(arr) {
+      return arr.filter((elem) => !isUndefined(elem));
+    }
+    var objectEquals = isEqual;
+    function uniq(values) {
+      const set = new ObjectSet();
+      values.forEach((value) => set.put(value));
+      return [...set.values()];
+    }
+    function isString(val) {
+      return typeof val === "string";
+    }
+    function sortObjectByKeys(obj) {
+      return Object.fromEntries(Object.entries(obj).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)));
+    }
+    var zodToOpenAPIRegistry = registry();
+    var Metadata = class {
+      static collectMetadata(schema, metadata2) {
+        const currentMetadata = this.getMetadataFromRegistry(schema);
+        const _internal = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata._internal), metadata2 === null || metadata2 === void 0 ? void 0 : metadata2._internal);
+        const param = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.param);
+        const totalMetadata = Object.assign(Object.assign(Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : {}), currentMetadata), metadata2), Object.keys(param).length > 0 ? { param } : {});
+        if (isZodType(schema, [
+          "ZodOptional",
+          "ZodNullable",
+          "ZodDefault",
+          "ZodPrefault",
+          "ZodReadonly",
+          "ZodNonOptional"
+        ]) && isAnyZodType(schema._zod.def.innerType)) {
+          return this.collectMetadata(schema._zod.def.innerType, totalMetadata);
+        }
+        if (isZodType(schema, "ZodPipe")) {
+          const inSchema = schema._zod.def.in;
+          const outSchema = schema._zod.def.out;
+          if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) {
+            return this.collectMetadata(outSchema, totalMetadata);
+          }
+          if (isAnyZodType(inSchema)) {
+            return this.collectMetadata(inSchema, totalMetadata);
+          }
+        }
+        return totalMetadata;
+      }
+      /**
+       * @deprecated Use one of `getOpenApiMetadata` or `getInternalMetadata` instead
+       */
+      static getMetadata(zodSchema) {
+        return this.collectMetadata(zodSchema);
+      }
+      static getOpenApiMetadata(zodSchema) {
+        const metadata2 = this.collectMetadata(zodSchema);
+        const _a = metadata2 !== null && metadata2 !== void 0 ? metadata2 : {}, { _internal } = _a, rest = __rest(_a, ["_internal"]);
+        return rest;
+      }
+      static getInternalMetadata(zodSchema) {
+        var _a;
+        return (_a = this.collectMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a._internal;
+      }
+      static getParamMetadata(zodSchema) {
+        const metadata2 = this.collectMetadata(zodSchema);
+        return Object.assign(Object.assign({}, metadata2), {
+          // A description provided from .openapi() should be taken with higher precedence
+          param: Object.assign(Object.assign({}, (metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.description) ? { description: metadata2.description } : {}), metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.param)
+        });
+      }
+      /**
+       * A method that omits all custom keys added to the regular OpenAPI
+       * metadata properties
+       */
+      static buildSchemaMetadata(metadata2) {
+        return omitBy(omit(metadata2, ["param", "_internal"]), isUndefined);
+      }
+      static buildParameterMetadata(metadata2) {
+        return omitBy(metadata2, isUndefined);
+      }
+      static applySchemaMetadata(initialData, metadata2) {
+        return omitBy(Object.assign(Object.assign({}, initialData), this.buildSchemaMetadata(metadata2)), isUndefined);
+      }
+      static getRefId(zodSchema) {
+        var _a;
+        return (_a = this.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.refId;
+      }
+      static unwrapChained(schema) {
+        return this.unwrapUntil(schema);
+      }
+      static getDefaultValue(zodSchema) {
+        var _a;
+        const unwrapped = (_a = this.unwrapUntil(zodSchema, "ZodDefault")) !== null && _a !== void 0 ? _a : this.unwrapUntil(zodSchema, "ZodPrefault");
+        return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._zod.def.defaultValue;
+      }
+      static unwrapUntil(schema, typeName) {
+        if (typeName && isZodType(schema, typeName)) {
+          return schema;
+        }
+        if (isZodType(schema, [
+          "ZodOptional",
+          "ZodNullable",
+          "ZodDefault",
+          "ZodPrefault",
+          "ZodReadonly",
+          "ZodNonOptional"
+        ]) && isAnyZodType(schema._zod.def.innerType)) {
+          return this.unwrapUntil(schema._zod.def.innerType, typeName);
+        }
+        if (isZodType(schema, "ZodPipe")) {
+          const inSchema = schema._zod.def.in;
+          const outSchema = schema._zod.def.out;
+          if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) {
+            return this.unwrapUntil(outSchema, typeName);
+          }
+          if (isAnyZodType(inSchema)) {
+            return this.unwrapUntil(inSchema, typeName);
+          }
+        }
+        return typeName ? void 0 : schema;
+      }
+      static getMetadataFromInternalRegistry(zodSchema) {
+        return zodToOpenAPIRegistry.get(zodSchema);
+      }
+      static getMetadataFromRegistry(zodSchema) {
+        const internal = this.getMetadataFromInternalRegistry(zodSchema);
+        const general = zodSchema.meta();
+        if (!internal) {
+          return general;
+        }
+        const { _internal } = internal, rest = __rest(internal, ["_internal"]);
+        const _a = general !== null && general !== void 0 ? general : {}, { id, title } = _a, restGeneral = __rest(_a, ["id", "title"]);
+        return Object.assign(Object.assign(Object.assign({ _internal: Object.assign(Object.assign({}, id ? { refId: id } : {}), _internal) }, rest), title ? { description: title } : {}), restGeneral);
+      }
+      static setMetadataInRegistry(zodSchema, metadata2) {
+        zodToOpenAPIRegistry.add(zodSchema, metadata2);
+      }
+    };
+    function preserveMetadataFromModifier(zodSchema, modifier) {
+      const zodModifier = zodSchema[modifier];
+      if (typeof zodModifier !== "function") {
+        return;
+      }
+      zodSchema[modifier] = function(...args) {
+        const result = zodModifier.apply(this, args);
+        const meta = Metadata.getMetadataFromRegistry(this);
+        if (meta) {
+          Metadata.setMetadataInRegistry(result, meta);
+        }
+        return result;
+      };
+    }
+    function extendZodWithOpenApi2(zod) {
+      if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+        return;
+      }
+      zod.ZodType.prototype.openapi = function(...args) {
+        const { refId, metadata: metadata2, options } = getOpenApiConfiguration(...args);
+        const _a = metadata2 !== null && metadata2 !== void 0 ? metadata2 : {}, { param } = _a, restOfOpenApi = __rest(_a, ["param"]);
+        const allMetadata = Metadata.getMetadataFromRegistry(this);
+        const _b = allMetadata !== null && allMetadata !== void 0 ? allMetadata : {}, { _internal: internalMetadata } = _b, currentMetadata = __rest(_b, ["_internal"]);
+        const _internal = Object.assign(Object.assign(Object.assign({}, internalMetadata), options), refId ? { refId } : void 0);
+        const resultMetadata = Object.assign(Object.assign(Object.assign({}, currentMetadata), restOfOpenApi), (currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) || param ? {
+          param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), param)
+        } : void 0);
+        const result = new this.constructor(this._def);
+        function setMetadata(schema) {
+          Metadata.setMetadataInRegistry(schema, Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : void 0), resultMetadata));
+        }
+        setMetadata(result);
+        if (isZodType(result, "ZodLazy")) {
+          setMetadata(this);
+        }
+        if (isZodType(result, "ZodObject")) {
+          const currentMetadata2 = Metadata.getMetadataFromRegistry(result);
+          const originalExtend = result.extend;
+          result.extend = function(...args2) {
+            const extendedResult = originalExtend.apply(result, args2);
+            const _a2 = currentMetadata2 !== null && currentMetadata2 !== void 0 ? currentMetadata2 : {}, { _internal: _internal2 } = _a2, rest = __rest(_a2, ["_internal"]);
+            Metadata.setMetadataInRegistry(extendedResult, {
+              _internal: {
+                extendedFrom: (_internal2 === null || _internal2 === void 0 ? void 0 : _internal2.refId) ? { refId: _internal2.refId, schema: result } : _internal2 === null || _internal2 === void 0 ? void 0 : _internal2.extendedFrom
+              }
+            });
+            return extendedResult.openapi(rest);
+          };
+          preserveMetadataFromModifier(result, "catchall");
+        }
+        preserveMetadataFromModifier(result, "optional");
+        preserveMetadataFromModifier(result, "nullable");
+        preserveMetadataFromModifier(result, "default");
+        preserveMetadataFromModifier(result, "transform");
+        preserveMetadataFromModifier(result, "refine");
+        preserveMetadataFromModifier(result, "length");
+        preserveMetadataFromModifier(result, "min");
+        preserveMetadataFromModifier(result, "max");
+        const originalMeta = result.meta;
+        result.meta = function(...args2) {
+          const result2 = originalMeta.apply(this, args2);
+          if (args2[0]) {
+            const meta = Metadata.getMetadataFromInternalRegistry(this);
+            if (meta) {
+              Metadata.setMetadataInRegistry(result2, Object.assign(Object.assign({}, meta), args2[0]));
+            }
+          }
+          return result2;
+        };
+        return result;
+      };
+    }
+    function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
+      if (typeof refOrOpenapi === "string") {
+        return {
+          refId: refOrOpenapi,
+          metadata: metadataOrOptions,
+          options
+        };
+      }
+      return {
+        refId: void 0,
+        metadata: refOrOpenapi,
+        options: metadataOrOptions
+      };
+    }
+    function getOpenApiMetadata2(zodSchema) {
+      var _a;
+      return omitBy((_a = Metadata.getOpenApiMetadata(zodSchema)) !== null && _a !== void 0 ? _a : {}, isUndefined);
+    }
+    function getRefId(zodSchema) {
+      return Metadata.getRefId(zodSchema);
+    }
+    var OpenAPIRegistry2 = class {
+      constructor(parents) {
+        this.parents = parents;
+        this._definitions = [];
+      }
+      get definitions() {
+        var _a, _b;
+        const parentDefinitions = (_b = (_a = this.parents) === null || _a === void 0 ? void 0 : _a.flatMap((par) => par._definitions)) !== null && _b !== void 0 ? _b : [];
+        return [...parentDefinitions, ...this._definitions];
+      }
+      /**
+       * Registers a new component schema under /components/schemas/${name}
+       */
+      register(refId, zodSchema) {
+        const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);
+        this._definitions.push({ type: "schema", schema: schemaWithRefId });
+        return schemaWithRefId;
+      }
+      /**
+       * Registers a new parameter schema under /components/parameters/${name}
+       */
+      registerParameter(refId, zodSchema) {
+        var _a, _b, _c;
+        const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);
+        const currentMetadata = (_a = Metadata.getOpenApiMetadata(schemaWithRefId)) !== null && _a !== void 0 ? _a : {};
+        const schemaWithMetadata = schemaWithRefId.openapi(Object.assign(Object.assign({}, currentMetadata), { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), { name: (_c = (_b = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : refId }) }));
+        this._definitions.push({
+          type: "parameter",
+          schema: schemaWithMetadata
+        });
+        return schemaWithMetadata;
+      }
+      /**
+       * Registers a new path that would be generated under paths:
+       */
+      registerPath(route) {
+        this._definitions.push({
+          type: "route",
+          route
+        });
+      }
+      /**
+       * Registers a new webhook that would be generated under webhooks:
+       */
+      registerWebhook(webhook) {
+        this._definitions.push({
+          type: "webhook",
+          webhook
+        });
+      }
+      /**
+       * Registers a raw OpenAPI component. Use this if you have a simple object instead of a Zod schema.
+       *
+       * @param type The component type, e.g. `schemas`, `responses`, `securitySchemes`, etc.
+       * @param name The name of the object, it is the key under the component
+       *             type in the resulting OpenAPI document
+       * @param component The actual object to put there
+       */
+      registerComponent(type, name, component) {
+        this._definitions.push({
+          type: "component",
+          componentType: type,
+          name,
+          component
+        });
+        return {
+          name,
+          ref: { $ref: `#/components/${type}/${name}` }
+        };
+      }
+      schemaWithRefId(refId, zodSchema) {
+        return zodSchema.openapi(refId);
+      }
+    };
+    var ZodToOpenAPIError = class {
+      constructor(message) {
+        this.message = message;
+      }
+    };
+    var ConflictError = class extends ZodToOpenAPIError {
+      constructor(message, data) {
+        super(message);
+        this.data = data;
+      }
+    };
+    var MissingParameterDataError = class extends ZodToOpenAPIError {
+      constructor(data) {
+        super(`Missing parameter data, please specify \`${data.missingField}\` and other OpenAPI parameter props using the \`param\` field of \`schema.openapi\``);
+        this.data = data;
+      }
+    };
+    function enhanceMissingParametersError(action, paramsToAdd) {
+      try {
+        return action();
+      } catch (error2) {
+        if (error2 instanceof MissingParameterDataError) {
+          throw new MissingParameterDataError(Object.assign(Object.assign({}, error2.data), paramsToAdd));
+        }
+        throw error2;
+      }
+    }
+    var UnknownZodTypeError = class extends ZodToOpenAPIError {
+      constructor(data) {
+        super(`Unknown zod object type, please specify \`type\` and other OpenAPI props using \`schema.openapi\`.`);
+        this.data = data;
+      }
+    };
+    var ArrayTransformer = class {
+      transform(zodSchema, mapNullableType, mapItems) {
+        var _a, _b, _c, _d;
+        const itemType = zodSchema.def.element;
+        const minItems = (_b = (_a = zodSchema.def.checks) === null || _a === void 0 ? void 0 : _a.find((check) => check._zod.def.check === "min_length")) === null || _b === void 0 ? void 0 : _b._zod.def.minimum;
+        const maxItems = (_d = (_c = zodSchema.def.checks) === null || _c === void 0 ? void 0 : _c.find((check) => check._zod.def.check === "max_length")) === null || _d === void 0 ? void 0 : _d._zod.def.maximum;
+        return Object.assign(Object.assign({}, mapNullableType("array")), {
+          items: isAnyZodType(itemType) ? mapItems(itemType) : {},
+          minItems,
+          maxItems
+        });
+      }
+    };
+    var BigIntTransformer = class {
+      transform(mapNullableType) {
+        return Object.assign(Object.assign({}, mapNullableType("string")), { pattern: `^\\d+$` });
+      }
+    };
+    var DiscriminatedUnionTransformer = class {
+      transform(zodSchema, isNullable, mapNullableOfArray, mapItem, generateSchemaRef) {
+        const options = zodSchema.def.options.filter(isAnyZodType);
+        const optionSchema = options.map(mapItem);
+        if (isNullable) {
+          return {
+            oneOf: mapNullableOfArray(optionSchema, isNullable)
+          };
+        }
+        const discriminator = zodSchema._zod.def.discriminator;
+        if (!discriminator) {
+          return {
+            oneOf: optionSchema
+          };
+        }
+        return {
+          oneOf: optionSchema,
+          discriminator: this.mapDiscriminator(options, discriminator, generateSchemaRef)
+        };
+      }
+      mapDiscriminator(schemas, discriminator, generateSchemaRef) {
+        if (schemas.some((schema) => Metadata.getRefId(schema) === void 0)) {
+          return void 0;
+        }
+        const mapping = {};
+        for (const schema of schemas) {
+          const refId = Metadata.getRefId(schema);
+          const values = this.getDiscriminatorValues(schema, discriminator);
+          for (const value of values) {
+            mapping[value] = generateSchemaRef(refId);
+          }
+        }
+        return {
+          propertyName: discriminator,
+          mapping
+        };
+      }
+      getDiscriminatorValues(schema, discriminator) {
+        var _a;
+        if (isZodType(schema, "ZodObject")) {
+          const value = (_a = schema.def.shape) === null || _a === void 0 ? void 0 : _a[discriminator];
+          if (!value) {
+            return [];
+          }
+          if (isZodType(value, "ZodEnum")) {
+            return Object.values(value._zod.def.entries).filter(isString);
+          }
+          if (isZodType(value, "ZodLiteral")) {
+            return value.def.values.filter(isString);
+          }
+          return [];
+        }
+        if (isZodType(schema, "ZodDiscriminatedUnion")) {
+          const nestedOptions = schema.def.options.filter(isAnyZodType);
+          return [
+            ...new Set(nestedOptions.flatMap((option) => this.getDiscriminatorValues(option, discriminator)))
+          ];
+        }
+        return [];
+      }
+    };
+    function enumInfo(enumObject) {
+      const keysExceptReverseMappings = Object.keys(enumObject).filter((key) => typeof enumObject[enumObject[key]] !== "number");
+      const values = keysExceptReverseMappings.map((key) => enumObject[key]);
+      const numericCount = values.filter((_) => typeof _ === "number").length;
+      const type = numericCount === 0 ? "string" : numericCount === values.length ? "numeric" : "mixed";
+      return { values, type };
+    }
+    var EnumTransformer = class {
+      transform(zodSchema, isNullable, mapNullableType) {
+        const { type, values } = enumInfo(zodSchema._zod.def.entries);
+        if (type === "mixed") {
+          throw new ZodToOpenAPIError("Enum has mixed string and number values, please specify the OpenAPI type manually");
+        }
+        return Object.assign(Object.assign({}, mapNullableType(type === "numeric" ? "integer" : "string")), { enum: isNullable ? [...values, null] : values });
+      }
+    };
+    var IntersectionTransformer = class {
+      transform(zodSchema, isNullable, mapNullableOfArray, mapItem) {
+        const subtypes = this.flattenIntersectionTypes(zodSchema);
+        const allOfSchema = {
+          allOf: subtypes.map(mapItem)
+        };
+        if (isNullable) {
+          return {
+            anyOf: mapNullableOfArray([allOfSchema], isNullable)
+          };
+        }
+        return allOfSchema;
+      }
+      flattenIntersectionTypes(schema) {
+        if (!isZodType(schema, "ZodIntersection")) {
+          return [schema];
+        }
+        const leftSubTypes = isAnyZodType(schema._zod.def.left) ? this.flattenIntersectionTypes(schema._zod.def.left) : [];
+        const rightSubTypes = isAnyZodType(schema._zod.def.right) ? this.flattenIntersectionTypes(schema._zod.def.right) : [];
+        return [...leftSubTypes, ...rightSubTypes];
+      }
+    };
+    var LiteralTransformer = class {
+      constructor() {
+        this.bigIntTransformer = new BigIntTransformer();
+      }
+      transform(zodSchema, mapNullableType) {
+        const type = typeof zodSchema.def.values[0];
+        if (type === "boolean" || type === "number" || type === "string" || type === "object") {
+          return Object.assign(Object.assign({}, mapNullableType(type)), { enum: [zodSchema.def.values[0]] });
+        }
+        if (type === "bigint") {
+          return this.bigIntTransformer.transform(mapNullableType);
+        }
+        return mapNullableType("null");
+      }
+    };
+    var NumberTransformer = class {
+      transform(zodSchema, mapNullableType, getNumberChecks) {
+        var _a;
+        return Object.assign(Object.assign(Object.assign({}, mapNullableType("number")), mapNullableType(zodSchema.format === "safeint" ? "integer" : "number")), getNumberChecks((_a = zodSchema.def.checks) !== null && _a !== void 0 ? _a : []));
+      }
+    };
+    var ObjectTransformer = class {
+      transform(zodSchema, defaultValue, mapNullableType, mapItem) {
+        var _a;
+        const extendedFrom = (_a = Metadata.getInternalMetadata(zodSchema)) === null || _a === void 0 ? void 0 : _a.extendedFrom;
+        const required = this.requiredKeysOf(zodSchema);
+        const properties = mapValues(zodSchema.def.shape, mapItem);
+        if (!extendedFrom) {
+          return Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType("object")), { properties, default: defaultValue }), required.length > 0 ? { required } : {}), this.generateAdditionalProperties(zodSchema, mapItem));
+        }
+        const parent = extendedFrom.schema;
+        mapItem(parent);
+        const keysRequiredByParent = this.requiredKeysOf(parent);
+        const propsOfParent = mapValues(parent === null || parent === void 0 ? void 0 : parent.def.shape, mapItem);
+        const propertiesToAdd = Object.fromEntries(Object.entries(properties).filter(([key, type]) => {
+          return !objectEquals(propsOfParent[key], type);
+        }));
+        const additionallyRequired = required.filter((prop) => !keysRequiredByParent.includes(prop));
+        const objectData = Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType("object")), { default: defaultValue, properties: propertiesToAdd }), additionallyRequired.length > 0 ? { required: additionallyRequired } : {}), this.generateAdditionalProperties(zodSchema, mapItem));
+        return {
+          allOf: [
+            { $ref: `#/components/schemas/${extendedFrom.refId}` },
+            objectData
+          ]
+        };
+      }
+      generateAdditionalProperties(zodSchema, mapItem) {
+        const catchallSchema = zodSchema.def.catchall;
+        if (!catchallSchema) {
+          return {};
+        }
+        if (isZodType(catchallSchema, "ZodNever")) {
+          return { additionalProperties: false };
+        }
+        if (isAnyZodType(catchallSchema)) {
+          return { additionalProperties: mapItem(catchallSchema) };
+        }
+        return {};
+      }
+      requiredKeysOf(objectSchema) {
+        return Object.entries(objectSchema.def.shape).filter(([_key, type]) => !isOptionalSchema(type)).map(([key, _type]) => key);
+      }
+    };
+    var RecordTransformer = class {
+      transform(zodSchema, mapNullableType, mapItem) {
+        const propertiesType = zodSchema.valueType;
+        const keyType = zodSchema.keyType;
+        const propertiesSchema = isAnyZodType(propertiesType) ? mapItem(propertiesType) : {};
+        if (isZodType(keyType, "ZodEnum")) {
+          const keys = Object.values(keyType._zod.def.entries).filter(isString);
+          const properties = keys.reduce((acc, curr) => Object.assign(Object.assign({}, acc), { [curr]: propertiesSchema }), {});
+          return Object.assign(Object.assign({}, mapNullableType("object")), { properties });
+        }
+        return Object.assign(Object.assign({}, mapNullableType("object")), { additionalProperties: propertiesSchema });
+      }
+    };
+    function isZodCheckLengthEquals(check) {
+      return check._zod.def.check === "length_equals";
+    }
+    function isZodCheckRegex(check) {
+      return check._zod.def.check === "string_format" && check._zod.def.format === "regex";
+    }
+    var StringTransformer = class {
+      transform(zodSchema, mapNullableType) {
+        var _a, _b, _c, _d;
+        const regexCheck = (_a = zodSchema.def.checks) === null || _a === void 0 ? void 0 : _a.find(isZodCheckRegex);
+        const pattern = regexCheck === null || regexCheck === void 0 ? void 0 : regexCheck._zod.def.pattern.toString().replace(/^\/|\/$/g, "");
+        const check = (_b = zodSchema.def.checks) === null || _b === void 0 ? void 0 : _b.find(isZodCheckLengthEquals);
+        const length = check === null || check === void 0 ? void 0 : check._zod.def.length;
+        const maxLength = Number.isFinite(zodSchema.minLength) ? (_c = zodSchema.minLength) !== null && _c !== void 0 ? _c : void 0 : void 0;
+        const minLength = Number.isFinite(zodSchema.maxLength) ? (_d = zodSchema.maxLength) !== null && _d !== void 0 ? _d : void 0 : void 0;
+        return Object.assign(Object.assign({}, mapNullableType("string")), {
+          // FIXME: https://github.com/colinhacks/zod/commit/d78047e9f44596a96d637abb0ce209cd2732d88c
+          minLength: length !== null && length !== void 0 ? length : maxLength,
+          maxLength: length !== null && length !== void 0 ? length : minLength,
+          format: this.mapStringFormat(zodSchema),
+          pattern
+        });
+      }
+      /**
+       * Attempts to map Zod strings to known formats
+       * https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+       * New mappings should use values from the OpenAPI format registry:
+       * https://spec.openapis.org/registry/format/
+       */
+      mapStringFormat(zodString) {
+        if (zodString.format === "uuid")
+          return "uuid";
+        if (zodString.format === "guid")
+          return "uuid";
+        if (zodString.format === "email")
+          return "email";
+        if (zodString.format === "url")
+          return "uri";
+        if (zodString.format === "date")
+          return "date";
+        if (zodString.format === "datetime")
+          return "date-time";
+        if (zodString.format === "time")
+          return "time";
+        if (zodString.format === "duration")
+          return "duration";
+        if (zodString.format === "cuid")
+          return "cuid";
+        if (zodString.format === "cuid2")
+          return "cuid2";
+        if (zodString.format === "ulid")
+          return "ulid";
+        if (zodString.format === "ipv4")
+          return "ip";
+        if (zodString.format === "ipv6")
+          return "ip";
+        if (zodString.format === "cidrv4")
+          return "ipv4-cidr";
+        if (zodString.format === "cidrv6")
+          return "ipv6-cidr";
+        if (zodString.format === "base64url")
+          return "base64url";
+        if (zodString.format === "emoji")
+          return "emoji";
+        return void 0;
+      }
+    };
+    var TupleTransformer = class {
+      constructor(versionSpecifics) {
+        this.versionSpecifics = versionSpecifics;
+      }
+      transform(zodSchema, mapNullableType, mapItem) {
+        const items = zodSchema._zod.def.items;
+        const schemas = items.map((item) => isAnyZodType(item) ? mapItem(item) : {});
+        return Object.assign(Object.assign({}, mapNullableType("array")), this.versionSpecifics.mapTupleItems(schemas));
+      }
+    };
+    var UnionTransformer = class {
+      constructor(options) {
+        this.options = options;
+      }
+      transform(zodSchema, mapNullableOfArray, mapItem) {
+        var _a, _b, _c;
+        const internalMetadata = Metadata.getInternalMetadata(zodSchema);
+        const preferredType = (_c = (_a = internalMetadata === null || internalMetadata === void 0 ? void 0 : internalMetadata.unionPreferredType) !== null && _a !== void 0 ? _a : (_b = this.options) === null || _b === void 0 ? void 0 : _b.unionPreferredType) !== null && _c !== void 0 ? _c : "anyOf";
+        const options = this.flattenUnionTypes(zodSchema);
+        const schemas = options.map((schema) => {
+          const optionToGenerate = this.unwrapNullable(schema);
+          return mapItem(optionToGenerate);
+        });
+        return {
+          [preferredType]: mapNullableOfArray(schemas)
+        };
+      }
+      flattenUnionTypes(schema) {
+        if (!isZodType(schema, "ZodUnion")) {
+          return [schema];
+        }
+        const options = schema.def.options;
+        return options.flatMap((option) => isAnyZodType(option) ? this.flattenUnionTypes(option) : []);
+      }
+      unwrapNullable(schema) {
+        if (isZodType(schema, "ZodNullable")) {
+          const unwrapped = schema.unwrap();
+          if (isAnyZodType(unwrapped)) {
+            return this.unwrapNullable(unwrapped);
+          }
+        }
+        return schema;
+      }
+    };
+    var DateTransformer = class {
+      transform(mapNullableType) {
+        return Object.assign(Object.assign({}, mapNullableType("string")), { format: "date-time" });
+      }
+    };
+    var LazyTransformer = class _LazyTransformer {
+      transform(zodSchema, mapItem, mapNullableType, mapNullableRef) {
+        const result = mapItem(zodSchema._zod.def.getter());
+        return _LazyTransformer.mapRecursive(result, mapNullableType, mapNullableRef);
+      }
+      static mapRecursive(schema, mapNullableType, mapNullableRef) {
+        if ("$ref" in schema) {
+          return mapNullableRef(schema);
+        }
+        if (schema.type) {
+          return Object.assign(Object.assign({}, schema), mapNullableType(schema.type));
+        }
+        return schema;
+      }
+    };
+    var TemplateLiteralTransformer = class {
+      transform(zodSchema, mapNullableType) {
+        const parts = zodSchema.def.parts;
+        const contentPattern = parts.map((part) => this.generatePattern(part)).join("");
+        return Object.assign(Object.assign({}, mapNullableType("string")), { pattern: `^${contentPattern}$` });
+      }
+      generatePattern(part) {
+        if (typeof part === "string" || typeof part === "number" || typeof part === "boolean" || typeof part === "bigint" || part === null || part === void 0) {
+          return this.escapeRegex(String(part));
+        }
+        if (isZodType(part, "ZodLiteral")) {
+          const value = part.def.values[0];
+          return this.escapeRegex(String(value));
+        }
+        if (isZodType(part, "ZodNumber")) {
+          return "[+-]?\\d+(\\.\\d+)?";
+        }
+        if (isZodType(part, "ZodBoolean")) {
+          return "(true|false)";
+        }
+        if (isZodType(part, "ZodEnum")) {
+          const { values } = enumInfo(part.def.entries);
+          return `(${values.map((v) => this.escapeRegex(String(v))).join("|")})`;
+        }
+        return ".*";
+      }
+      escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+    };
+    var OpenApiTransformer = class {
+      constructor(versionSpecifics, options) {
+        this.versionSpecifics = versionSpecifics;
+        this.objectTransformer = new ObjectTransformer();
+        this.stringTransformer = new StringTransformer();
+        this.numberTransformer = new NumberTransformer();
+        this.bigIntTransformer = new BigIntTransformer();
+        this.dateTransformer = new DateTransformer();
+        this.lazyTransformer = new LazyTransformer();
+        this.literalTransformer = new LiteralTransformer();
+        this.templateLiteralTransformer = new TemplateLiteralTransformer();
+        this.enumTransformer = new EnumTransformer();
+        this.arrayTransformer = new ArrayTransformer();
+        this.discriminatedUnionTransformer = new DiscriminatedUnionTransformer();
+        this.intersectionTransformer = new IntersectionTransformer();
+        this.recordTransformer = new RecordTransformer();
+        this.tupleTransformer = new TupleTransformer(versionSpecifics);
+        this.unionTransformer = new UnionTransformer(options);
+      }
+      transform(zodSchema, isNullable, mapItem, generateSchemaRef, defaultValue) {
+        if (isZodType(zodSchema, "ZodNull")) {
+          return this.versionSpecifics.nullType;
+        }
+        if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
+          return this.versionSpecifics.mapNullableType(void 0, isNullable);
+        }
+        if (isZodType(zodSchema, "ZodObject")) {
+          return this.objectTransformer.transform(
+            zodSchema,
+            defaultValue,
+            // verified on TS level from input
+            // verified on TS level from input
+            (_) => this.versionSpecifics.mapNullableType(_, isNullable),
+            mapItem
+          );
+        }
+        const schema = this.transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef);
+        return Object.assign(Object.assign({}, schema), { default: defaultValue });
+      }
+      transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef) {
+        if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) {
+          return this.versionSpecifics.mapNullableType(void 0, isNullable);
+        }
+        if (isZodType(zodSchema, "ZodString")) {
+          return this.stringTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+        }
+        if (isZodType(zodSchema, "ZodNumber")) {
+          return this.numberTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (_) => this.versionSpecifics.getNumberChecks(_));
+        }
+        if (isZodType(zodSchema, "ZodBigInt")) {
+          return this.bigIntTransformer.transform((schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+        }
+        if (isZodType(zodSchema, "ZodBoolean")) {
+          return this.versionSpecifics.mapNullableType("boolean", isNullable);
+        }
+        if (isZodType(zodSchema, "ZodLazy")) {
+          return this.lazyTransformer.transform(zodSchema, mapItem, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (schema) => this.versionSpecifics.mapNullableOfRef(schema, isNullable));
+        }
+        if (isZodType(zodSchema, "ZodLiteral")) {
+          return this.literalTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+        }
+        if (isZodType(zodSchema, "ZodTemplateLiteral")) {
+          return this.templateLiteralTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+        }
+        if (isZodType(zodSchema, "ZodEnum")) {
+          return this.enumTransformer.transform(zodSchema, isNullable, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+        }
+        if (isZodType(zodSchema, "ZodArray")) {
+          return this.arrayTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+        }
+        if (isZodType(zodSchema, "ZodTuple")) {
+          return this.tupleTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+        }
+        if (isZodType(zodSchema, "ZodDiscriminatedUnion")) {
+          return this.discriminatedUnionTransformer.transform(zodSchema, isNullable, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem, generateSchemaRef);
+        }
+        if (isZodType(zodSchema, "ZodUnion")) {
+          return this.unionTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);
+        }
+        if (isZodType(zodSchema, "ZodIntersection")) {
+          return this.intersectionTransformer.transform(zodSchema, isNullable, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);
+        }
+        if (isZodType(zodSchema, "ZodRecord")) {
+          return this.recordTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+        }
+        if (isZodType(zodSchema, "ZodDate")) {
+          return this.dateTransformer.transform((_) => this.versionSpecifics.mapNullableType(_, isNullable));
+        }
+        const refId = Metadata.getRefId(zodSchema);
+        throw new UnknownZodTypeError({
+          currentSchema: zodSchema.def,
+          schemaName: refId
+        });
+      }
+    };
+    var OpenAPIGenerator = class {
+      constructor(definitions, versionSpecifics, options) {
+        this.definitions = definitions;
+        this.versionSpecifics = versionSpecifics;
+        this.options = options;
+        this.schemaRefs = {};
+        this.paramRefs = {};
+        this.pathRefs = {};
+        this.rawComponents = [];
+        this.openApiTransformer = new OpenApiTransformer(versionSpecifics, options);
+        this.sortDefinitions();
+      }
+      generateDocumentData() {
+        this.definitions.forEach((definition) => this.generateSingle(definition));
+        return {
+          components: this.buildComponents(),
+          paths: this.pathRefs
+        };
+      }
+      generateComponents() {
+        this.definitions.forEach((definition) => this.generateSingle(definition));
+        return {
+          components: this.buildComponents()
+        };
+      }
+      buildComponents() {
+        var _a, _b, _c, _d;
+        const rawComponents = {};
+        this.rawComponents.forEach(({ componentType, name, component }) => {
+          var _a2;
+          (_a2 = rawComponents[componentType]) !== null && _a2 !== void 0 ? _a2 : rawComponents[componentType] = {};
+          rawComponents[componentType][name] = component;
+        });
+        const rawSchemas = (_a = rawComponents["schemas"]) !== null && _a !== void 0 ? _a : {};
+        const allSchemas = Object.assign(Object.assign({}, rawSchemas), this.filteredSchemaRefs);
+        const schemas = ((_b = this.options) === null || _b === void 0 ? void 0 : _b.sortComponents) === "alphabetically" ? sortObjectByKeys(allSchemas) : allSchemas;
+        const rawParameters = (_c = rawComponents["parameters"]) !== null && _c !== void 0 ? _c : {};
+        const allParameters = Object.assign(Object.assign({}, rawParameters), this.paramRefs);
+        const parameters = ((_d = this.options) === null || _d === void 0 ? void 0 : _d.sortComponents) === "alphabetically" ? sortObjectByKeys(allParameters) : allParameters;
+        return Object.assign(Object.assign({}, rawComponents), { schemas, parameters });
+      }
+      isNotPendingRefEntry(entry) {
+        return entry[1] !== "pending";
+      }
+      get filteredSchemaRefs() {
+        const filtered = Object.entries(this.schemaRefs).filter(this.isNotPendingRefEntry);
+        return Object.fromEntries(filtered);
+      }
+      sortDefinitions() {
+        const generationOrder = [
+          "schema",
+          "parameter",
+          "component",
+          "route",
+          "webhook"
+        ];
+        this.definitions.sort((left, right) => {
+          if (!("type" in left)) {
+            if (!("type" in right)) {
+              return 0;
+            }
+            return -1;
+          }
+          if (!("type" in right)) {
+            return 1;
+          }
+          const leftIndex = generationOrder.findIndex((type) => type === left.type);
+          const rightIndex = generationOrder.findIndex((type) => type === right.type);
+          return leftIndex - rightIndex;
+        });
+      }
+      generateSingle(definition) {
+        if (!("type" in definition)) {
+          this.generateSchemaWithRef(definition);
+          return;
+        }
+        switch (definition.type) {
+          case "parameter":
+            this.generateParameterDefinition(definition.schema);
+            return;
+          case "schema":
+            this.generateSchemaWithRef(definition.schema);
+            return;
+          case "route":
+            this.generateSingleRoute(definition.route);
+            return;
+          case "component":
+            this.rawComponents.push(definition);
+            return;
+        }
+      }
+      generateParameterDefinition(zodSchema) {
+        const refId = Metadata.getRefId(zodSchema);
+        const result = this.generateParameter(zodSchema);
+        if (refId) {
+          this.paramRefs[refId] = result;
+        }
+        return result;
+      }
+      getParameterRef(schema, external) {
+        const metadata2 = Metadata.getOpenApiMetadata(schema);
+        const internalMetadata = Metadata.getInternalMetadata(schema);
+        const parameterMetadata = metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.param;
+        const existingRef = (internalMetadata === null || internalMetadata === void 0 ? void 0 : internalMetadata.refId) ? this.paramRefs[internalMetadata.refId] : void 0;
+        if (!(internalMetadata === null || internalMetadata === void 0 ? void 0 : internalMetadata.refId) || !existingRef) {
+          return void 0;
+        }
+        if (parameterMetadata && existingRef.in !== parameterMetadata.in || (external === null || external === void 0 ? void 0 : external.in) && existingRef.in !== external.in) {
+          throw new ConflictError(`Conflicting location for parameter ${existingRef.name}`, {
+            key: "in",
+            values: compact([
+              existingRef.in,
+              external === null || external === void 0 ? void 0 : external.in,
+              parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.in
+            ])
+          });
+        }
+        if (parameterMetadata && existingRef.name !== parameterMetadata.name || (external === null || external === void 0 ? void 0 : external.name) && existingRef.name !== (external === null || external === void 0 ? void 0 : external.name)) {
+          throw new ConflictError(`Conflicting names for parameter`, {
+            key: "name",
+            values: compact([
+              existingRef.name,
+              external === null || external === void 0 ? void 0 : external.name,
+              parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.name
+            ])
+          });
+        }
+        return {
+          $ref: `#/components/parameters/${internalMetadata.refId}`
+        };
+      }
+      generateInlineParameters(zodSchema, location) {
+        const metadata2 = Metadata.getOpenApiMetadata(zodSchema);
+        const parameterMetadata = metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.param;
+        const referencedSchema = this.getParameterRef(zodSchema, { in: location });
+        if (referencedSchema) {
+          return [referencedSchema];
+        }
+        if (isZodType(zodSchema, "ZodObject")) {
+          const propTypes = zodSchema.def.shape;
+          const parameters = Object.entries(propTypes).map(([key, schema]) => {
+            var _a;
+            const innerMetadata = Metadata.getOpenApiMetadata(schema);
+            const referencedSchema2 = this.getParameterRef(schema, {
+              in: location,
+              name: key
+            });
+            if (referencedSchema2) {
+              return referencedSchema2;
+            }
+            const innerParameterMetadata = innerMetadata === null || innerMetadata === void 0 ? void 0 : innerMetadata.param;
+            if ((innerParameterMetadata === null || innerParameterMetadata === void 0 ? void 0 : innerParameterMetadata.name) && innerParameterMetadata.name !== key) {
+              throw new ConflictError(`Conflicting names for parameter`, {
+                key: "name",
+                values: [key, innerParameterMetadata.name]
+              });
+            }
+            if ((innerParameterMetadata === null || innerParameterMetadata === void 0 ? void 0 : innerParameterMetadata.in) && innerParameterMetadata.in !== location) {
+              throw new ConflictError(`Conflicting location for parameter ${(_a = innerParameterMetadata.name) !== null && _a !== void 0 ? _a : key}`, {
+                key: "in",
+                values: [location, innerParameterMetadata.in]
+              });
+            }
+            return this.generateParameter(schema, { name: key, in: location });
+          });
+          return parameters;
+        }
+        if ((parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.in) && parameterMetadata.in !== location) {
+          throw new ConflictError(`Conflicting location for parameter ${parameterMetadata.name}`, {
+            key: "in",
+            values: [location, parameterMetadata.in]
+          });
+        }
+        return [this.generateParameter(zodSchema, { in: location })];
+      }
+      generateSimpleParameter(zodSchema, externalParamMetadata) {
+        const metadata2 = Metadata.getParamMetadata(zodSchema);
+        const paramMetadata = metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.param;
+        const mergedParamMetadata = Object.assign(Object.assign({}, paramMetadata), externalParamMetadata);
+        const required = !isOptionalSchema(zodSchema) && !isNullableSchema(zodSchema);
+        const schema = this.generateSchemaWithRef(zodSchema);
+        return Object.assign({
+          schema,
+          required
+        }, Object.keys(mergedParamMetadata).length > 0 ? Metadata.buildParameterMetadata(mergedParamMetadata) : {});
+      }
+      generateParameter(zodSchema, externalParamMetadata) {
+        var _a, _b;
+        const metadata2 = Metadata.getOpenApiMetadata(zodSchema);
+        const paramMetadata = metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.param;
+        const paramName = (_a = externalParamMetadata === null || externalParamMetadata === void 0 ? void 0 : externalParamMetadata.name) !== null && _a !== void 0 ? _a : paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.name;
+        const paramLocation = (_b = externalParamMetadata === null || externalParamMetadata === void 0 ? void 0 : externalParamMetadata.in) !== null && _b !== void 0 ? _b : paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.in;
+        if (!paramName) {
+          throw new MissingParameterDataError({ missingField: "name" });
+        }
+        if (!paramLocation) {
+          throw new MissingParameterDataError({
+            missingField: "in",
+            paramName
+          });
+        }
+        const baseParameter = this.generateSimpleParameter(zodSchema, externalParamMetadata);
+        return Object.assign(Object.assign({}, baseParameter), { in: paramLocation, name: paramName });
+      }
+      generateSchemaWithMetadata(zodSchema) {
+        const innerSchema = Metadata.unwrapChained(zodSchema);
+        const metadata2 = Metadata.getOpenApiMetadata(zodSchema);
+        const defaultValue = Metadata.getDefaultValue(zodSchema);
+        const refId = Metadata.getRefId(zodSchema);
+        if (refId && typeof this.schemaRefs[refId] === "object") {
+          return this.schemaRefs[refId];
+        }
+        if (refId && this.schemaRefs[refId] === "pending") {
+          const refSchema = { $ref: this.generateSchemaRef(refId) };
+          return this.versionSpecifics.mapNullableOfRef(refSchema, isNullableSchema(zodSchema));
+        }
+        if (refId && !this.schemaRefs[refId]) {
+          this.schemaRefs[refId] = "pending";
+        }
+        const result = (metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.type) ? { type: metadata2.type } : this.toOpenAPISchema(innerSchema, isNullableSchema(zodSchema), defaultValue);
+        return metadata2 ? Metadata.applySchemaMetadata(result, metadata2) : omitBy(result, isUndefined);
+      }
+      /**
+       * Same as above but applies nullable
+       */
+      constructReferencedOpenAPISchema(zodSchema) {
+        const metadata2 = Metadata.getOpenApiMetadata(zodSchema);
+        const innerSchema = Metadata.unwrapChained(zodSchema);
+        const defaultValue = Metadata.getDefaultValue(zodSchema);
+        const isNullable = isNullableSchema(zodSchema);
+        if (metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.type) {
+          return this.versionSpecifics.mapNullableType(metadata2.type, isNullable);
+        }
+        const refId = Metadata.getRefId(zodSchema);
+        if (refId && typeof this.schemaRefs[refId] === "object") {
+          return LazyTransformer.mapRecursive(this.schemaRefs[refId], (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (schema) => this.versionSpecifics.mapNullableOfRef(schema, isNullable));
+        }
+        if (refId && this.schemaRefs[refId] === "pending") {
+          const refSchema = { $ref: this.generateSchemaRef(refId) };
+          return this.versionSpecifics.mapNullableOfRef(refSchema, isNullable);
+        }
+        if (refId && !this.schemaRefs[refId]) {
+          this.schemaRefs[refId] = "pending";
+        }
+        return this.toOpenAPISchema(innerSchema, isNullable, defaultValue);
+      }
+      /**
+       * Generates an OpenAPI SchemaObject or a ReferenceObject with all the provided metadata applied
+       */
+      generateSimpleSchema(zodSchema) {
+        const metadata2 = Metadata.getOpenApiMetadata(zodSchema);
+        const refId = Metadata.getRefId(zodSchema);
+        if (!refId || !this.schemaRefs[refId]) {
+          return this.generateSchemaWithMetadata(zodSchema);
+        }
+        const schemaRef = this.schemaRefs[refId];
+        const referenceObject = {
+          $ref: this.generateSchemaRef(refId)
+        };
+        if (this.schemaRefs[refId] === "pending") {
+          return this.versionSpecifics.mapNullableOfRef(referenceObject, isNullableSchema(zodSchema));
+        }
+        const newMetadata = omitBy(Metadata.buildSchemaMetadata(metadata2 !== null && metadata2 !== void 0 ? metadata2 : {}), (value, key) => value === void 0 || objectEquals(value, schemaRef[key]));
+        if (newMetadata.type) {
+          return {
+            allOf: [referenceObject, newMetadata]
+          };
+        }
+        const newSchemaMetadata = omitBy(this.constructReferencedOpenAPISchema(zodSchema), (value, key) => value === void 0 || objectEquals(value, schemaRef[key]));
+        const appliedMetadata = Metadata.applySchemaMetadata(newSchemaMetadata, newMetadata);
+        if (Object.keys(appliedMetadata).length > 0) {
+          return {
+            allOf: [referenceObject, appliedMetadata]
+          };
+        }
+        return referenceObject;
+      }
+      /**
+       * Same as `generateSchema` but if the new schema is added into the
+       * referenced schemas, it would return a ReferenceObject and not the
+       * whole result.
+       *
+       * Should be used for nested objects, arrays, etc.
+       */
+      generateSchemaWithRef(zodSchema) {
+        const refId = Metadata.getRefId(zodSchema);
+        if (refId && !this.schemaRefs[refId]) {
+          this.schemaRefs[refId] = this.generateSimpleSchema(zodSchema);
+          return { $ref: this.generateSchemaRef(refId) };
+        }
+        return this.generateSimpleSchema(zodSchema);
+      }
+      generateSchemaRef(refId) {
+        return `#/components/schemas/${refId}`;
+      }
+      getRequestBody(requestBody) {
+        if (!requestBody) {
+          return;
+        }
+        const { content } = requestBody, rest = __rest(requestBody, ["content"]);
+        const requestBodyContent = this.getBodyContent(content);
+        return Object.assign(Object.assign({}, rest), { content: requestBodyContent });
+      }
+      getParameters(request) {
+        if (!request) {
+          return [];
+        }
+        const { headers } = request;
+        const query = this.cleanParameter(request.query);
+        const params = this.cleanParameter(request.params);
+        const cookies = this.cleanParameter(request.cookies);
+        const queryParameters = enhanceMissingParametersError(() => query ? this.generateInlineParameters(query, "query") : [], { location: "query" });
+        const pathParameters = enhanceMissingParametersError(() => params ? this.generateInlineParameters(params, "path") : [], { location: "path" });
+        const cookieParameters = enhanceMissingParametersError(() => cookies ? this.generateInlineParameters(cookies, "cookie") : [], { location: "cookie" });
+        const headerParameters = enhanceMissingParametersError(() => {
+          if (Array.isArray(headers)) {
+            return headers.flatMap((header) => this.generateInlineParameters(header, "header"));
+          }
+          const cleanHeaders = this.cleanParameter(headers);
+          return cleanHeaders ? this.generateInlineParameters(cleanHeaders, "header") : [];
+        }, { location: "header" });
+        return [
+          ...pathParameters,
+          ...queryParameters,
+          ...headerParameters,
+          ...cookieParameters
+        ];
+      }
+      cleanParameter(schema) {
+        if (!schema) {
+          return void 0;
+        }
+        if (isZodType(schema, "ZodPipe")) {
+          const inSchema = schema._zod.def.in;
+          const outSchema = schema._zod.def.out;
+          if (isZodType(inSchema, "ZodObject")) {
+            return this.cleanParameter(inSchema);
+          }
+          if (isZodType(outSchema, "ZodObject")) {
+            return this.cleanParameter(outSchema);
+          }
+          return void 0;
+        }
+        return schema;
+      }
+      generatePath(route) {
+        const { method, path, request, responses } = route, pathItemConfig = __rest(route, ["method", "path", "request", "responses"]);
+        const generatedResponses = mapValues(responses, (response) => {
+          return this.getResponse(response);
+        });
+        const parameters = enhanceMissingParametersError(() => this.getParameters(request), { route: `${method} ${path}` });
+        const requestBody = this.getRequestBody(request === null || request === void 0 ? void 0 : request.body);
+        const routeDoc = {
+          [method]: Object.assign(Object.assign(Object.assign(Object.assign({}, pathItemConfig), parameters.length > 0 ? {
+            parameters: [...pathItemConfig.parameters || [], ...parameters]
+          } : {}), requestBody ? { requestBody } : {}), { responses: generatedResponses })
+        };
+        return routeDoc;
+      }
+      generateSingleRoute(route) {
+        const routeDoc = this.generatePath(route);
+        this.pathRefs[route.path] = Object.assign(Object.assign({}, this.pathRefs[route.path]), routeDoc);
+        return routeDoc;
+      }
+      getResponse(response) {
+        if (this.isReferenceObject(response)) {
+          return response;
+        }
+        const { content, headers } = response, rest = __rest(response, ["content", "headers"]);
+        const responseContent = content ? { content: this.getBodyContent(content) } : {};
+        if (!headers) {
+          return Object.assign(Object.assign({}, rest), responseContent);
+        }
+        const responseHeaders = isZodType(headers, "ZodObject") ? this.getResponseHeaders(headers) : (
+          // This is input data so it is okay to cast in the common generator
+          // since this is the user's responsibility to keep it correct
+          headers
+        );
+        return Object.assign(Object.assign(Object.assign({}, rest), { headers: responseHeaders }), responseContent);
+      }
+      isReferenceObject(schema) {
+        return "$ref" in schema;
+      }
+      getResponseHeaders(headers) {
+        const schemaShape = headers.def.shape;
+        const responseHeaders = mapValues(schemaShape, (_) => this.generateSimpleParameter(_));
+        return responseHeaders;
+      }
+      getBodyContent(content) {
+        return mapValues(content, (config) => {
+          if (!config) {
+            return config;
+          }
+          if ("$ref" in config) {
+            return config;
+          }
+          const { schema: configSchema, itemSchema: configItemSchema } = config, rest = __rest(config, ["schema", "itemSchema"]);
+          const schema = typeof configSchema === "object" && isAnyZodType(configSchema) ? this.generateSchemaWithRef(configSchema) : configSchema;
+          const itemSchema = typeof configItemSchema === "object" && isAnyZodType(configItemSchema) ? this.generateSchemaWithRef(configItemSchema) : configItemSchema;
+          return Object.assign(Object.assign(Object.assign({}, rest), schema !== void 0 ? { schema } : {}), itemSchema !== void 0 ? { itemSchema } : {});
+        });
+      }
+      toOpenAPISchema(zodSchema, isNullable, defaultValue) {
+        const result = this.openApiTransformer.transform(zodSchema, isNullable, (_) => this.generateSchemaWithRef(_), (_) => this.generateSchemaRef(_), defaultValue);
+        return result;
+      }
+    };
+    var OpenApiGeneratorV30Specifics = class {
+      get nullType() {
+        return { nullable: true };
+      }
+      mapNullableOfArray(objects, isNullable) {
+        if (isNullable && !objects.some((object2) => objectEquals(object2, this.nullType))) {
+          return [...objects, this.nullType];
+        }
+        return objects;
+      }
+      mapNullableType(type, isNullable) {
+        return Object.assign(Object.assign({}, type ? { type } : void 0), isNullable ? this.nullType : void 0);
+      }
+      mapNullableOfRef(ref, isNullable) {
+        if (isNullable) {
+          return {
+            allOf: [ref, this.nullType]
+          };
+        }
+        return ref;
+      }
+      mapTupleItems(schemas) {
+        const uniqueSchemas = uniq(schemas);
+        return {
+          items: uniqueSchemas.length === 1 ? uniqueSchemas[0] : { anyOf: uniqueSchemas },
+          minItems: schemas.length,
+          maxItems: schemas.length
+        };
+      }
+      getNumberChecks(checks) {
+        return Object.assign({}, ...checks.map((check) => {
+          switch (check._zod.def.check) {
+            case "greater_than": {
+              const greaterThanCheck = check;
+              return greaterThanCheck._zod.def.inclusive ? { minimum: Number(greaterThanCheck._zod.def.value) } : {
+                minimum: Number(greaterThanCheck._zod.def.value),
+                exclusiveMinimum: true
+              };
+            }
+            case "less_than": {
+              const lessThanCheck = check;
+              return lessThanCheck._zod.def.inclusive ? { maximum: Number(lessThanCheck._zod.def.value) } : {
+                maximum: Number(lessThanCheck._zod.def.value),
+                exclusiveMaximum: !lessThanCheck._zod.def.inclusive
+              };
+            }
+            default:
+              return {};
+          }
+        }));
+      }
+    };
+    var OpenApiGeneratorV32 = class {
+      constructor(definitions, options) {
+        const specifics = new OpenApiGeneratorV30Specifics();
+        this.generator = new OpenAPIGenerator(definitions, specifics, options);
+      }
+      generateDocument(config) {
+        const baseData = this.generator.generateDocumentData();
+        return Object.assign(Object.assign({}, config), baseData);
+      }
+      generateComponents() {
+        return this.generator.generateComponents();
+      }
+    };
+    var OpenApiGeneratorV31Specifics = class {
+      get nullType() {
+        return { type: "null" };
+      }
+      mapNullableOfArray(objects, isNullable) {
+        if (isNullable && !objects.some((object2) => objectEquals(object2, this.nullType))) {
+          return [...objects, this.nullType];
+        }
+        return objects;
+      }
+      mapNullableType(type, isNullable) {
+        if (!type) {
+          return {};
+        }
+        if (isNullable) {
+          const typeArray = Array.isArray(type) ? type : [type];
+          const nullableType = uniq([...typeArray, "null"]);
+          return { type: nullableType };
+        }
+        return { type };
+      }
+      mapNullableOfRef(ref, isNullable) {
+        if (isNullable) {
+          return {
+            oneOf: [ref, this.nullType]
+          };
+        }
+        return ref;
+      }
+      mapTupleItems(schemas) {
+        return {
+          prefixItems: schemas
+        };
+      }
+      getNumberChecks(checks) {
+        return Object.assign({}, ...checks.map((check) => {
+          switch (check._zod.def.check) {
+            case "greater_than": {
+              const greaterThanCheck = check;
+              return greaterThanCheck._zod.def.inclusive ? { minimum: Number(greaterThanCheck._zod.def.value) } : { exclusiveMinimum: Number(greaterThanCheck._zod.def.value) };
+            }
+            case "less_than": {
+              const lessThanCheck = check;
+              return lessThanCheck._zod.def.inclusive ? { maximum: Number(lessThanCheck._zod.def.value) } : { exclusiveMaximum: Number(lessThanCheck._zod.def.value) };
+            }
+            default:
+              return {};
+          }
+        }));
+      }
+    };
+    function isWebhookDefinition$1(definition) {
+      return "type" in definition && definition.type === "webhook";
+    }
+    var OpenApiGeneratorV312 = class {
+      constructor(definitions, options) {
+        this.definitions = definitions;
+        this.webhookRefs = {};
+        const specifics = new OpenApiGeneratorV31Specifics();
+        this.generator = new OpenAPIGenerator(this.definitions, specifics, options);
+      }
+      generateDocument(config) {
+        this.generateWebhooks();
+        const baseDocument = this.generator.generateDocumentData();
+        return Object.assign(Object.assign(Object.assign({}, config), baseDocument), { webhooks: this.webhookRefs });
+      }
+      generateComponents() {
+        return this.generator.generateComponents();
+      }
+      generateWebhooks() {
+        this.webhookRefs = {};
+        this.definitions.filter(isWebhookDefinition$1).forEach((definition) => this.generateSingleWebhook(definition.webhook));
+      }
+      generateSingleWebhook(route) {
+        const routeDoc = this.generator.generatePath(route);
+        this.webhookRefs[route.path] = Object.assign(Object.assign({}, this.webhookRefs[route.path]), routeDoc);
+        return routeDoc;
+      }
+    };
+    function isWebhookDefinition(definition) {
+      return "type" in definition && definition.type === "webhook";
+    }
+    var OpenApiGeneratorV322 = class {
+      constructor(definitions, options) {
+        this.definitions = definitions;
+        this.webhookRefs = {};
+        const specifics = new OpenApiGeneratorV31Specifics();
+        this.generator = new OpenAPIGenerator(this.definitions, specifics, options);
+      }
+      generateDocument(config) {
+        this.generateWebhooks();
+        const baseDocument = this.generator.generateDocumentData();
+        return Object.assign(Object.assign(Object.assign({}, config), baseDocument), { webhooks: this.webhookRefs });
+      }
+      generateComponents() {
+        return this.generator.generateComponents();
+      }
+      generateWebhooks() {
+        this.webhookRefs = {};
+        this.definitions.filter(isWebhookDefinition).forEach((definition) => this.generateSingleWebhook(definition.webhook));
+      }
+      generateSingleWebhook(route) {
+        const routeDoc = this.generator.generatePath(route);
+        this.webhookRefs[route.path] = Object.assign(Object.assign({}, this.webhookRefs[route.path]), routeDoc);
+        return routeDoc;
+      }
+    };
+    exports.OpenAPIRegistry = OpenAPIRegistry2;
+    exports.OpenApiGeneratorV3 = OpenApiGeneratorV32;
+    exports.OpenApiGeneratorV31 = OpenApiGeneratorV312;
+    exports.OpenApiGeneratorV32 = OpenApiGeneratorV322;
+    exports.extendZodWithOpenApi = extendZodWithOpenApi2;
+    exports.getOpenApiMetadata = getOpenApiMetadata2;
+    exports.getRefId = getRefId;
+    exports.zodToOpenAPIRegistry = zodToOpenAPIRegistry;
+  }
+});
+
+// packages/cli/contracts/internal.ts
+import { z as z7 } from "zod";
+
+// node_modules/.pnpm/@hono+zod-openapi@1.6.3_hono@4.13.8_zod@4.6.5/node_modules/@hono/zod-openapi/dist/index.mjs
+var import_zod_to_openapi = __toESM(require_dist(), 1);
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/utils/url.js
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
+      try {
+        return decoder(match2);
+      } catch {
+        return match2;
+      }
+    });
+  }
+};
+var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
+var _decodeURI = (value) => {
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return tryDecodeURIComponent(value);
+};
+var _getQueryParam = (url, key, multiple) => {
+  const hashIndex = url.indexOf("#", 8);
+  if (hashIndex !== -1) {
+    url = url.slice(0, hashIndex);
+  }
+  let encoded;
+  if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1) {
+      return void 0;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return void 0;
+    }
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(
+      keyIndex + 1,
+      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
+    );
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      ;
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      // Normalize the media type (case-insensitive) while keeping parameters like the boundary
+      "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase())
+    }
+  });
+  return response.formData();
+};
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/utils/body.js
+var MAX_NESTING_DEPTH = 32;
+var MAX_NESTED_OBJECTS = 1e4;
+var isRawRequest = (request) => "headers" in request;
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const contentType = headers.get("Content-Type");
+  const mediaType = contentType?.split(";")[0].trim().toLowerCase();
+  if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  if (!isRawRequest(request) && request.bodyCache.formData) {
+    return convertFormDataToBodyData(
+      await request.bodyCache.formData,
+      options
+    );
+  }
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const arrayBuffer = await request.arrayBuffer();
+  const formDataPromise = bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
+  if (!isRawRequest(request)) {
+    request.bodyCache.formData = formDataPromise;
+  }
+  const formData = await formDataPromise;
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  const nestingState = { count: 0 };
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value, nestingState);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+var handleParsingNestedValues = (form, key, value, state) => {
+  if (/(?:^|\.)__proto__\./.test(key)) {
+    return;
+  }
+  let nestedForm = form;
+  const keys = key.split(".", MAX_NESTING_DEPTH + 2);
+  if (keys.length > MAX_NESTING_DEPTH + 1) {
+    throwNestingLimitExceeded();
+  }
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        if (state.count++ >= MAX_NESTED_OBJECTS) {
+          throwNestingLimitExceeded();
+        }
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+var throwNestingLimitExceeded = () => {
+  throw new Error("Nesting limit exceeded");
+};
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/request.js
+var HonoRequest = class {
+  /**
+   * `.raw` can get the raw Request object.
+   *
+   * @see {@link https://hono.dev/docs/api/request#raw}
+   *
+   * @example
+   * ```ts
+   * // For Cloudflare Workers
+   * app.post('/', async (c) => {
+   *   const metadata = c.req.raw.cf?.hostMetadata?
+   *   ...
+   * })
+   * ```
+   */
+  raw;
+  #validatedData;
+  // Short name of validatedData
+  #matchResult;
+  routeIndex = 0;
+  /**
+   * `.path` can get the pathname of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#path}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const pathname = c.req.path // `/about/me`
+   * })
+   * ```
+   */
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && tryDecodeURIComponent(param);
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== void 0) {
+        decoded[key] = tryDecodeURIComponent(value);
+      }
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name) ?? void 0;
+    }
+    const headerData = /* @__PURE__ */ Object.create(null);
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    for (const anyCachedKey in bodyCache) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        const contentType = anyCachedKey === "formData" ? void 0 : raw.headers.get("content-type");
+        return new Response(body, {
+          headers: contentType ? { "Content-Type": contentType } : void 0
+        })[key]();
+      });
+    }
+    return bodyCache[key] = raw[key]();
+  };
+  /**
+   * `.json()` can parse Request body of type `application/json`
+   *
+   * @see {@link https://hono.dev/docs/api/request#json}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.json()
+   * })
+   * ```
+   */
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  /**
+   * `.text()` can parse Request body of type `text/plain`
+   *
+   * @see {@link https://hono.dev/docs/api/request#text}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.text()
+   * })
+   * ```
+   */
+  text() {
+    return this.#cachedBody("text");
+  }
+  /**
+   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+   *
+   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.arrayBuffer()
+   * })
+   * ```
+   */
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  /**
+   * `.bytes()` parses the request body as a `Uint8Array`.
+   *
+   * @see {@link https://hono.dev/docs/api/request#bytes}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.bytes()
+   * })
+   * ```
+   */
+  bytes() {
+    return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+  }
+  /**
+   * Parses the request body as a `Blob`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.blob();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#blob
+   */
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  /**
+   * Parses the request body as `FormData`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.formData();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#formdata
+   */
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  /**
+   * Adds validated data to the request.
+   *
+   * @param target - The target of the validation.
+   * @param data - The validated data to add.
+   */
+  addValidatedData(target, data) {
+    ;
+    (this.#validatedData ??= {})[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData?.[target];
+  }
+  /**
+   * `.url()` can get the request url strings.
+   *
+   * @see {@link https://hono.dev/docs/api/request#url}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const url = c.req.url // `http://localhost:8787/about/me`
+   *   ...
+   * })
+   * ```
+   */
+  get url() {
+    return this.raw.url;
+  }
+  /**
+   * `.method()` can get the method name of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#method}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const method = c.req.method // `GET`
+   * })
+   * ```
+   */
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  /**
+   * `.matchedRoutes()` can return a matched route in the handler
+   *
+   * @deprecated
+   *
+   * Use matchedRoutes helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async function logger(c, next) {
+   *   await next()
+   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+   *     console.log(
+   *       method,
+   *       ' ',
+   *       path,
+   *       ' '.repeat(Math.max(10 - path.length, 0)),
+   *       name,
+   *       i === c.req.routeIndex ? '<- respond from here' : ''
+   *     )
+   *   })
+   * })
+   * ```
+   */
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  /**
+   * `routePath()` can retrieve the path registered within the handler
+   *
+   * @deprecated
+   *
+   * Use routePath helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#routepath}
+   *
+   * @example
+   * ```ts
+   * app.get('/posts/:id', (c) => {
+   *   return c.json({ path: c.req.routePath })
+   * })
+   * ```
+   */
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/router/utils.js
+var createNullObject = () => /* @__PURE__ */ Object.create(null);
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/router/reg-exp-router/node.js
+var regExpMetaChars = new Set(".\\+*[^]$()");
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/router/reg-exp-router/router.js
+var wildcardRegExpCache = createNullObject();
+
+// node_modules/.pnpm/hono@4.13.8/node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = createNullObject();
+
+// node_modules/.pnpm/@hono+zod-openapi@1.6.3_hono@4.13.8_zod@4.6.5/node_modules/@hono/zod-openapi/dist/index.mjs
+import { z } from "zod";
+(0, import_zod_to_openapi.extendZodWithOpenApi)(z);
+
+// apps/api/src/config/permissions.ts
+var apiKeyPermissionNames = [
+  "environments:read",
+  "environments:write",
+  "environments:connect",
+  "snapshots:read",
+  "snapshots:write"
+];
+var permissionNames = [
+  ...apiKeyPermissionNames,
+  "workspaces:write",
+  "api_keys:read",
+  "api_keys:write",
+  "members:read",
+  "members:write"
+];
+var cliTokenPermissionNames = [
+  ...apiKeyPermissionNames,
+  "api_keys:read",
+  "api_keys:write"
+];
+
+// packages/runtime/src/protocol-profiles.ts
+var SERVICE_ID_PATTERN = /^[a-z][a-z0-9-]{0,39}$/;
+var MAX_DECLARABLE_REQUEST_BYTES = 64 * 1024 * 1024;
+
+// apps/api/src/utils/api-error.ts
+var statuses = {
+  invalid_request: 400,
+  unauthenticated: 401,
+  forbidden: 403,
+  not_found: 404,
+  invalid_status: 409,
+  snapshot_in_progress: 409,
+  idempotency_key_reused: 409,
+  name_taken: 409,
+  last_owner: 409,
+  last_workspace: 409,
+  workspace_archived: 409,
+  version_in_use: 409,
+  body_too_large: 413,
+  version_unavailable: 422,
+  environment_limit_reached: 429,
+  rate_limited: 429,
+  internal_error: 500,
+  unavailable: 503
+};
+var errorCodes = Object.keys(statuses);
+
+// apps/api/src/api/schemas/common.ts
+var idSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var serviceIdSchema = z.string().regex(SERVICE_ID_PATTERN);
+var nameSchema = z.string().trim().min(1).max(120);
+var timestampSchema = z.iso.datetime();
+var principalSchema = z.object({
+  type: z.enum(["member", "api_key", "system"]),
+  id: z.string().nullable(),
+  name: z.string().nullable()
+}).openapi("Principal");
+function jsonbTextBytes(value) {
+  const text = (item) => {
+    if (Array.isArray(item)) {
+      return `[${item.map(text).join(", ")}]`;
+    }
+    if (item !== null && typeof item === "object") {
+      return `{${Object.entries(item).map(([key, entry]) => `${JSON.stringify(key)}: ${text(entry)}`).join(", ")}}`;
+    }
+    return JSON.stringify(item);
+  };
+  return Buffer.byteLength(text(value));
+}
+var labelsSchema = z.preprocess(
+  (value, context) => {
+    if (value && typeof value === "object" && Object.keys(value).some(
+      (key) => ["__proto__", "constructor", "prototype"].includes(key)
+    )) {
+      context.addIssue({
+        code: "custom",
+        message: "Reserved label keys are not allowed."
+      });
+    }
+    return value;
+  },
+  z.record(
+    z.string().min(1).max(63).regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/),
+    z.string().max(256)
+  )
+).refine((value) => Object.keys(value).length <= 32, "At most 32 labels.").refine(
+  (value) => !Object.keys(value).some(
+    (key) => key.startsWith("usestatemachines.com/")
+  ),
+  "The usestatemachines.com/ prefix is reserved."
+).refine(
+  (value) => jsonbTextBytes(value) <= 8192,
+  "Labels must fit within 8 KiB."
+);
+var errorSchema = z.object({
+  error: z.object({
+    code: z.enum(errorCodes),
+    message: z.string(),
+    requestId: z.string(),
+    fields: z.record(z.string(), z.array(z.string())).optional(),
+    status: z.string().optional()
+  })
+}).openapi("Error");
+var pageQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  cursor: z.string().max(2048).optional()
+});
+var idempotencyHeaderSchema = z.object({
+  "idempotency-key": z.string().min(8).max(128).regex(/^[A-Za-z0-9._:-]+$/).optional()
+});
+function pageSchema(schema) {
+  return z.object({ data: z.array(schema), nextCursor: z.string().nullable() });
+}
+var error = (description) => ({
+  description,
+  content: { "application/json": { schema: errorSchema } }
+});
+var standardErrors = {
+  400: error("Invalid request"),
+  401: error("Authentication required"),
+  403: error("Permission denied"),
+  404: error("Resource not found"),
+  409: error("Conflicting request"),
+  413: error("Request body too large"),
+  422: error("Version unavailable"),
+  429: error("Limit reached"),
+  500: error("Unexpected failure"),
+  503: error("Dependency unavailable")
+};
+
+// apps/api/src/api/schemas/api-keys.ts
+var apiKeyPermissionSchema = z.enum(apiKeyPermissionNames).openapi("ApiKeyPermission");
+var apiKeySchema = z.object({
+  id: idSchema,
+  workspaceId: idSchema,
+  name: z.string(),
+  displayValue: z.string(),
+  /** From WorkOS, the authority. A revoke answers what the key held; a revoked key holds none. */
+  permissions: z.array(apiKeyPermissionSchema),
+  createdBy: principalSchema,
+  createdAt: timestampSchema,
+  lastUsedAt: timestampSchema.nullable(),
+  revokedAt: timestampSchema.nullable(),
+  kind: z.enum(["dashboard", "cli_run", "env_pull"]),
+  expiresAt: timestampSchema.nullable()
+}).openapi("ApiKey");
+var apiKeyListQuerySchema = pageQuerySchema.extend({
+  workspaceId: idSchema
+});
+var createApiKeySchema = z.object({
+  workspaceId: idSchema,
+  name: nameSchema,
+  permissions: z.array(apiKeyPermissionSchema).min(1).max(5),
+  kind: z.enum(["cli_run", "env_pull"]).optional()
+});
+var createdApiKeySchema = z.object({
+  apiKey: apiKeySchema,
+  secret: z.string().optional()
+});
+var apiKeyIdSchema = z.object({ apiKeyId: idSchema });
+
+// apps/api/src/auth/cli-sealing.ts
+import { z as z2 } from "zod";
+var sealedCliTokenSchema = z2.object({
+  v: z2.literal(1),
+  serverPublicKey: z2.string(),
+  nonce: z2.string(),
+  ciphertext: z2.string(),
+  tag: z2.string()
+});
+
+// apps/api/src/api/schemas/cli-logins.ts
+var cliUserCodeSchema = z.string().trim().toUpperCase().regex(/^[BCDFGHJKLMNPQRSTVWXZ]{4}-?[BCDFGHJKLMNPQRSTVWXZ]{4}$/).transform((value) => value.replace("-", ""));
+var printable = /^[^\p{Cc}\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]*$/u;
+var metadata = (max) => z.string().trim().min(1).max(max).regex(printable);
+var startCliLoginSchema = z.object({
+  publicKey: z.string().max(128),
+  cliVersion: metadata(32),
+  hostname: metadata(64),
+  platform: metadata(32)
+});
+var startedCliLoginSchema = z.object({
+  loginId: idSchema,
+  deviceCode: z.string(),
+  userCode: z.string(),
+  verificationUrl: z.url(),
+  expiresIn: z.number().int(),
+  interval: z.number().int()
+});
+var cliLoginDetailsSchema = z.discriminatedUnion("status", [
+  z.object({
+    loginId: idSchema,
+    userCode: z.string(),
+    status: z.literal("pending"),
+    hostname: z.string(),
+    platform: z.string(),
+    cliVersion: z.string(),
+    location: z.string().nullable(),
+    createdAt: timestampSchema,
+    expiresAt: timestampSchema,
+    permissions: z.array(z.enum(cliTokenPermissionNames))
+  }),
+  z.object({
+    loginId: idSchema,
+    userCode: z.string(),
+    status: z.enum(["approved", "collected", "denied"])
+  })
+]);
+var cliLoginDecisionSchema = z.object({ userCode: cliUserCodeSchema });
+var cliLoginLookupSchema = z.object({ userCode: cliUserCodeSchema });
+var cliLoginIdSchema = z.object({
+  loginId: z.string().regex(/^cli_login_[0-9a-z]{16}$/)
+});
+var approvedCliLoginSchema = z.object({
+  loginId: idSchema,
+  status: z.literal("approved")
+});
+var deniedCliLoginSchema = z.object({
+  loginId: idSchema,
+  status: z.literal("denied")
+});
+var collectedCliLoginSchema = z.object({
+  loginId: idSchema,
+  status: z.literal("collected")
+});
+var pollCliLoginSchema = z.object({
+  deviceCode: z.string().regex(/^[A-Za-z0-9_-]{43}$/)
+});
+var cliLoginPollErrorSchema = z.object({
+  error: z.enum([
+    "authorization_pending",
+    "slow_down",
+    "access_denied",
+    "expired_token"
+  ]),
+  interval: z.number().int()
+});
+var cliLoginTokenSchema = z.object({
+  envelope: sealedCliTokenSchema,
+  tokenId: idSchema,
+  idleExpiresAt: timestampSchema,
+  expiresAt: timestampSchema,
+  organization: z.object({ id: z.string(), name: z.string() }),
+  user: z.object({ email: z.string() })
+});
+
+// apps/api/src/api/schemas/cli-tokens.ts
+var cliTokenSchema = z.object({
+  id: idSchema,
+  name: z.string(),
+  createdAt: timestampSchema,
+  lastUsedAt: timestampSchema.nullable(),
+  idleExpiresAt: timestampSchema,
+  expiresAt: timestampSchema,
+  revokedAt: timestampSchema.nullable()
+});
+var cliTokenListSchema = pageSchema(cliTokenSchema);
+
+// apps/api/src/auth/analytics-source.ts
+import { z as z3 } from "zod";
+var cliAgentSchema = z3.enum([
+  "claude_code",
+  "codex_cli",
+  "cursor",
+  "cursor-cli",
+  "gemini_cli",
+  "github-copilot"
+]);
+var cliVersionSchema = z3.string().max(32).regex(/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/);
+
+// packages/http/src/environment-token.ts
+var ENVIRONMENT_TOKEN_HEADER = "StateMachines-Environment-Token";
+var TOKEN_PATTERN = "[A-Za-z0-9_-]{1,256}";
+var COMBINED_BEARER_PREFIX = "state_app_";
+var COMBINED = new RegExp(
+  `^${COMBINED_BEARER_PREFIX}(${TOKEN_PATTERN})\\.(${TOKEN_PATTERN})$`
+);
+
+// packages/http/src/credential-variables.ts
+var HTTP_TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var NAMED_HEADERS = /* @__PURE__ */ new Map([
+  [ENVIRONMENT_TOKEN_HEADER.toLowerCase(), "ENVIRONMENT_TOKEN"],
+  ["authorization", "AUTHORIZATION"]
+]);
+function variablePart(value) {
+  return value.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+}
+function serviceVariable(appName, serviceId, slot) {
+  return `STATEMACHINES_${variablePart(appName)}_${variablePart(serviceId)}_${slot}`;
+}
+function mcpServerVariable(appName, serviceId, serverName) {
+  return `STATEMACHINES_${variablePart(appName)}_${variablePart(serviceId)}_MCP_${variablePart(serverName)}_URL`;
+}
+function actorTokenVariable(appName) {
+  return `STATEMACHINES_${variablePart(appName)}_ACTOR_TOKEN`;
+}
+function uniqueHeaders(headers) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(headers)) {
+    if (!HTTP_TOKEN.test(name)) {
+      continue;
+    }
+    const earlier = byName.get(name.toLowerCase());
+    byName.set(
+      name.toLowerCase(),
+      earlier ? { ...earlier, value: `${earlier.value}, ${value}` } : { name, value }
+    );
+  }
+  return [...byName.values()];
+}
+function headerVariables(appName, serviceId, headers) {
+  return uniqueHeaders(headers).map(({ name, value }, index) => {
+    const slot = NAMED_HEADERS.get(name.toLowerCase()) ?? `HEADER_${index + 1}`;
+    return {
+      name,
+      value,
+      slot,
+      variable: serviceVariable(appName, serviceId, slot)
+    };
+  });
+}
+
+// packages/sdk/esm/models/error.js
+import * as z6 from "zod/v4-mini";
+
+// packages/sdk/esm/types/enums.js
+import * as z4 from "zod/v4-mini";
+
+// packages/sdk/esm/types/unrecognized.js
+function unrecognized(value) {
+  globalCount++;
+  return value;
+}
+var globalCount = 0;
+
+// packages/sdk/esm/types/enums.js
+function inboundSchema(enumObj) {
+  const options = Object.values(enumObj);
+  return z4.union([
+    ...options.map((x) => z4.literal(x)),
+    z4.pipe(z4.string(), z4.transform((x) => unrecognized(x)))
+  ]);
+}
+
+// packages/sdk/esm/types/primitives.js
+import * as z5 from "zod/v4-mini";
+
+// packages/sdk/esm/types/default-to-zero-value.js
+var globalCount2 = 0;
+function defaultToZeroValue(value) {
+  globalCount2++;
+  return unrecognized(value);
+}
+
+// packages/sdk/esm/types/primitives.js
+function string3() {
+  return z5.union([
+    z5.string(),
+    // Null or undefined -> ""
+    zodDefaultToZeroValue(""),
+    // Any other value -> String(x)
+    z5.pipe(z5.any(), z5.transform((x) => unrecognized(JSON.stringify(x))))
+  ]);
+}
+function optional2(t) {
+  return z5.optional(z5.union([
+    // Null -> undefined
+    z5.pipe(z5.null(), z5.transform(() => unrecognized(void 0))),
+    t
+  ]));
+}
+function zodDefaultToZeroValue(value) {
+  return z5.pipe(z5.any(), z5.transform((input, ctx) => {
+    if (input === void 0)
+      return defaultToZeroValue(value);
+    if (input === null)
+      return defaultToZeroValue(value);
+    ctx.issues.push({
+      input,
+      code: "invalid_type",
+      expected: "undefined",
+      received: "unknown"
+    });
+    return z5.NEVER;
+  }));
+}
+
+// packages/sdk/esm/models/error.js
+var ErrorCode = {
+  InvalidRequest: "invalid_request",
+  Unauthenticated: "unauthenticated",
+  Forbidden: "forbidden",
+  NotFound: "not_found",
+  InvalidStatus: "invalid_status",
+  SnapshotInProgress: "snapshot_in_progress",
+  IdempotencyKeyReused: "idempotency_key_reused",
+  NameTaken: "name_taken",
+  LastOwner: "last_owner",
+  LastWorkspace: "last_workspace",
+  WorkspaceArchived: "workspace_archived",
+  VersionInUse: "version_in_use",
+  BodyTooLarge: "body_too_large",
+  VersionUnavailable: "version_unavailable",
+  EnvironmentLimitReached: "environment_limit_reached",
+  RateLimited: "rate_limited",
+  InternalError: "internal_error",
+  Unavailable: "unavailable"
+};
+var ErrorCode$inboundSchema = inboundSchema(ErrorCode);
+var ErrorT$inboundSchema = z6.object({
+  code: ErrorCode$inboundSchema,
+  fields: optional2(z6.record(z6.string(), z6.array(string3()))),
+  message: string3(),
+  requestId: string3(),
+  status: optional2(string3())
+});
+
+// packages/cli/contracts/internal.ts
+var parseStartLogin = (input) => startCliLoginSchema.parse(input);
+var parseStartedLogin = (input) => startedCliLoginSchema.parse(input);
+var parseLoginToken = (input) => cliLoginTokenSchema.parse(input);
+var parsePollError = (input) => cliLoginPollErrorSchema.parse(input);
+var parseCollected = (input) => collectedCliLoginSchema.parse(input);
+var parseCreateKey = (input) => createApiKeySchema.parse(input);
+var keyPolicy = {
+  permissions: createApiKeySchema.shape.permissions.element.options,
+  maxNameLength: createApiKeySchema.shape.name.maxLength
+};
+var parseEnvironmentLabels = (input) => labelsSchema.parse(input);
+var parseCreatedKey = (input) => createdApiKeySchema.parse(input);
+var parseKey = (input) => apiKeySchema.parse(input);
+var parseKeyListQuery = (input) => apiKeyListQuerySchema.parse(input);
+var parseKeyList = (input) => pageSchema(apiKeySchema).parse(input);
+var parseTokenList = (input) => cliTokenListSchema.parse(input);
+var parseAgent = (input) => {
+  const result = cliAgentSchema.safeParse(input);
+  return result.success ? result.data : null;
+};
+function parseApiError(input) {
+  const envelope = z7.object({ error: z7.unknown() }).parse(input);
+  const error2 = ErrorT$inboundSchema.parse(envelope.error);
+  return {
+    code: error2.code,
+    message: error2.message,
+    requestId: error2.requestId,
+    fields: error2.fields ?? null
+  };
+}
+var credentialVariables = (appName, actorToken, services) => [
+  ...services.flatMap(({ id, url, headers, servers }) => [
+    [serviceVariable(appName, id, "URL"), url],
+    ...headerVariables(appName, id, headers).map(
+      ({ variable, value }) => [variable, value]
+    ),
+    ...(servers ?? []).map(({ name, url: url2 }) => [
+      mcpServerVariable(appName, id, name),
+      url2
+    ])
+  ]),
+  [actorTokenVariable(appName), actorToken]
+];
+export {
+  credentialVariables,
+  keyPolicy,
+  parseAgent,
+  parseApiError,
+  parseCollected,
+  parseCreateKey,
+  parseCreatedKey,
+  parseEnvironmentLabels,
+  parseKey,
+  parseKeyList,
+  parseKeyListQuery,
+  parseLoginToken,
+  parsePollError,
+  parseStartLogin,
+  parseStartedLogin,
+  parseTokenList
+};