@forklaunch/implementation-worker-redis 0.3.8 → 0.5.0

package/lib/domain/schemas/index.js

@@ -1,13 +1,8 @@
 "use strict";
-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() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -21,440 +16,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-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
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../../node_modules/.pnpm/ts-deepmerge@6.2.1/node_modules/ts-deepmerge/cjs/index.js
-var require_cjs = __commonJS({
-  "../../../node_modules/.pnpm/ts-deepmerge@6.2.1/node_modules/ts-deepmerge/cjs/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    var isObject = (obj) => {
-      if (typeof obj === "object" && obj !== null) {
-        if (typeof Object.getPrototypeOf === "function") {
-          const prototype = Object.getPrototypeOf(obj);
-          return prototype === Object.prototype || prototype === null;
-        }
-        return Object.prototype.toString.call(obj) === "[object Object]";
-      }
-      return false;
-    };
-    var merge = (...objects) => objects.reduce((result, current) => {
-      if (Array.isArray(current)) {
-        throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
-      }
-      Object.keys(current).forEach((key) => {
-        if (["__proto__", "constructor", "prototype"].includes(key)) {
-          return;
-        }
-        if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-          result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [...result[key], ...current[key]] : current[key];
-        } else if (isObject(result[key]) && isObject(current[key])) {
-          result[key] = merge(result[key], current[key]);
-        } else {
-          result[key] = current[key] === void 0 ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
-        }
-      });
-      return result;
-    }, {});
-    var defaultOptions = {
-      allowUndefinedOverrides: true,
-      mergeArrays: true,
-      uniqueArrayItems: true
-    };
-    merge.options = defaultOptions;
-    merge.withOptions = (options, ...objects) => {
-      merge.options = Object.assign(Object.assign({}, defaultOptions), options);
-      const result = merge(...objects);
-      merge.options = defaultOptions;
-      return result;
-    };
-    exports2.default = merge;
-  }
-});
-
-// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-openapi.js
-var require_zod_openapi = __commonJS({
-  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-openapi.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.generateSchema = exports2.extendApi = void 0;
-    var ts_deepmerge_1 = require_cjs();
-    var zod_1 = require("zod");
-    function extendApi(schema, schemaObject = {}) {
-      const This = schema.constructor;
-      const newSchema = new This(schema._def);
-      newSchema.metaOpenApi = Object.assign({}, schema.metaOpenApi || {}, schemaObject);
-      return newSchema;
-    }
-    exports2.extendApi = extendApi;
-    function iterateZodObject({ zodRef, useOutput, hideDefinitions, openApiVersion }) {
-      const reduced = Object.keys(zodRef.shape).filter((key) => (hideDefinitions === null || hideDefinitions === void 0 ? void 0 : hideDefinitions.includes(key)) === false).reduce((carry, key) => Object.assign(Object.assign({}, carry), { [key]: generateSchema2(zodRef.shape[key], useOutput, openApiVersion) }), {});
-      return reduced;
-    }
-    function typeFormat(type3, openApiVersion) {
-      return openApiVersion === "3.0" ? type3 : [type3];
-    }
-    function parseTransformation({ zodRef, schemas, useOutput, openApiVersion }) {
-      const input = generateSchema2(zodRef._def.schema, useOutput, openApiVersion);
-      let output = "undefined";
-      if (useOutput && zodRef._def.effect) {
-        const effect = zodRef._def.effect.type === "transform" ? zodRef._def.effect : null;
-        if (effect && "transform" in effect) {
-          try {
-            const type3 = Array.isArray(input.type) ? input.type[0] : input.type;
-            output = typeof effect.transform(
-              ["integer", "number"].includes(`${type3}`) ? 0 : "string" === type3 ? "" : "boolean" === type3 ? false : "object" === type3 ? {} : "null" === type3 ? null : "array" === type3 ? [] : void 0,
-              { addIssue: () => void 0, path: [] }
-              // TODO: Discover if context is necessary here
-            );
-          } catch (e) {
-          }
-        }
-      }
-      const outputType = output;
-      return (0, ts_deepmerge_1.default)(Object.assign(Object.assign(Object.assign({}, zodRef.description ? { description: zodRef.description } : {}), input), ["number", "string", "boolean", "null"].includes(output) ? {
-        type: typeFormat(outputType, openApiVersion)
-      } : {}), ...schemas);
-    }
-    function parseString({ zodRef, schemas, openApiVersion }) {
-      const baseSchema = {
-        type: typeFormat("string", openApiVersion)
-      };
-      const { checks = [] } = zodRef._def;
-      checks.forEach((item) => {
-        switch (item.kind) {
-          case "email":
-            baseSchema.format = "email";
-            break;
-          case "uuid":
-            baseSchema.format = "uuid";
-            break;
-          case "cuid":
-            baseSchema.format = "cuid";
-            break;
-          case "url":
-            baseSchema.format = "uri";
-            break;
-          case "datetime":
-            baseSchema.format = "date-time";
-            break;
-          case "length":
-            baseSchema.minLength = item.value;
-            baseSchema.maxLength = item.value;
-            break;
-          case "max":
-            baseSchema.maxLength = item.value;
-            break;
-          case "min":
-            baseSchema.minLength = item.value;
-            break;
-          case "regex":
-            baseSchema.pattern = item.regex.source;
-            break;
-        }
-      });
-      return (0, ts_deepmerge_1.default)(baseSchema, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNumber({ zodRef, schemas, openApiVersion }) {
-      const baseSchema = {
-        type: typeFormat("number", openApiVersion)
-      };
-      const { checks = [] } = zodRef._def;
-      checks.forEach((item) => {
-        switch (item.kind) {
-          case "max":
-            if (item.inclusive || openApiVersion === "3.0") {
-              baseSchema.maximum = item.value;
-            }
-            if (!item.inclusive) {
-              if (openApiVersion === "3.0") {
-                baseSchema.exclusiveMaximum = true;
-              } else {
-                baseSchema.exclusiveMaximum = item.value;
-              }
-            }
-            break;
-          case "min":
-            if (item.inclusive || openApiVersion === "3.0") {
-              baseSchema.minimum = item.value;
-            }
-            if (!item.inclusive) {
-              if (openApiVersion === "3.0") {
-                baseSchema.exclusiveMinimum = true;
-              } else {
-                baseSchema.exclusiveMinimum = item.value;
-              }
-            }
-            break;
-          case "int":
-            baseSchema.type = typeFormat("integer", openApiVersion);
-            break;
-          case "multipleOf":
-            baseSchema.multipleOf = item.value;
-            break;
-        }
-      });
-      return (0, ts_deepmerge_1.default)(baseSchema, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function getExcludedDefinitionsFromSchema(schemas) {
-      const excludedDefinitions = [];
-      for (const schema of schemas) {
-        if (Array.isArray(schema.hideDefinitions)) {
-          excludedDefinitions.push(...schema.hideDefinitions);
-        }
-      }
-      return excludedDefinitions;
-    }
-    function parseObject({ zodRef, schemas, useOutput, hideDefinitions, openApiVersion }) {
-      var _a;
-      let additionalProperties;
-      if (!(zodRef._def.catchall instanceof zod_1.z.ZodNever || ((_a = zodRef._def.catchall) === null || _a === void 0 ? void 0 : _a._def.typeName) === "ZodNever"))
-        additionalProperties = generateSchema2(zodRef._def.catchall, useOutput, openApiVersion);
-      else if (zodRef._def.unknownKeys === "passthrough")
-        additionalProperties = true;
-      else if (zodRef._def.unknownKeys === "strict")
-        additionalProperties = false;
-      additionalProperties = additionalProperties != null ? { additionalProperties } : {};
-      const requiredProperties = Object.keys(zodRef.shape).filter((key) => {
-        const item = zodRef.shape[key];
-        return !(item.isOptional() || item instanceof zod_1.z.ZodDefault || item._def.typeName === "ZodDefault") && !(item instanceof zod_1.z.ZodNever || item._def.typeName === "ZodDefault");
-      });
-      const required = requiredProperties.length > 0 ? { required: requiredProperties } : {};
-      return (0, ts_deepmerge_1.default)(Object.assign(Object.assign(Object.assign({ type: typeFormat("object", openApiVersion), properties: iterateZodObject({
-        zodRef,
-        schemas,
-        useOutput,
-        hideDefinitions: getExcludedDefinitionsFromSchema(schemas),
-        openApiVersion
-      }) }, required), additionalProperties), hideDefinitions), zodRef.description ? { description: zodRef.description, hideDefinitions } : {}, ...schemas);
-    }
-    function parseRecord({ zodRef, schemas, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat("object", openApiVersion),
-        additionalProperties: zodRef._def.valueType instanceof zod_1.z.ZodUnknown ? {} : generateSchema2(zodRef._def.valueType, useOutput, openApiVersion)
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseBigInt({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat("integer", openApiVersion),
-        format: "int64"
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseBoolean({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({ type: typeFormat("boolean", openApiVersion) }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseDate({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat("string", openApiVersion),
-        format: "date-time"
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNull({ zodRef, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(openApiVersion === "3.0" ? { type: "null" } : {
-        type: ["string", "null"],
-        enum: ["null"]
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseOptional({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef.unwrap(), useOutput, openApiVersion), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNullable({ schemas, zodRef, useOutput, openApiVersion }) {
-      const schema = generateSchema2(zodRef.unwrap(), useOutput, openApiVersion);
-      return (0, ts_deepmerge_1.default)(schema, openApiVersion === "3.0" ? { nullable: true } : { type: typeFormat("null", openApiVersion) }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseDefault({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(Object.assign({ default: zodRef._def.defaultValue() }, generateSchema2(zodRef._def.innerType, useOutput, openApiVersion)), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseArray({ schemas, zodRef, useOutput, openApiVersion }) {
-      const constraints = {};
-      if (zodRef._def.exactLength != null) {
-        constraints.minItems = zodRef._def.exactLength.value;
-        constraints.maxItems = zodRef._def.exactLength.value;
-      }
-      if (zodRef._def.minLength != null)
-        constraints.minItems = zodRef._def.minLength.value;
-      if (zodRef._def.maxLength != null)
-        constraints.maxItems = zodRef._def.maxLength.value;
-      return (0, ts_deepmerge_1.default)(Object.assign({ type: typeFormat("array", openApiVersion), items: generateSchema2(zodRef.element, useOutput, openApiVersion) }, constraints), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseLiteral({ schemas, zodRef, openApiVersion }) {
-      const type3 = typeof zodRef._def.value;
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat(type3, openApiVersion),
-        enum: [zodRef._def.value]
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseEnum({ schemas, zodRef, openApiVersion }) {
-      const type3 = typeof Object.values(zodRef._def.values)[0];
-      return (0, ts_deepmerge_1.default)({
-        type: typeFormat(type3, openApiVersion),
-        enum: Object.values(zodRef._def.values)
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseIntersection({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        allOf: [
-          generateSchema2(zodRef._def.left, useOutput, openApiVersion),
-          generateSchema2(zodRef._def.right, useOutput, openApiVersion)
-        ]
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseUnion({ schemas, zodRef, useOutput, openApiVersion }) {
-      const contents = zodRef._def.options;
-      if (contents.reduce((prev, content) => prev && content._def.typeName === "ZodLiteral", true)) {
-        const literals = contents;
-        const type3 = literals.reduce((prev, content) => !prev || prev === typeof content._def.value ? typeof content._def.value : null, null);
-        if (type3) {
-          return (0, ts_deepmerge_1.default)({
-            type: typeFormat(type3, openApiVersion),
-            enum: literals.map((literal3) => literal3._def.value)
-          }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-        }
-      }
-      const oneOfContents = openApiVersion === "3.0" ? contents.filter((content) => content._def.typeName !== "ZodNull") : contents;
-      const contentsHasNull = contents.length != oneOfContents.length;
-      return (0, ts_deepmerge_1.default)({
-        oneOf: oneOfContents.map((schema) => generateSchema2(schema, useOutput, openApiVersion))
-      }, contentsHasNull ? { nullable: true } : {}, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseDiscriminatedUnion({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)({
-        discriminator: {
-          propertyName: zodRef._def.discriminator
-        },
-        oneOf: Array.from(zodRef._def.options.values()).map((schema) => generateSchema2(schema, useOutput, openApiVersion))
-      }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseNever({ zodRef, schemas }) {
-      return (0, ts_deepmerge_1.default)({ readOnly: true }, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parseBranded({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef._def.type, useOutput, openApiVersion), ...schemas);
-    }
-    function catchAllParser({ zodRef, schemas }) {
-      return (0, ts_deepmerge_1.default)(zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    function parsePipeline({ schemas, zodRef, useOutput, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(useOutput ? zodRef._def.out : zodRef._def.in, useOutput, openApiVersion), ...schemas);
-    }
-    function parseReadonly({ zodRef, useOutput, schemas, openApiVersion }) {
-      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef._def.innerType, useOutput, openApiVersion), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
-    }
-    var workerMap = {
-      ZodObject: parseObject,
-      ZodRecord: parseRecord,
-      ZodString: parseString,
-      ZodNumber: parseNumber,
-      ZodBigInt: parseBigInt,
-      ZodBoolean: parseBoolean,
-      ZodDate: parseDate,
-      ZodNull: parseNull,
-      ZodOptional: parseOptional,
-      ZodNullable: parseNullable,
-      ZodDefault: parseDefault,
-      ZodArray: parseArray,
-      ZodLiteral: parseLiteral,
-      ZodEnum: parseEnum,
-      ZodNativeEnum: parseEnum,
-      ZodTransformer: parseTransformation,
-      ZodEffects: parseTransformation,
-      ZodIntersection: parseIntersection,
-      ZodUnion: parseUnion,
-      ZodDiscriminatedUnion: parseDiscriminatedUnion,
-      ZodNever: parseNever,
-      ZodBranded: parseBranded,
-      // TODO Transform the rest to schemas
-      ZodUndefined: catchAllParser,
-      // TODO: `prefixItems` is allowed in OpenAPI 3.1 which can be used to create tuples
-      ZodTuple: catchAllParser,
-      ZodMap: catchAllParser,
-      ZodFunction: catchAllParser,
-      ZodLazy: catchAllParser,
-      ZodPromise: catchAllParser,
-      ZodAny: catchAllParser,
-      ZodUnknown: catchAllParser,
-      ZodVoid: catchAllParser,
-      ZodPipeline: parsePipeline,
-      ZodReadonly: parseReadonly
-    };
-    function generateSchema2(zodRef, useOutput = false, openApiVersion = "3.1") {
-      const { metaOpenApi = {} } = zodRef;
-      const schemas = [
-        ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
-      ];
-      try {
-        const typeName = zodRef._def.typeName;
-        if (typeName in workerMap) {
-          return workerMap[typeName]({
-            zodRef,
-            schemas,
-            useOutput,
-            openApiVersion
-          });
-        }
-        return catchAllParser({ zodRef, schemas, openApiVersion });
-      } catch (err) {
-        console.error(err);
-        return catchAllParser({ zodRef, schemas, openApiVersion });
-      }
-    }
-    exports2.generateSchema = generateSchema2;
-  }
-});
-
-// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-extensions.js
-var require_zod_extensions = __commonJS({
-  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/lib/zod-extensions.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.extendZodWithOpenApi = void 0;
-    var zod_openapi_1 = require_zod_openapi();
-    function extendZodWithOpenApi2(zod, forceOverride = false) {
-      if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
-        return;
-      }
-      zod.ZodSchema.prototype.openapi = function(metadata) {
-        return (0, zod_openapi_1.extendApi)(this, metadata);
-      };
-    }
-    exports2.extendZodWithOpenApi = extendZodWithOpenApi2;
-  }
-});
-
-// ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/index.js
-var require_src = __commonJS({
-  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.5.0_zod@3.25.76/node_modules/@anatine/zod-openapi/src/index.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    });
-    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar(require_zod_openapi(), exports2);
-    __exportStar(require_zod_extensions(), exports2);
-  }
-});
-
 // domain/schemas/index.ts
 var schemas_exports = {};
 __export(schemas_exports, {
@@ -465,7 +28,7 @@ module.exports = __toCommonJS(schemas_exports);
 // domain/schemas/redisWorker.schema.ts
 var import_internal = require("@forklaunch/internal");
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.5_openapi3-ts@4.5.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.8.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
 var typebox_exports = {};
 __export(typebox_exports, {
   SchemaValidator: () => SchemaValidator,
@@ -505,7 +68,7 @@ __export(typebox_exports, {
 });
 __reExport(typebox_exports, require("@sinclair/typebox"));
 
-// ../../../node_modules/.pnpm/@forklaunch+common@0.4.3/node_modules/@forklaunch/common/lib/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+common@0.4.6/node_modules/@forklaunch/common/lib/index.mjs
 var InMemoryBlob = class extends Blob {
   constructor(content) {
     super([Buffer.from(content)]);
@@ -513,7 +76,7 @@ var InMemoryBlob = class extends Blob {
   }
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.5_openapi3-ts@4.5.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.8.0/node_modules/@forklaunch/validator/lib/src/typebox/index.mjs
 var import_typebox = require("@sinclair/typebox");
 var import_compiler = require("@sinclair/typebox/compiler");
 var import_errors = require("@sinclair/typebox/errors");
@@ -747,12 +310,12 @@ var TypeboxSchemaValidator = class {
    * @returns {TResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
-      return schema;
-    }
     if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
       return import_typebox.Type.Literal(schema);
     }
+    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
+      return schema;
+    }
     const newSchema = {};
     Object.getOwnPropertyNames(schema).forEach((key) => {
       if (import_typebox.KindGuard.IsSchema(schema[key])) {
@@ -1020,10 +583,632 @@ var RedisWorkerOptionsSchema = {
   interval: number
 };
 
-// ../../../node_modules/.pnpm/@forklaunch+validator@0.7.5_openapi3-ts@4.5.0/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
-var import_zod_openapi = __toESM(require_src(), 1);
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.8.0/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
 var import_v3 = require("zod/v3");
-(0, import_zod_openapi.extendZodWithOpenApi)(import_v3.z);
+
+// ../../../node_modules/.pnpm/ts-deepmerge@7.0.3/node_modules/ts-deepmerge/esm/index.js
+var isObject = (obj) => {
+  if (typeof obj === "object" && obj !== null) {
+    if (typeof Object.getPrototypeOf === "function") {
+      const prototype = Object.getPrototypeOf(obj);
+      return prototype === Object.prototype || prototype === null;
+    }
+    return Object.prototype.toString.call(obj) === "[object Object]";
+  }
+  return false;
+};
+var merge = (...objects) => objects.reduce((result, current) => {
+  if (current === void 0) {
+    return result;
+  }
+  if (Array.isArray(current)) {
+    throw new TypeError("Arguments provided to ts-deepmerge must be objects, not arrays.");
+  }
+  Object.keys(current).forEach((key) => {
+    if (["__proto__", "constructor", "prototype"].includes(key)) {
+      return;
+    }
+    if (Array.isArray(result[key]) && Array.isArray(current[key])) {
+      result[key] = merge.options.mergeArrays ? merge.options.uniqueArrayItems ? Array.from(new Set(result[key].concat(current[key]))) : [...result[key], ...current[key]] : current[key];
+    } else if (isObject(result[key]) && isObject(current[key])) {
+      result[key] = merge(result[key], current[key]);
+    } else if (!isObject(result[key]) && isObject(current[key])) {
+      result[key] = merge(current[key], void 0);
+    } else {
+      result[key] = current[key] === void 0 ? merge.options.allowUndefinedOverrides ? current[key] : result[key] : current[key];
+    }
+  });
+  return result;
+}, {});
+var defaultOptions = {
+  allowUndefinedOverrides: true,
+  mergeArrays: true,
+  uniqueArrayItems: true
+};
+merge.options = defaultOptions;
+merge.withOptions = (options, ...objects) => {
+  merge.options = Object.assign(Object.assign({}, defaultOptions), options);
+  const result = merge(...objects);
+  merge.options = defaultOptions;
+  return result;
+};
+
+// ../../../node_modules/.pnpm/@forklaunch+validator@0.8.0/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
+var import_v32 = require("zod/v3");
+function extendApi(schema, schemaObject = {}) {
+  const This = schema.constructor;
+  const newSchema = new This(schema._def);
+  newSchema.metaOpenApi = Object.assign(
+    {},
+    schema.metaOpenApi || {},
+    schemaObject
+  );
+  return newSchema;
+}
+function iterateZodObject({
+  zodRef,
+  useOutput,
+  hideDefinitions,
+  openApiVersion
+}) {
+  const reduced = Object.keys(zodRef.shape).filter((key) => hideDefinitions?.includes(key) === false).reduce(
+    (carry, key) => ({
+      ...carry,
+      [key]: generateSchema(zodRef.shape[key], useOutput, openApiVersion)
+    }),
+    {}
+  );
+  return reduced;
+}
+function typeFormat(type22, openApiVersion) {
+  return openApiVersion === "3.0" ? type22 : [type22];
+}
+function parseTransformation({
+  zodRef,
+  schemas,
+  useOutput,
+  openApiVersion
+}) {
+  const input = generateSchema(zodRef._def.schema, useOutput, openApiVersion);
+  let output = "undefined";
+  if (useOutput && zodRef._def.effect) {
+    const effect = zodRef._def.effect.type === "transform" ? zodRef._def.effect : null;
+    if (effect && "transform" in effect) {
+      try {
+        const type22 = Array.isArray(input.type) ? input.type[0] : input.type;
+        output = typeof effect.transform(
+          ["integer", "number"].includes(`${type22}`) ? 0 : "string" === type22 ? "" : "boolean" === type22 ? false : "object" === type22 ? {} : "null" === type22 ? null : "array" === type22 ? [] : void 0,
+          { addIssue: () => void 0, path: [] }
+          // TODO: Discover if context is necessary here
+        );
+      } catch {
+      }
+    }
+  }
+  const outputType = output;
+  return merge(
+    {
+      ...zodRef.description ? { description: zodRef.description } : {},
+      ...input,
+      ...["number", "string", "boolean", "null"].includes(output) ? {
+        type: typeFormat(outputType, openApiVersion)
+      } : {}
+    },
+    ...schemas
+  );
+}
+function parseString({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  const baseSchema = {
+    type: typeFormat("string", openApiVersion)
+  };
+  const { checks = [] } = zodRef._def;
+  checks.forEach((item) => {
+    switch (item.kind) {
+      case "email":
+        baseSchema.format = "email";
+        break;
+      case "uuid":
+        baseSchema.format = "uuid";
+        break;
+      case "cuid":
+        baseSchema.format = "cuid";
+        break;
+      case "url":
+        baseSchema.format = "uri";
+        break;
+      case "datetime":
+        baseSchema.format = "date-time";
+        break;
+      case "length":
+        baseSchema.minLength = item.value;
+        baseSchema.maxLength = item.value;
+        break;
+      case "max":
+        baseSchema.maxLength = item.value;
+        break;
+      case "min":
+        baseSchema.minLength = item.value;
+        break;
+      case "regex":
+        baseSchema.pattern = item.regex.source;
+        break;
+    }
+  });
+  return merge(
+    baseSchema,
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNumber({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  const baseSchema = {
+    type: typeFormat("number", openApiVersion)
+  };
+  const { checks = [] } = zodRef._def;
+  checks.forEach((item) => {
+    switch (item.kind) {
+      case "max":
+        if (item.inclusive || openApiVersion === "3.0") {
+          baseSchema.maximum = item.value;
+        }
+        if (!item.inclusive) {
+          if (openApiVersion === "3.0") {
+            baseSchema.exclusiveMaximum = true;
+          } else {
+            baseSchema.exclusiveMaximum = item.value;
+          }
+        }
+        break;
+      case "min":
+        if (item.inclusive || openApiVersion === "3.0") {
+          baseSchema.minimum = item.value;
+        }
+        if (!item.inclusive) {
+          if (openApiVersion === "3.0") {
+            baseSchema.exclusiveMinimum = true;
+          } else {
+            baseSchema.exclusiveMinimum = item.value;
+          }
+        }
+        break;
+      case "int":
+        baseSchema.type = typeFormat("integer", openApiVersion);
+        break;
+      case "multipleOf":
+        baseSchema.multipleOf = item.value;
+        break;
+    }
+  });
+  return merge(
+    baseSchema,
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function getExcludedDefinitionsFromSchema(schemas) {
+  const excludedDefinitions = [];
+  for (const schema of schemas) {
+    if (Array.isArray(schema.hideDefinitions)) {
+      excludedDefinitions.push(...schema.hideDefinitions);
+    }
+  }
+  return excludedDefinitions;
+}
+function parseObject({
+  zodRef,
+  schemas,
+  useOutput,
+  hideDefinitions,
+  openApiVersion
+}) {
+  let additionalProperties;
+  if (!(zodRef._def.catchall instanceof import_v32.z.ZodNever || zodRef._def.catchall?._def.typeName === "ZodNever"))
+    additionalProperties = generateSchema(
+      zodRef._def.catchall,
+      useOutput,
+      openApiVersion
+    );
+  else if (zodRef._def.unknownKeys === "passthrough")
+    additionalProperties = true;
+  else if (zodRef._def.unknownKeys === "strict") additionalProperties = false;
+  additionalProperties = additionalProperties != null ? { additionalProperties } : {};
+  const requiredProperties = Object.keys(
+    zodRef.shape
+  ).filter((key) => {
+    const item = zodRef.shape[key];
+    return !(item.isOptional() || item instanceof import_v32.z.ZodDefault || item._def.typeName === "ZodDefault") && !(item instanceof import_v32.z.ZodNever || item._def.typeName === "ZodDefault");
+  });
+  const required = requiredProperties.length > 0 ? { required: requiredProperties } : {};
+  return merge(
+    {
+      type: typeFormat("object", openApiVersion),
+      properties: iterateZodObject({
+        zodRef,
+        schemas,
+        useOutput,
+        hideDefinitions: getExcludedDefinitionsFromSchema(schemas),
+        openApiVersion
+      }),
+      ...required,
+      ...additionalProperties,
+      ...hideDefinitions
+    },
+    zodRef.description ? { description: zodRef.description, hideDefinitions } : {},
+    ...schemas
+  );
+}
+function parseRecord({
+  zodRef,
+  schemas,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      type: typeFormat("object", openApiVersion),
+      additionalProperties: zodRef._def.valueType instanceof import_v32.z.ZodUnknown ? {} : generateSchema(zodRef._def.valueType, useOutput, openApiVersion)
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseBigInt({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    {
+      type: typeFormat("integer", openApiVersion),
+      format: "int64"
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseBoolean({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    { type: typeFormat("boolean", openApiVersion) },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseDate({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    {
+      type: typeFormat("string", openApiVersion),
+      format: "date-time"
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNull({
+  zodRef,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    openApiVersion === "3.0" ? { type: "null" } : {
+      type: ["string", "null"],
+      enum: ["null"]
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseOptional({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(zodRef.unwrap(), useOutput, openApiVersion),
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNullable({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  const schema = generateSchema(zodRef.unwrap(), useOutput, openApiVersion);
+  return merge(
+    schema,
+    openApiVersion === "3.0" ? { nullable: true } : { type: typeFormat("null", openApiVersion) },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseDefault({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      default: zodRef._def.defaultValue(),
+      ...generateSchema(zodRef._def.innerType, useOutput, openApiVersion)
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseArray({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  const constraints = {};
+  if (zodRef._def.exactLength != null) {
+    constraints.minItems = zodRef._def.exactLength.value;
+    constraints.maxItems = zodRef._def.exactLength.value;
+  }
+  if (zodRef._def.minLength != null)
+    constraints.minItems = zodRef._def.minLength.value;
+  if (zodRef._def.maxLength != null)
+    constraints.maxItems = zodRef._def.maxLength.value;
+  return merge(
+    {
+      type: typeFormat("array", openApiVersion),
+      items: generateSchema(zodRef.element, useOutput, openApiVersion),
+      ...constraints
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseLiteral({
+  schemas,
+  zodRef,
+  openApiVersion
+}) {
+  const type22 = typeof zodRef._def.value;
+  return merge(
+    {
+      type: typeFormat(type22, openApiVersion),
+      enum: [zodRef._def.value]
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseEnum({
+  schemas,
+  zodRef,
+  openApiVersion
+}) {
+  const type22 = typeof Object.values(zodRef._def.values)[0];
+  return merge(
+    {
+      type: typeFormat(type22, openApiVersion),
+      enum: Object.values(zodRef._def.values)
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseIntersection({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      allOf: [
+        generateSchema(zodRef._def.left, useOutput, openApiVersion),
+        generateSchema(zodRef._def.right, useOutput, openApiVersion)
+      ]
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseUnion({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  const contents = zodRef._def.options;
+  if (contents.reduce(
+    (prev, content) => prev && content._def.typeName === "ZodLiteral",
+    true
+  )) {
+    const literals = contents;
+    const type22 = literals.reduce(
+      (prev, content) => !prev || prev === typeof content._def.value ? typeof content._def.value : null,
+      null
+    );
+    if (type22) {
+      return merge(
+        {
+          type: typeFormat(type22, openApiVersion),
+          enum: literals.map((literal22) => literal22._def.value)
+        },
+        zodRef.description ? { description: zodRef.description } : {},
+        ...schemas
+      );
+    }
+  }
+  const oneOfContents = openApiVersion === "3.0" ? contents.filter((content) => content._def.typeName !== "ZodNull") : contents;
+  const contentsHasNull = contents.length != oneOfContents.length;
+  return merge(
+    {
+      oneOf: oneOfContents.map(
+        (schema) => generateSchema(schema, useOutput, openApiVersion)
+      )
+    },
+    contentsHasNull ? { nullable: true } : {},
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseDiscriminatedUnion({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    {
+      discriminator: {
+        propertyName: zodRef._def.discriminator
+      },
+      oneOf: Array.from(
+        zodRef._def.options.values()
+      ).map((schema) => generateSchema(schema, useOutput, openApiVersion))
+    },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseNever({
+  zodRef,
+  schemas
+}) {
+  return merge(
+    { readOnly: true },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parseBranded({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(zodRef._def.type, useOutput, openApiVersion),
+    ...schemas
+  );
+}
+function catchAllParser({
+  zodRef,
+  schemas
+}) {
+  return merge(
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+function parsePipeline({
+  schemas,
+  zodRef,
+  useOutput,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(
+      useOutput ? zodRef._def.out : zodRef._def.in,
+      useOutput,
+      openApiVersion
+    ),
+    ...schemas
+  );
+}
+function parseReadonly({
+  zodRef,
+  useOutput,
+  schemas,
+  openApiVersion
+}) {
+  return merge(
+    generateSchema(zodRef._def.innerType, useOutput, openApiVersion),
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+var workerMap = {
+  ZodObject: parseObject,
+  ZodRecord: parseRecord,
+  ZodString: parseString,
+  ZodNumber: parseNumber,
+  ZodBigInt: parseBigInt,
+  ZodBoolean: parseBoolean,
+  ZodDate: parseDate,
+  ZodNull: parseNull,
+  ZodOptional: parseOptional,
+  ZodNullable: parseNullable,
+  ZodDefault: parseDefault,
+  ZodArray: parseArray,
+  ZodLiteral: parseLiteral,
+  ZodEnum: parseEnum,
+  ZodNativeEnum: parseEnum,
+  ZodTransformer: parseTransformation,
+  ZodEffects: parseTransformation,
+  ZodIntersection: parseIntersection,
+  ZodUnion: parseUnion,
+  ZodDiscriminatedUnion: parseDiscriminatedUnion,
+  ZodNever: parseNever,
+  ZodBranded: parseBranded,
+  // TODO Transform the rest to schemas
+  ZodUndefined: catchAllParser,
+  // TODO: `prefixItems` is allowed in OpenAPI 3.1 which can be used to create tuples
+  ZodTuple: catchAllParser,
+  ZodMap: catchAllParser,
+  ZodFunction: catchAllParser,
+  ZodLazy: catchAllParser,
+  ZodPromise: catchAllParser,
+  ZodAny: catchAllParser,
+  ZodUnknown: catchAllParser,
+  ZodVoid: catchAllParser,
+  ZodPipeline: parsePipeline,
+  ZodReadonly: parseReadonly
+};
+function generateSchema(zodRef, useOutput = false, openApiVersion = "3.1") {
+  const { metaOpenApi = {} } = zodRef;
+  const schemas = [
+    ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
+  ];
+  try {
+    const typeName = zodRef._def.typeName;
+    if (typeName in workerMap) {
+      return workerMap[typeName]({
+        zodRef,
+        schemas,
+        useOutput,
+        openApiVersion
+      });
+    }
+    return catchAllParser({ zodRef, schemas, openApiVersion });
+  } catch (err) {
+    console.error(err);
+    return catchAllParser({ zodRef, schemas, openApiVersion });
+  }
+}
+function extendZodWithOpenApi(zod, forceOverride = false) {
+  if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodSchema.prototype.openapi = function(metadata) {
+    return extendApi(this, metadata);
+  };
+}
+extendZodWithOpenApi(import_v3.z);
 var ZodSchemaValidator = class {
   _Type = "Zod";
   _SchemaCatchall;
@@ -1343,7 +1528,7 @@ var ZodSchemaValidator = class {
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {
-    return (0, import_zod_openapi.generateSchema)(this.schemify(schema));
+    return generateSchema(this.schemify(schema));
   }
 };
 var SchemaValidator2 = () => new ZodSchemaValidator();