@forklaunch/implementation-worker-redis 0.3.3 → 0.3.4

package/lib/domain/schemas/index.js

@@ -1,96 +1,68 @@
-'use strict';
+"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 __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 });
 };
 var __copyProps = (to, from, except, desc) => {
-  if ((from && typeof from === 'object') || typeof from === 'function') {
+  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
-        });
+        __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
-  )
-);
-var __toCommonJS = (mod) =>
-  __copyProps(__defProp({}, '__esModule', { value: true }), mod);
+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 });
+  "../../../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') {
+      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 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.'
-          );
+    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;
         }
-        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;
-      }, {});
+        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,
@@ -109,200 +81,127 @@ var require_cjs = __commonJS({
 
 // ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/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.4.0_zod@3.25.67/node_modules/@anatine/zod-openapi/src/lib/zod-openapi.js'(
-    exports2
-  ) {
-    'use strict';
-    Object.defineProperty(exports2, '__esModule', { value: true });
+  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/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');
+    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
-      );
+      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
-              )
-            }),
-          {}
-        );
+    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];
+      return openApiVersion === "3.0" ? type3 : [type3];
     }
-    function parseTransformation({
-      zodRef,
-      schemas,
-      useOutput,
-      openApiVersion
-    }) {
-      const input = generateSchema2(
-        zodRef._def.schema,
-        useOutput,
-        openApiVersion
-      );
-      let output = 'undefined';
+    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) {
+        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;
+            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,
+              ["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) {}
+          } 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
-      );
+      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)
+        type: typeFormat("string", openApiVersion)
       };
       const { checks = [] } = zodRef._def;
       checks.forEach((item) => {
         switch (item.kind) {
-          case 'email':
-            baseSchema.format = 'email';
+          case "email":
+            baseSchema.format = "email";
             break;
-          case 'uuid':
-            baseSchema.format = 'uuid';
+          case "uuid":
+            baseSchema.format = "uuid";
             break;
-          case 'cuid':
-            baseSchema.format = 'cuid';
+          case "cuid":
+            baseSchema.format = "cuid";
             break;
-          case 'url':
-            baseSchema.format = 'uri';
+          case "url":
+            baseSchema.format = "uri";
             break;
-          case 'datetime':
-            baseSchema.format = 'date-time';
+          case "datetime":
+            baseSchema.format = "date-time";
             break;
-          case 'length':
+          case "length":
             baseSchema.minLength = item.value;
             baseSchema.maxLength = item.value;
             break;
-          case 'max':
+          case "max":
             baseSchema.maxLength = item.value;
             break;
-          case 'min':
+          case "min":
             baseSchema.minLength = item.value;
             break;
-          case 'regex':
+          case "regex":
             baseSchema.pattern = item.regex.source;
             break;
         }
       });
-      return (0, ts_deepmerge_1.default)(
-        baseSchema,
-        zodRef.description ? { description: zodRef.description } : {},
-        ...schemas
-      );
+      return (0, ts_deepmerge_1.default)(baseSchema, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
     }
     function parseNumber({ zodRef, schemas, openApiVersion }) {
       const baseSchema = {
-        type: typeFormat('number', openApiVersion)
+        type: typeFormat("number", openApiVersion)
       };
       const { checks = [] } = zodRef._def;
       checks.forEach((item) => {
         switch (item.kind) {
-          case 'max':
-            if (item.inclusive || openApiVersion === '3.0') {
+          case "max":
+            if (item.inclusive || openApiVersion === "3.0") {
               baseSchema.maximum = item.value;
             }
             if (!item.inclusive) {
-              if (openApiVersion === '3.0') {
+              if (openApiVersion === "3.0") {
                 baseSchema.exclusiveMaximum = true;
               } else {
                 baseSchema.exclusiveMaximum = item.value;
               }
             }
             break;
-          case 'min':
-            if (item.inclusive || openApiVersion === '3.0') {
+          case "min":
+            if (item.inclusive || openApiVersion === "3.0") {
               baseSchema.minimum = item.value;
             }
             if (!item.inclusive) {
-              if (openApiVersion === '3.0') {
+              if (openApiVersion === "3.0") {
                 baseSchema.exclusiveMinimum = true;
               } else {
                 baseSchema.exclusiveMinimum = item.value;
               }
             }
             break;
-          case 'int':
-            baseSchema.type = typeFormat('integer', openApiVersion);
+          case "int":
+            baseSchema.type = typeFormat("integer", openApiVersion);
             break;
-          case 'multipleOf':
+          case "multipleOf":
             baseSchema.multipleOf = item.value;
             break;
         }
       });
-      return (0, ts_deepmerge_1.default)(
-        baseSchema,
-        zodRef.description ? { description: zodRef.description } : {},
-        ...schemas
-      );
+      return (0, ts_deepmerge_1.default)(baseSchema, zodRef.description ? { description: zodRef.description } : {}, ...schemas);
     }
     function getExcludedDefinitionsFromSchema(schemas) {
       const excludedDefinitions = [];
@@ -313,163 +212,65 @@ var require_zod_openapi = __commonJS({
       }
       return excludedDefinitions;
     }
-    function parseObject({
-      zodRef,
-      schemas,
-      useOutput,
-      hideDefinitions,
-      openApiVersion
-    }) {
+    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')
+      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')
+      else if (zodRef._def.unknownKeys === "strict")
         additionalProperties = false;
-      additionalProperties =
-        additionalProperties != null ? { additionalProperties } : {};
+      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'
-          )
-        );
+        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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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 = {};
@@ -481,149 +282,70 @@ var require_zod_openapi = __commonJS({
         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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-        )
-      ) {
+      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
-        );
+        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
-          );
+          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 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
-      );
+      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)
-          )
+    function parseDiscriminatedUnion({ schemas, zodRef, useOutput, openApiVersion }) {
+      return (0, ts_deepmerge_1.default)({
+        discriminator: {
+          propertyName: zodRef._def.discriminator
         },
-        zodRef.description ? { description: zodRef.description } : {},
-        ...schemas
-      );
+        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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      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
-      );
+      return (0, ts_deepmerge_1.default)(generateSchema2(zodRef._def.innerType, useOutput, openApiVersion), zodRef.description ? { description: zodRef.description } : {}, ...schemas);
     }
     var workerMap = {
       ZodObject: parseObject,
@@ -662,14 +384,10 @@ var require_zod_openapi = __commonJS({
       ZodPipeline: parsePipeline,
       ZodReadonly: parseReadonly
     };
-    function generateSchema2(
-      zodRef,
-      useOutput = false,
-      openApiVersion = '3.1'
-    ) {
+    function generateSchema2(zodRef, useOutput = false, openApiVersion = "3.1") {
       const { metaOpenApi = {} } = zodRef;
       const schemas = [
-        ...(Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi])
+        ...Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]
       ];
       try {
         const typeName = zodRef._def.typeName;
@@ -693,21 +411,16 @@ var require_zod_openapi = __commonJS({
 
 // ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/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.4.0_zod@3.25.67/node_modules/@anatine/zod-openapi/src/lib/zod-extensions.js'(
-    exports2
-  ) {
-    'use strict';
-    Object.defineProperty(exports2, '__esModule', { value: true });
+  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/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'
-      ) {
+      if (!forceOverride && typeof zod.ZodSchema.prototype.openapi !== "undefined") {
         return;
       }
-      zod.ZodSchema.prototype.openapi = function (metadata) {
+      zod.ZodSchema.prototype.openapi = function(metadata) {
         return (0, zod_openapi_1.extendApi)(this, metadata);
       };
     }
@@ -717,46 +430,25 @@ var require_zod_extensions = __commonJS({
 
 // ../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/node_modules/@anatine/zod-openapi/src/index.js
 var require_src = __commonJS({
-  '../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/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 });
+  "../../../node_modules/.pnpm/@anatine+zod-openapi@2.2.8_openapi3-ts@4.4.0_zod@3.25.67/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);
   }
@@ -770,11 +462,15 @@ __export(schemas_exports, {
 module.exports = __toCommonJS(schemas_exports);
 
 // domain/schemas/redisWorker.schema.ts
-var import_internal = require('@forklaunch/internal');
+var import_internal = require("@forklaunch/internal");
 
 // ../../../node_modules/.pnpm/@forklaunch+common@0.3.14/node_modules/@forklaunch/common/lib/index.mjs
 var InMemoryFile = class extends File {
-  constructor(content, name, { type: type3, endings, lastModified }) {
+  constructor(content, name, {
+    type: type3,
+    endings,
+    lastModified
+  }) {
     super([Buffer.from(content)], name, {
       type: type3,
       endings,
@@ -785,235 +481,211 @@ var InMemoryFile = class extends File {
 };
 
 // ../../../node_modules/.pnpm/@forklaunch+validator@0.6.16_openapi3-ts@4.4.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');
-var import_value = require('@sinclair/typebox/value');
-import_typebox.FormatRegistry.Set(
-  'binary',
-  (value) => typeof value === 'string'
-);
+var import_typebox = require("@sinclair/typebox");
+var import_compiler = require("@sinclair/typebox/compiler");
+var import_errors = require("@sinclair/typebox/errors");
+var import_value = require("@sinclair/typebox/value");
+import_typebox.FormatRegistry.Set("binary", (value) => typeof value === "string");
 (0, import_errors.SetErrorFunction)((params) => {
   switch (params.errorType) {
     case import_errors.ValueErrorType.Union:
     case import_errors.ValueErrorType.Array:
     case import_errors.ValueErrorType.String:
     case import_errors.ValueErrorType.Number:
-      return params.schema.errorType
-        ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? 's' : ''}`
-        : (0, import_errors.DefaultErrorFunction)(params);
+      return params.schema.errorType ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? "s" : ""}` : (0, import_errors.DefaultErrorFunction)(params);
     default:
       return (0, import_errors.DefaultErrorFunction)(params);
   }
 });
 var TypeboxSchemaValidator = class {
-  _Type = 'TypeBox';
+  _Type = "TypeBox";
   _SchemaCatchall;
   _ValidSchemaObject;
   string = import_typebox.Type.String({
-    example: 'a string',
-    title: 'String'
+    example: "a string",
+    title: "String"
   });
   uuid = import_typebox.Type.String({
-    pattern:
-      '^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$',
-    errorType: 'uuid',
-    example: 'a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6',
-    title: 'UUID'
+    pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$",
+    errorType: "uuid",
+    example: "a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6",
+    title: "UUID"
   });
   email = import_typebox.Type.String({
     pattern: `(?:[a-z0-9!#$%&'*+/=?^_{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])`,
-    errorType: 'email',
-    example: 'a@b.com',
-    title: 'Email'
+    errorType: "email",
+    example: "a@b.com",
+    title: "Email"
   });
   uri = import_typebox.Type.String({
-    pattern: '^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$',
-    errorType: 'uri',
-    example: 'https://forklaunch.com',
-    title: 'URI'
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    errorType: "uri",
+    example: "https://forklaunch.com",
+    title: "URI"
   });
   number = import_typebox.Type.Transform(
     import_typebox.Type.Union(
       [
         import_typebox.Type.Number(),
-        import_typebox.Type.String({ pattern: '^[0-9]+$' }),
+        import_typebox.Type.String({ pattern: "^[0-9]+$" }),
         import_typebox.Type.Boolean(),
         import_typebox.Type.Null(),
         import_typebox.Type.BigInt(),
         import_typebox.Type.Date()
       ],
       {
-        errorType: 'number-like',
+        errorType: "number-like",
         example: 123,
-        title: 'Number'
+        title: "Number"
       }
     )
-  )
-    .Decode((value) => {
-      if (typeof value !== 'number') {
-        const num = Number(value);
-        if (isNaN(num)) {
-          throw new Error('Invalid number');
-        } else {
-          return num;
-        }
+  ).Decode((value) => {
+    if (typeof value !== "number") {
+      const num = Number(value);
+      if (isNaN(num)) {
+        throw new Error("Invalid number");
+      } else {
+        return num;
       }
-      return value;
-    })
-    .Encode(Number);
+    }
+    return value;
+  }).Encode(Number);
   bigint = import_typebox.Type.Transform(
     import_typebox.Type.Union(
       [
         import_typebox.Type.BigInt(),
         import_typebox.Type.Number(),
-        import_typebox.Type.String({ pattern: '^[0-9]+n?$' }),
+        import_typebox.Type.String({ pattern: "^[0-9]+n?$" }),
         import_typebox.Type.Boolean(),
         import_typebox.Type.Date()
       ],
       {
-        errorType: 'BigInt-like',
+        errorType: "BigInt-like",
         example: 123n,
-        title: 'BigInt'
+        title: "BigInt"
       }
     )
-  )
-    .Decode((value) => {
-      if (typeof value !== 'bigint') {
-        try {
-          if (value instanceof Date) {
-            return BigInt(value.getTime());
-          }
-          return BigInt(value);
-        } catch {
-          throw new Error('Invalid bigint');
+  ).Decode((value) => {
+    if (typeof value !== "bigint") {
+      try {
+        if (value instanceof Date) {
+          return BigInt(value.getTime());
         }
+        return BigInt(value);
+      } catch {
+        throw new Error("Invalid bigint");
       }
-      return value;
-    })
-    .Encode(BigInt);
+    }
+    return value;
+  }).Encode(BigInt);
   boolean = import_typebox.Type.Transform(
     import_typebox.Type.Union(
       [
         import_typebox.Type.Boolean(),
         import_typebox.Type.String({
-          pattern: '^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$'
+          pattern: "^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$"
         })
       ],
       {
-        errorType: 'boolean-like',
+        errorType: "boolean-like",
         example: true,
-        title: 'Boolean'
+        title: "Boolean"
       }
     )
-  )
-    .Decode((value) => {
-      if (typeof value === 'string') {
-        if (value.toLowerCase() === 'true') return true;
-        return false;
-      } else {
-        return value;
-      }
-    })
-    .Encode(Boolean);
+  ).Decode((value) => {
+    if (typeof value === "string") {
+      if (value.toLowerCase() === "true") return true;
+      return false;
+    } else {
+      return value;
+    }
+  }).Encode(Boolean);
   date = import_typebox.Type.Transform(
     import_typebox.Type.Union(
       [
         import_typebox.Type.String({
-          pattern:
-            '^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$'
+          pattern: "^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$"
         }),
         import_typebox.Type.Number(),
         import_typebox.Type.Date()
       ],
       {
-        errorType: 'date',
-        example: '2025-05-16T21:13:04.123Z',
-        title: 'Date'
+        errorType: "date",
+        example: "2025-05-16T21:13:04.123Z",
+        title: "Date"
       }
     )
-  )
-    .Decode((value) => {
-      if (value === null || typeof value === 'boolean') {
-        return /* @__PURE__ */ new Date(value ? 1 : 0);
-      }
-      return new Date(value);
-    })
-    .Encode((value) => new Date(value).toISOString());
+  ).Decode((value) => {
+    if (value === null || typeof value === "boolean") {
+      return /* @__PURE__ */ new Date(value ? 1 : 0);
+    }
+    return new Date(value);
+  }).Encode((value) => new Date(value).toISOString());
   symbol = import_typebox.Type.Symbol({
-    title: 'Symbol'
+    title: "Symbol"
   });
   nullish = import_typebox.Type.Union(
-    [
-      import_typebox.Type.Void(),
-      import_typebox.Type.Null(),
-      import_typebox.Type.Undefined()
-    ],
+    [import_typebox.Type.Void(), import_typebox.Type.Null(), import_typebox.Type.Undefined()],
     {
-      errorType: 'nullish',
-      type: 'null',
-      example: 'null',
-      title: 'Nullish'
+      errorType: "nullish",
+      type: "null",
+      example: "null",
+      title: "Nullish"
     }
   );
   void = import_typebox.Type.Void({
-    type: 'null',
-    example: 'void',
-    title: 'Void'
+    type: "null",
+    example: "void",
+    title: "Void"
   });
   null = import_typebox.Type.Null({
-    type: 'null',
-    example: 'null',
-    title: 'Null'
+    type: "null",
+    example: "null",
+    title: "Null"
   });
   undefined = import_typebox.Type.Undefined({
-    type: 'null',
-    example: 'undefined',
-    title: 'Undefined'
+    type: "null",
+    example: "undefined",
+    title: "Undefined"
   });
   any = import_typebox.Type.Any({
-    type: 'object',
-    example: 'any',
-    title: 'Any'
+    type: "object",
+    example: "any",
+    title: "Any"
   });
   unknown = import_typebox.Type.Unknown({
-    type: 'object',
-    example: 'unknown',
-    title: 'Unknown'
+    type: "object",
+    example: "unknown",
+    title: "Unknown"
   });
   never = import_typebox.Type.Never({
-    type: 'null',
-    example: 'never',
-    title: 'Never'
+    type: "null",
+    example: "never",
+    title: "Never"
   });
   binary = import_typebox.Type.Transform(
     import_typebox.Type.String({
-      errorType: 'binary',
-      format: 'binary',
-      example: 'a utf-8 encodable string',
-      title: 'Binary'
+      errorType: "binary",
+      format: "binary",
+      example: "a utf-8 encodable string",
+      title: "Binary"
     })
-  )
-    .Decode((value) => new TextEncoder().encode(value))
-    .Encode((value) => {
-      if (value instanceof ArrayBuffer) {
-        return String.fromCharCode(...new Uint8Array(value));
-      }
-      return '';
-    });
+  ).Decode((value) => new TextEncoder().encode(value)).Encode((value) => {
+    if (value instanceof ArrayBuffer) {
+      return String.fromCharCode(...new Uint8Array(value));
+    }
+    return "";
+  });
   file = import_typebox.Type.Transform(
     import_typebox.Type.String({
-      errorType: 'binary',
-      format: 'binary',
-      example: 'a utf-8 encodable string',
-      title: 'File'
+      errorType: "binary",
+      format: "binary",
+      example: "a utf-8 encodable string",
+      title: "File"
     })
-  )
-    .Decode(
-      (value) => (name, type22) =>
-        new InMemoryFile(value, name, { type: type22 })
-    )
-    .Encode((value) => value('name', 'type').content);
+  ).Decode(
+    (value) => (name, type22) => new InMemoryFile(value, name, { type: type22 })
+  ).Encode((value) => value("name", "type").content);
   type = () => this.any;
   /**
    * Extracts the error type of a schema for error messages.
@@ -1022,10 +694,7 @@ var TypeboxSchemaValidator = class {
    * @returns The type of the schema for error messages.
    */
   errorType(schema) {
-    if (
-      import_typebox.KindGuard.IsSchema(schema) &&
-      Object.hasOwn(schema, 'errorType')
-    ) {
+    if (import_typebox.KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
       return schema.errorType;
     } else if (import_typebox.KindGuard.IsLiteral(schema)) {
       return schema.const;
@@ -1047,17 +716,10 @@ var TypeboxSchemaValidator = class {
    * @returns {TResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (
-      import_typebox.KindGuard.IsSchema(schema) ||
-      schema instanceof import_compiler.TypeCheck
-    ) {
+    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
       return schema;
     }
-    if (
-      typeof schema === 'string' ||
-      typeof schema === 'number' ||
-      typeof schema === 'boolean'
-    ) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
       return import_typebox.Type.Literal(schema);
     }
     const newSchema = {};
@@ -1104,7 +766,7 @@ var TypeboxSchemaValidator = class {
       return this.schemify(schema);
     });
     return import_typebox.Type.Union(unionTypes, {
-      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(', ')}`,
+      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
       errorSuffix: true
     });
   }
@@ -1175,12 +837,7 @@ var TypeboxSchemaValidator = class {
    * @returns {boolean} True if the value is an instance of the schema.
    */
   isInstanceOf(value, type22) {
-    return (
-      typeof value === 'object' &&
-      value != null &&
-      import_typebox.Kind in value &&
-      value[import_typebox.Kind] === type22[import_typebox.Kind]
-    );
+    return typeof value === "object" && value != null && import_typebox.Kind in value && value[import_typebox.Kind] === type22[import_typebox.Kind];
   }
   /**
    * Validate a value against a schema.
@@ -1221,38 +878,33 @@ var TypeboxSchemaValidator = class {
         errors = Array.from(import_value.Value.Errors(schemified, value));
       }
     }
-    return errors != null && errors.length === 0
-      ? {
-          ok: true,
-          value: conversion
-        }
-      : {
-          ok: false,
-          errors: errors.flatMap((error) => {
-            if (
-              error.type === import_errors.ValueErrorType.Union &&
-              error.schema.errorType.includes('any of')
-            ) {
-              return error.errors.flatMap((e, idx) =>
-                Array.from(e).map((e2) => ({
-                  path: [
-                    `Union Schema Variant ${idx}`,
-                    ...error.path.split('/').slice(1),
-                    ...e2.path.split('/').slice(1)
-                  ],
-                  message: e2.message
-                }))
-              );
-            } else {
-              return [
-                {
-                  path: error.path.split('/').slice(1),
-                  message: error.message
-                }
-              ];
+    return errors != null && errors.length === 0 ? {
+      ok: true,
+      value: conversion
+    } : {
+      ok: false,
+      errors: errors.flatMap((error) => {
+        if (error.type === import_errors.ValueErrorType.Union && error.schema.errorType.includes("any of")) {
+          return error.errors.flatMap(
+            (e, idx) => Array.from(e).map((e2) => ({
+              path: [
+                `Union Schema Variant ${idx}`,
+                ...error.path.split("/").slice(1),
+                ...e2.path.split("/").slice(1)
+              ],
+              message: e2.message
+            }))
+          );
+        } else {
+          return [
+            {
+              path: error.path.split("/").slice(1),
+              message: error.message
             }
-          })
-        };
+          ];
+        }
+      })
+    };
   }
   /**
    * Convert a schema to an OpenAPI schema object.
@@ -1263,33 +915,34 @@ var TypeboxSchemaValidator = class {
     let schemified = this.schemify(schema);
     if (import_typebox.KindGuard.IsDate(schemified)) {
       schemified = import_typebox.Type.String({
-        format: 'date-time'
+        format: "date-time"
       });
     }
     const newSchema = Object.assign({}, schemified);
-    if (Object.hasOwn(newSchema, 'properties')) {
+    if (Object.hasOwn(newSchema, "properties")) {
       if (newSchema.properties) {
         Object.entries({ ...schemified.properties }).forEach(([key, value]) => {
-          if (
-            import_typebox.KindGuard.IsSchema(value) &&
-            newSchema.properties
-          ) {
+          if (import_typebox.KindGuard.IsSchema(value) && newSchema.properties) {
             newSchema.properties[key] = this.openapi(value);
           }
         });
       }
     }
-    if (Object.hasOwn(newSchema, 'items')) {
+    if (Object.hasOwn(newSchema, "items")) {
       newSchema.items = this.openapi(newSchema.items);
     }
     if (Array.isArray(newSchema.anyOf)) {
-      newSchema.anyOf = newSchema.anyOf.map((item) => this.openapi(item));
+      newSchema.anyOf = newSchema.anyOf.map(
+        (item) => this.openapi(item)
+      );
     }
     if (Array.isArray(newSchema.oneOf)) {
-      newSchema.oneOf = newSchema.oneOf.map((item) => this.openapi(item));
+      newSchema.oneOf = newSchema.oneOf.map(
+        (item) => this.openapi(item)
+      );
     }
-    if ('errorType' in newSchema) {
-      delete newSchema['errorType'];
+    if ("errorType" in newSchema) {
+      delete newSchema["errorType"];
     }
     return newSchema;
   }
@@ -1338,170 +991,152 @@ var RedisWorkerOptionsSchema = {
 
 // ../../../node_modules/.pnpm/@forklaunch+validator@0.6.16_openapi3-ts@4.4.0/node_modules/@forklaunch/validator/lib/src/zod/index.mjs
 var import_zod_openapi = __toESM(require_src(), 1);
-var import_zod = require('zod');
+var import_zod = require("zod");
 (0, import_zod_openapi.extendZodWithOpenApi)(import_zod.z);
 var ZodSchemaValidator = class {
-  _Type = 'Zod';
+  _Type = "Zod";
   _SchemaCatchall;
   _ValidSchemaObject;
   string = import_zod.z.string().openapi({
-    title: 'String',
-    example: 'a string'
+    title: "String",
+    example: "a string"
   });
   uuid = import_zod.z.string().uuid().openapi({
-    title: 'UUID',
-    format: 'uuid',
-    pattern:
-      '^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$',
-    example: 'a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6'
+    title: "UUID",
+    format: "uuid",
+    pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$",
+    example: "a8b2c3d4-e5f6-g7h8-i9j0-k1l2m3n4o5p6"
   });
   email = import_zod.z.string().email().openapi({
-    title: 'Email',
-    format: 'email',
+    title: "Email",
+    format: "email",
     pattern: `(?:[a-z0-9!#$%&'*+/=?^_{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])`,
-    example: 'a@b.com'
+    example: "a@b.com"
   });
   uri = import_zod.z.string().url().openapi({
-    title: 'URI',
-    format: 'uri',
-    pattern: '^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$',
-    example: 'https://forklaunch.com'
+    title: "URI",
+    format: "uri",
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    example: "https://forklaunch.com"
   });
-  number = import_zod.z
-    .preprocess((value) => {
-      try {
-        return Number(value);
-      } catch {
-        return value;
-      }
-    }, import_zod.z.number())
-    .openapi({
-      title: 'Number',
-      example: 123
-    });
-  bigint = import_zod.z
-    .preprocess((value) => {
-      try {
-        if (value instanceof Date) {
-          return BigInt(value.getTime());
-        }
-        switch (typeof value) {
-          case 'number':
-          case 'string':
-            return BigInt(value);
-          case 'boolean':
-            return BigInt(value ? 1 : 0);
-          default:
-            return value;
-        }
-      } catch {
-        return value;
+  number = import_zod.z.preprocess((value) => {
+    try {
+      return Number(value);
+    } catch {
+      return value;
+    }
+  }, import_zod.z.number()).openapi({
+    title: "Number",
+    example: 123
+  });
+  bigint = import_zod.z.preprocess((value) => {
+    try {
+      if (value instanceof Date) {
+        return BigInt(value.getTime());
       }
-    }, import_zod.z.bigint())
-    .openapi({
-      title: 'BigInt',
-      type: 'integer',
-      format: 'int64',
-      example: 123n
-    });
-  boolean = import_zod.z
-    .preprocess((val) => {
-      if (typeof val === 'string') {
-        if (val.toLowerCase() === 'true') return true;
-        if (val.toLowerCase() === 'false') return false;
+      switch (typeof value) {
+        case "number":
+        case "string":
+          return BigInt(value);
+        case "boolean":
+          return BigInt(value ? 1 : 0);
+        default:
+          return value;
       }
-      return val;
-    }, import_zod.z.boolean())
-    .openapi({
-      title: 'Boolean',
-      example: true
-    });
-  date = import_zod.z
-    .preprocess((value) => {
-      try {
-        switch (typeof value) {
-          case 'string':
-            return new Date(value);
-          case 'number':
-            return new Date(value);
-          default:
-            return value;
-        }
-      } catch {
-        return value;
+    } catch {
+      return value;
+    }
+  }, import_zod.z.bigint()).openapi({
+    title: "BigInt",
+    type: "integer",
+    format: "int64",
+    example: 123n
+  });
+  boolean = import_zod.z.preprocess((val) => {
+    if (typeof val === "string") {
+      if (val.toLowerCase() === "true") return true;
+      if (val.toLowerCase() === "false") return false;
+    }
+    return val;
+  }, import_zod.z.boolean()).openapi({
+    title: "Boolean",
+    example: true
+  });
+  date = import_zod.z.preprocess((value) => {
+    try {
+      switch (typeof value) {
+        case "string":
+          return new Date(value);
+        case "number":
+          return new Date(value);
+        default:
+          return value;
       }
-    }, import_zod.z.date())
-    .openapi({
-      title: 'Date',
-      type: 'string',
-      format: 'date-time',
-      example: '2025-05-16T21:13:04.123Z'
-    });
+    } catch {
+      return value;
+    }
+  }, import_zod.z.date()).openapi({
+    title: "Date",
+    type: "string",
+    format: "date-time",
+    example: "2025-05-16T21:13:04.123Z"
+  });
   symbol = import_zod.z.symbol().openapi({
-    title: 'Symbol',
-    example: Symbol('symbol')
+    title: "Symbol",
+    example: Symbol("symbol")
+  });
+  nullish = import_zod.z.union([import_zod.z.void(), import_zod.z.null(), import_zod.z.undefined()]).openapi({
+    title: "Nullish",
+    type: "null",
+    example: null
   });
-  nullish = import_zod.z
-    .union([import_zod.z.void(), import_zod.z.null(), import_zod.z.undefined()])
-    .openapi({
-      title: 'Nullish',
-      type: 'null',
-      example: null
-    });
   void = import_zod.z.void().openapi({
-    title: 'Void',
-    type: 'null',
+    title: "Void",
+    type: "null",
     example: void 0
   });
   null = import_zod.z.null().openapi({
-    title: 'Null',
-    type: 'null',
+    title: "Null",
+    type: "null",
     example: null
   });
   undefined = import_zod.z.undefined().openapi({
-    title: 'Undefined',
-    type: 'null',
+    title: "Undefined",
+    type: "null",
     example: void 0
   });
   any = import_zod.z.any().openapi({
-    title: 'Any',
-    type: 'object',
-    example: 'any'
+    title: "Any",
+    type: "object",
+    example: "any"
   });
   unknown = import_zod.z.unknown().openapi({
-    title: 'Unknown',
-    type: 'object',
-    example: 'unknown'
+    title: "Unknown",
+    type: "object",
+    example: "unknown"
   });
   never = import_zod.z.never().openapi({
-    title: 'Never',
-    type: 'null',
-    example: 'never'
+    title: "Never",
+    type: "null",
+    example: "never"
   });
-  binary = import_zod.z
-    .string()
-    .transform((v) => new TextEncoder().encode(v))
-    .openapi({
-      title: 'Binary',
-      type: 'string',
-      format: 'binary',
-      example: 'a utf-8 encodable string'
-    });
-  file = import_zod.z
-    .string()
-    .transform((val) => {
-      return (name, type22) =>
-        new File([val], name, {
-          type: type22,
-          lastModified: Date.now()
-        });
-    })
-    .openapi({
-      title: 'File',
-      type: 'string',
-      format: 'binary',
-      example: 'a utf-8 encodable string'
+  binary = import_zod.z.string().transform((v) => new TextEncoder().encode(v)).openapi({
+    title: "Binary",
+    type: "string",
+    format: "binary",
+    example: "a utf-8 encodable string"
+  });
+  file = import_zod.z.string().transform((val) => {
+    return (name, type22) => new File([val], name, {
+      type: type22,
+      lastModified: Date.now()
     });
+  }).openapi({
+    title: "File",
+    type: "string",
+    format: "binary",
+    example: "a utf-8 encodable string"
+  });
   type = () => this.any;
   /**
    * Compiles schema if this exists, for optimal performance.
@@ -1518,11 +1153,7 @@ var ZodSchemaValidator = class {
    * @returns {ZodResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (
-      typeof schema === 'string' ||
-      typeof schema === 'number' ||
-      typeof schema === 'boolean'
-    ) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
       return import_zod.z.literal(schema);
     }
     if (schema instanceof import_zod.ZodType) {
@@ -1563,7 +1194,9 @@ var ZodSchemaValidator = class {
    */
   union(schemas) {
     const resolvedSchemas = schemas.map((schema) => this.schemify(schema));
-    return import_zod.z.union(resolvedSchemas);
+    return import_zod.z.union(
+      resolvedSchemas
+    );
   }
   /**
    * Create a literal schema.
@@ -1579,7 +1212,9 @@ var ZodSchemaValidator = class {
    * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
    */
   enum_(schemaEnum) {
-    return this.union(Object.values(schemaEnum));
+    return this.union(
+      Object.values(schemaEnum)
+    );
   }
   /**
    * Create a function schema.
@@ -1590,10 +1225,7 @@ var ZodSchemaValidator = class {
   function_(args, returnType) {
     const schemaArgs = args.map((schema) => this.schemify(schema));
     const schemaReturnType = this.schemify(returnType);
-    return import_zod.z.function(
-      import_zod.z.tuple(schemaArgs),
-      schemaReturnType
-    );
+    return import_zod.z.function(import_zod.z.tuple(schemaArgs), schemaReturnType);
   }
   /**
    * Create a record schema.
@@ -1651,33 +1283,31 @@ var ZodSchemaValidator = class {
   parse(schema, value) {
     const resolvedSchema = this.schemify(schema);
     const result = resolvedSchema.safeParse(value);
-    return result.success
-      ? { ok: true, value: result.data }
-      : {
-          ok: false,
-          errors: result.error.errors.flatMap((error) => {
-            switch (error.code) {
-              case 'invalid_union':
-                return error.unionErrors.flatMap((unionError, idx) =>
-                  unionError.errors.map((e) => ({
-                    path: [
-                      `Union Schema Variant ${idx}`,
-                      ...error.path.map((p) => p.toString()),
-                      ...e.path.map((p) => p.toString())
-                    ],
-                    message: e.message
-                  }))
-                );
-              default:
-                return [
-                  {
-                    path: error.path.map((p) => p.toString()),
-                    message: error.message
-                  }
-                ];
-            }
-          })
-        };
+    return result.success ? { ok: true, value: result.data } : {
+      ok: false,
+      errors: result.error.errors.flatMap((error) => {
+        switch (error.code) {
+          case "invalid_union":
+            return error.unionErrors.flatMap(
+              (unionError, idx) => unionError.errors.map((e) => ({
+                path: [
+                  `Union Schema Variant ${idx}`,
+                  ...error.path.map((p) => p.toString()),
+                  ...e.path.map((p) => p.toString())
+                ],
+                message: e.message
+              }))
+            );
+          default:
+            return [
+              {
+                path: error.path.map((p) => p.toString()),
+                message: error.message
+              }
+            ];
+        }
+      })
+    };
   }
   /**
    * Convert a schema to an OpenAPI schema object.
@@ -1736,7 +1366,6 @@ var RedisWorkerSchemas = (0, import_internal.serviceSchemaResolver)(
   () => RedisWorkerOptionsSchema2
 );
 // Annotate the CommonJS export names for ESM import in node:
-0 &&
-  (module.exports = {
-    RedisWorkerSchemas
-  });
+0 && (module.exports = {
+  RedisWorkerSchemas
+});