@desplega.ai/agent-swarm 1.129.0 → 1.131.0

package/dist/{cli-4n4mdv21.js → cli-xpxde7rm.js}

@@ -3,9 +3,12 @@ import {
 } from "./cli-p9swy5t3.js";
 
 // src/utils/template.ts
+function findInterpolationTokens(template) {
+  return Array.from(template.matchAll(INTERPOLATION_TOKEN_RE), (match) => match[1].trim());
+}
 function interpolate(template, ctx) {
   const unresolved = [];
-  const result = template.replace(/\{\{([^}]+)\}\}/g, (_match, path) => {
+  const result = template.replace(INTERPOLATION_TOKEN_RE, (_match, path) => {
     const keys = path.trim().split(".");
     let value = ctx;
     for (const key of keys) {
@@ -73,8 +76,9 @@ function deepInterpolate(value, ctx, options = {}) {
   }
   return { value: walk(value), unresolved: allUnresolved };
 }
-var EXACT_TOKEN_RE;
+var INTERPOLATION_TOKEN_RE, EXACT_TOKEN_RE;
 var init_template = __esm(() => {
+  INTERPOLATION_TOKEN_RE = /\{\{([^}]+)\}\}/g;
   EXACT_TOKEN_RE = /^\{\{([^}]+)\}\}$/;
 });
 
@@ -1146,4 +1150,4 @@ Your output is captured automatically — focus on doing the work and communicat
   });
 });
 
-export { interpolate, deepInterpolate, init_template, registerTemplate, getTemplateDefinition, getAllTemplateDefinitions, init_registry, configureDbResolver, configureHttpResolver, resolveTemplate, resolveTemplateAsync, init_resolver, parseEnvFlag, isEnvFlagEnabled, init_env_flag, init_session_templates, isSteeringEnabled, init_steering_enabled };
+export { findInterpolationTokens, interpolate, deepInterpolate, init_template, registerTemplate, getTemplateDefinition, getAllTemplateDefinitions, init_registry, configureDbResolver, configureHttpResolver, resolveTemplate, resolveTemplateAsync, init_resolver, parseEnvFlag, isEnvFlagEnabled, init_env_flag, init_session_templates, isSteeringEnabled, init_steering_enabled };

package/dist/{cli-fpaa5k2q.js → cli-yw8vghx2.js}

@@ -16,10 +16,10 @@ import {
   runScript,
   sandboxSpawnEnv,
   snapshotCapped
-} from "./cli-akxnpx17.js";
+} from "./cli-pm6xbh84.js";
 import {
   withSiblingAwareness
-} from "./cli-0sf92efp.js";
+} from "./cli-cdeg08wx.js";
 import {
   FollowUpConfigSchema,
   ModelTierSchema,
@@ -64,26 +64,27 @@ import {
   updateWorkflowRun,
   updateWorkflowRunStep,
   workflowContextKey
-} from "./cli-t53vnnxz.js";
+} from "./cli-a4jzdpa3.js";
 import {
   deepInterpolate,
+  findInterpolationTokens,
   init_template,
   interpolate
-} from "./cli-4n4mdv21.js";
+} from "./cli-xpxde7rm.js";
 import {
   getAppUrl,
   init_constants
 } from "./cli-x23me2mg.js";
 import {
   init_zod
-} from "./cli-d91pvmq1.js";
+} from "./cli-zsspvvm2.js";
 import {
   init_secret_scrubber,
   isSensitiveKey
 } from "./cli-4j2mrzag.js";
 import {
   exports_external
-} from "./cli-2mbe7vk0.js";
+} from "./cli-5dsbcjjw.js";
 import {
   init_event_bus,
   workflowEventBus
@@ -1079,9 +1080,18 @@ async function executeStep(def, runId, ctx, node, registry, workflowId, secretKe
       throw new Error(errorMsg);
     }
   }
-  const { value: interpolatedValue, unresolved } = interpolateNodeConfig(node, interpolationCtx);
+  const {
+    value: interpolatedValue,
+    unresolved,
+    scriptBodyUnresolved
+  } = interpolateNodeConfig(node, interpolationCtx);
   const interpolatedConfig = interpolatedValue;
   const executionCtx = { ...ctx, ...interpolationCtx };
+  if (scriptBodyUnresolved && scriptBodyUnresolved.length > 0) {
+    const errorMsg = scriptBodyInterpolationError(node.id, scriptBodyUnresolved);
+    checkpointStepFailure(runId, stepId, errorMsg, 0);
+    return { outcome: "failed", successors: [] };
+  }
   if (unresolved.length > 0) {
     console.warn(`[workflow] Step ${node.id}: unresolved interpolation tokens: ${unresolved.join(", ")}`);
     updateWorkflowRunStep(stepId, {
@@ -1267,9 +1277,10 @@ function interpolateNodeConfig(node, interpolationCtx) {
     return {
       value: {
         ...restResult.value,
-        script: scriptResult.value
+        script: scriptResult.unresolved.length > 0 ? script : scriptResult.value
       },
-      unresolved: [...restResult.unresolved, ...scriptResult.unresolved]
+      unresolved: [...restResult.unresolved, ...scriptResult.unresolved],
+      scriptBodyUnresolved: scriptResult.unresolved
     };
   }
   if (node.type !== "swarm-script" || !Object.hasOwn(node.config, "args")) {
@@ -1286,6 +1297,10 @@ function interpolateNodeConfig(node, interpolationCtx) {
     unresolved: [...configResult.unresolved, ...argsResult.unresolved]
   };
 }
+function scriptBodyInterpolationError(nodeId, tokens) {
+  const renderedTokens = [...new Set(tokens)].map((token) => `{{${token}}}`).join(", ");
+  return `Script body interpolation failed for node "${nodeId}": unresolved or disallowed token(s): ${renderedTokens}. ` + "Executable source may interpolate only input, workflow, swarm, or run values. " + "Pass dynamic trigger or upstream values through config.args and read them from argv.";
+}
 function timeoutPromise(ms) {
   return new Promise((_, reject) => {
     setTimeout(() => reject(new Error(`Step timed out after ${ms}ms`)), ms);
@@ -2225,7 +2240,11 @@ function startRetryPoller(registry, intervalMs = 5000) {
           if (!("run" in ctx))
             ctx.run = { id: run.id };
           const inputCtx = buildNodeInterpolationCtx(node, ctx);
-          const { value: interpolatedValue } = interpolateNodeConfig(node, inputCtx);
+          const { value: interpolatedValue, scriptBodyUnresolved } = interpolateNodeConfig(node, inputCtx);
+          if (scriptBodyUnresolved && scriptBodyUnresolved.length > 0) {
+            checkpointStepFailure(run.id, step.id, scriptBodyInterpolationError(node.id, scriptBodyUnresolved), step.retryCount);
+            continue;
+          }
           const interpolatedConfig = interpolatedValue;
           const executor = registry.get(node.type);
           const meta = {
@@ -3073,7 +3092,7 @@ class HumanInTheLoopExecutor extends BaseExecutor {
       }
       if (notification.channel === "slack") {
         try {
-          const { getSlackApp } = await import("./app-q8vjk6e8.js");
+          const { getSlackApp } = await import("./app-m9gwqsqv.js");
           const slackApp = getSlackApp();
           if (!slackApp) {
             console.warn("[HITL] Slack not initialized — cannot send notification");
@@ -3189,7 +3208,7 @@ class NotifyExecutor extends BaseExecutor {
         }
       }
       case "slack": {
-        const { getSlackApp } = await import("./app-q8vjk6e8.js");
+        const { getSlackApp } = await import("./app-m9gwqsqv.js");
         const app = getSlackApp();
         if (!app) {
           return {
@@ -3314,14 +3333,14 @@ var RawLlmOutputSchema = exports_external.object({
 async function executeRawLlm(config) {
   const modelName = config.model ?? "google/gemini-3-flash-preview";
   try {
-    const { createOpenAI } = await import("./index-0bpkzb09.js");
+    const { createOpenAI } = await import("./index-070v4eyb.js");
     const openrouter = createOpenAI({
       baseURL: getOpenRouterBaseUrl(),
       apiKey: process.env.OPENROUTER_API_KEY
     });
     const model = openrouter(modelName);
     if (config.schema) {
-      const { generateObject, jsonSchema } = await import("./index-ker3gccb.js");
+      const { generateObject, jsonSchema } = await import("./index-9znhar3x.js");
       const { object } = await generateObject({
         model,
         schema: jsonSchema(config.schema),
@@ -3335,7 +3354,7 @@ async function executeRawLlm(config) {
         output: { result: object, model: modelName }
       };
     }
-    const { generateText } = await import("./index-ker3gccb.js");
+    const { generateText } = await import("./index-9znhar3x.js");
     const { text } = await generateText({
       model,
       prompt: config.prompt
@@ -3538,6 +3557,7 @@ class ScriptExecutor extends BaseExecutor {
 
 // src/workflows/executors/swarm-script.ts
 init_zod();
+init_template();
 var SWARM_SCRIPT_DEFAULT_TIMEOUT_MS = DEFAULT_SCRIPT_RESOURCES.wallClockMs;
 var SWARM_SCRIPT_MIN_TIMEOUT_MS = MIN_SCRIPT_WALL_CLOCK_MS;
 var SWARM_SCRIPT_MAX_TIMEOUT_MS = MAX_SCRIPT_WALL_CLOCK_MS;
@@ -3560,6 +3580,14 @@ var SwarmScriptOutputSchema = exports_external.object({
   contentHash: exports_external.string(),
   version: exports_external.number()
 });
+var WORKFLOW_INTERPOLATION_ROOTS = new Set(["trigger", "input", "workflow", "swarm", "run"]);
+function findWorkflowSourceTokens(source, inputCtx) {
+  const roots = new Set([...WORKFLOW_INTERPOLATION_ROOTS, ...Object.keys(inputCtx ?? {})]);
+  return findInterpolationTokens(source).filter((token) => {
+    const root = token.split(".")[0];
+    return root !== undefined && roots.has(root);
+  });
+}
 
 class SwarmScriptExecutor extends BaseExecutor {
   type = "swarm-script";
@@ -3579,6 +3607,14 @@ class SwarmScriptExecutor extends BaseExecutor {
     if (!resolved.ok) {
       return { status: "failed", error: resolved.error };
     }
+    const sourceTokens = findWorkflowSourceTokens(resolved.source, meta.inputCtx);
+    if (sourceTokens.length > 0) {
+      const renderedTokens = [...new Set(sourceTokens)].map((token) => `{{${token}}}`).join(", ");
+      return {
+        status: "failed",
+        error: `swarm-script body interpolation failed for node "${meta.nodeId}": unresolved token(s): ${renderedTokens}. ` + "Named script source is not workflow-interpolated; pass dynamic values through config.args and read them from args."
+      };
+    }
     const credentials = await buildScriptCredentialBindingsWithFailures({
       agentId: agentId ?? undefined
     });
@@ -3745,8 +3781,8 @@ class ValidateExecutor extends BaseExecutor {
     const interpolatedPrompt = this.deps.interpolate(prompt, context);
     const outputStr = typeof targetOutput === "string" ? targetOutput : JSON.stringify(targetOutput);
     try {
-      const { createOpenAI } = await import("./index-0bpkzb09.js");
-      const { generateObject, jsonSchema } = await import("./index-ker3gccb.js");
+      const { createOpenAI } = await import("./index-070v4eyb.js");
+      const { generateObject, jsonSchema } = await import("./index-9znhar3x.js");
       const openrouter = createOpenAI({
         baseURL: getOpenRouterBaseUrl(),
         apiKey: process.env.OPENROUTER_API_KEY
@@ -3951,4 +3987,4 @@ function initWorkflows() {
   logOpenWebhookTriggers();
 }
 
-export { generateEdges, findEntryNodes, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch, validateJsonSchema, TriggerSchemaError, startWorkflowExecution, setupWorkflowResumeListener, retryFailedRun, cancelWorkflowRun, resumeWaitState, initWaitBusSubscriptions, subscribeWaitToBus, recoverIncompleteRuns, startRetryPoller, stopRetryPoller, validateTemplateVariables, instantiateTemplate, handleWebhookTrigger, logOpenWebhookTriggers, handleScheduleTrigger, verifyHmacSignature, WebhookError, snapshotWorkflow, startWaitPoller, stopWaitPoller, RawLlmConfigSchema, executeRawLlm, getExecutorRegistry, initWorkflows };
+export { generateEdges, findEntryNodes, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch, validateJsonSchema, TriggerSchemaError, startWorkflowExecution, setupWorkflowResumeListener, retryFailedRun, cancelWorkflowRun, resumeWaitState, initWaitBusSubscriptions, subscribeWaitToBus, recoverIncompleteRuns, startRetryPoller, stopRetryPoller, validateTemplateVariables, instantiateTemplate, handleWebhookTrigger, logOpenWebhookTriggers, handleScheduleTrigger, verifyHmacSignature, WebhookError, snapshotWorkflow, startWaitPoller, stopWaitPoller, RawLlmConfigSchema, RawLlmOutputSchema, executeRawLlm, getExecutorRegistry, initWorkflows };

package/dist/cli-zsspvvm2.js

@@ -0,0 +1,490 @@
+import {
+  $brand,
+  $input,
+  $output,
+  NEVER,
+  TimePrecision,
+  ZodAny,
+  ZodArray,
+  ZodBase64,
+  ZodBase64URL,
+  ZodBigInt,
+  ZodBigIntFormat,
+  ZodBoolean,
+  ZodCIDRv4,
+  ZodCIDRv6,
+  ZodCUID,
+  ZodCUID2,
+  ZodCatch,
+  ZodCodec,
+  ZodCustom,
+  ZodCustomStringFormat,
+  ZodDate,
+  ZodDefault,
+  ZodDiscriminatedUnion,
+  ZodE164,
+  ZodEmail,
+  ZodEmoji,
+  ZodEnum,
+  ZodError,
+  ZodFile,
+  ZodFirstPartyTypeKind,
+  ZodFunction,
+  ZodGUID,
+  ZodIPv4,
+  ZodIPv6,
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  ZodIntersection,
+  ZodIssueCode,
+  ZodJWT,
+  ZodKSUID,
+  ZodLazy,
+  ZodLiteral,
+  ZodMAC,
+  ZodMap,
+  ZodNaN,
+  ZodNanoID,
+  ZodNever,
+  ZodNonOptional,
+  ZodNull,
+  ZodNullable,
+  ZodNumber,
+  ZodNumberFormat,
+  ZodObject,
+  ZodOptional,
+  ZodPipe,
+  ZodPrefault,
+  ZodPromise,
+  ZodReadonly,
+  ZodRealError,
+  ZodRecord,
+  ZodSet,
+  ZodString,
+  ZodStringFormat,
+  ZodSuccess,
+  ZodSymbol,
+  ZodTemplateLiteral,
+  ZodTransform,
+  ZodTuple,
+  ZodType,
+  ZodULID,
+  ZodURL,
+  ZodUUID,
+  ZodUndefined,
+  ZodUnion,
+  ZodUnknown,
+  ZodVoid,
+  ZodXID,
+  ZodXor,
+  _ZodString,
+  _catch,
+  _default,
+  _endsWith,
+  _enum,
+  _function,
+  _gt,
+  _gte,
+  _includes,
+  _instanceof,
+  _length,
+  _lowercase,
+  _lt,
+  _lte,
+  _maxLength,
+  _maxSize,
+  _mime,
+  _minLength,
+  _minSize,
+  _multipleOf,
+  _negative,
+  _nonnegative,
+  _nonpositive,
+  _normalize,
+  _null,
+  _overwrite,
+  _positive,
+  _property,
+  _regex,
+  _size,
+  _slugify,
+  _startsWith,
+  _toLowerCase,
+  _toUpperCase,
+  _trim,
+  _undefined,
+  _uppercase,
+  _void,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  codec,
+  config,
+  cuid,
+  cuid2,
+  custom,
+  date,
+  decode,
+  decodeAsync,
+  describe,
+  discriminatedUnion,
+  e164,
+  email,
+  emoji,
+  encode,
+  encodeAsync,
+  exports_coerce,
+  exports_core,
+  exports_external,
+  exports_iso,
+  exports_locales,
+  exports_regexes,
+  exports_util,
+  file,
+  flattenError,
+  float32,
+  float64,
+  formatError,
+  fromJSONSchema,
+  getErrorMap,
+  globalRegistry,
+  guid,
+  hash,
+  hex,
+  hostname,
+  httpUrl,
+  init_external,
+  int,
+  int32,
+  int64,
+  intersection,
+  ipv4,
+  ipv6,
+  json,
+  jwt,
+  keyof,
+  ksuid,
+  lazy,
+  literal,
+  looseObject,
+  looseRecord,
+  mac,
+  map,
+  meta,
+  nan,
+  nanoid,
+  nativeEnum,
+  never,
+  nonoptional,
+  nullable,
+  nullish,
+  number,
+  object,
+  optional,
+  parse1 as parse,
+  parseAsync1 as parseAsync,
+  partialRecord,
+  pipe,
+  prefault,
+  preprocess,
+  prettifyError,
+  promise,
+  readonly,
+  record,
+  refine,
+  registry,
+  safeDecode,
+  safeDecodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  safeParse1 as safeParse,
+  safeParseAsync1 as safeParseAsync,
+  set,
+  setErrorMap,
+  strictObject,
+  string,
+  stringFormat,
+  stringbool,
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  transform,
+  treeifyError,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  union,
+  unknown,
+  url,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  xid,
+  xor
+} from "./cli-5dsbcjjw.js";
+import {
+  __esm,
+  __export
+} from "./cli-p9swy5t3.js";
+
+// node_modules/zod/index.js
+var exports_zod = {};
+__export(exports_zod, {
+  z: () => exports_external,
+  xor: () => xor,
+  xid: () => xid,
+  void: () => _void,
+  uuidv7: () => uuidv7,
+  uuidv6: () => uuidv6,
+  uuidv4: () => uuidv4,
+  uuid: () => uuid,
+  util: () => exports_util,
+  url: () => url,
+  uppercase: () => _uppercase,
+  unknown: () => unknown,
+  union: () => union,
+  undefined: () => _undefined,
+  ulid: () => ulid,
+  uint64: () => uint64,
+  uint32: () => uint32,
+  tuple: () => tuple,
+  trim: () => _trim,
+  treeifyError: () => treeifyError,
+  transform: () => transform,
+  toUpperCase: () => _toUpperCase,
+  toLowerCase: () => _toLowerCase,
+  toJSONSchema: () => toJSONSchema,
+  templateLiteral: () => templateLiteral,
+  symbol: () => symbol,
+  superRefine: () => superRefine,
+  success: () => success,
+  stringbool: () => stringbool,
+  stringFormat: () => stringFormat,
+  string: () => string,
+  strictObject: () => strictObject,
+  startsWith: () => _startsWith,
+  slugify: () => _slugify,
+  size: () => _size,
+  setErrorMap: () => setErrorMap,
+  set: () => set,
+  safeParseAsync: () => safeParseAsync,
+  safeParse: () => safeParse,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeEncode: () => safeEncode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeDecode: () => safeDecode,
+  registry: () => registry,
+  regexes: () => exports_regexes,
+  regex: () => _regex,
+  refine: () => refine,
+  record: () => record,
+  readonly: () => readonly,
+  property: () => _property,
+  promise: () => promise,
+  prettifyError: () => prettifyError,
+  preprocess: () => preprocess,
+  prefault: () => prefault,
+  positive: () => _positive,
+  pipe: () => pipe,
+  partialRecord: () => partialRecord,
+  parseAsync: () => parseAsync,
+  parse: () => parse,
+  overwrite: () => _overwrite,
+  optional: () => optional,
+  object: () => object,
+  number: () => number,
+  nullish: () => nullish,
+  nullable: () => nullable,
+  null: () => _null,
+  normalize: () => _normalize,
+  nonpositive: () => _nonpositive,
+  nonoptional: () => nonoptional,
+  nonnegative: () => _nonnegative,
+  never: () => never,
+  negative: () => _negative,
+  nativeEnum: () => nativeEnum,
+  nanoid: () => nanoid,
+  nan: () => nan,
+  multipleOf: () => _multipleOf,
+  minSize: () => _minSize,
+  minLength: () => _minLength,
+  mime: () => _mime,
+  meta: () => meta,
+  maxSize: () => _maxSize,
+  maxLength: () => _maxLength,
+  map: () => map,
+  mac: () => mac,
+  lte: () => _lte,
+  lt: () => _lt,
+  lowercase: () => _lowercase,
+  looseRecord: () => looseRecord,
+  looseObject: () => looseObject,
+  locales: () => exports_locales,
+  literal: () => literal,
+  length: () => _length,
+  lazy: () => lazy,
+  ksuid: () => ksuid,
+  keyof: () => keyof,
+  jwt: () => jwt,
+  json: () => json,
+  iso: () => exports_iso,
+  ipv6: () => ipv6,
+  ipv4: () => ipv4,
+  intersection: () => intersection,
+  int64: () => int64,
+  int32: () => int32,
+  int: () => int,
+  instanceof: () => _instanceof,
+  includes: () => _includes,
+  httpUrl: () => httpUrl,
+  hostname: () => hostname,
+  hex: () => hex,
+  hash: () => hash,
+  guid: () => guid,
+  gte: () => _gte,
+  gt: () => _gt,
+  globalRegistry: () => globalRegistry,
+  getErrorMap: () => getErrorMap,
+  function: () => _function,
+  fromJSONSchema: () => fromJSONSchema,
+  formatError: () => formatError,
+  float64: () => float64,
+  float32: () => float32,
+  flattenError: () => flattenError,
+  file: () => file,
+  enum: () => _enum,
+  endsWith: () => _endsWith,
+  encodeAsync: () => encodeAsync,
+  encode: () => encode,
+  emoji: () => emoji,
+  email: () => email,
+  e164: () => e164,
+  discriminatedUnion: () => discriminatedUnion,
+  describe: () => describe,
+  default: () => zod_default,
+  decodeAsync: () => decodeAsync,
+  decode: () => decode,
+  date: () => date,
+  custom: () => custom,
+  cuid2: () => cuid2,
+  cuid: () => cuid,
+  core: () => exports_core,
+  config: () => config,
+  coerce: () => exports_coerce,
+  codec: () => codec,
+  clone: () => clone,
+  cidrv6: () => cidrv6,
+  cidrv4: () => cidrv4,
+  check: () => check,
+  catch: () => _catch,
+  boolean: () => boolean,
+  bigint: () => bigint,
+  base64url: () => base64url,
+  base64: () => base64,
+  array: () => array,
+  any: () => any,
+  _function: () => _function,
+  _default: () => _default,
+  _ZodString: () => _ZodString,
+  ZodXor: () => ZodXor,
+  ZodXID: () => ZodXID,
+  ZodVoid: () => ZodVoid,
+  ZodUnknown: () => ZodUnknown,
+  ZodUnion: () => ZodUnion,
+  ZodUndefined: () => ZodUndefined,
+  ZodUUID: () => ZodUUID,
+  ZodURL: () => ZodURL,
+  ZodULID: () => ZodULID,
+  ZodType: () => ZodType,
+  ZodTuple: () => ZodTuple,
+  ZodTransform: () => ZodTransform,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodSymbol: () => ZodSymbol,
+  ZodSuccess: () => ZodSuccess,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodString: () => ZodString,
+  ZodSet: () => ZodSet,
+  ZodRecord: () => ZodRecord,
+  ZodRealError: () => ZodRealError,
+  ZodReadonly: () => ZodReadonly,
+  ZodPromise: () => ZodPromise,
+  ZodPrefault: () => ZodPrefault,
+  ZodPipe: () => ZodPipe,
+  ZodOptional: () => ZodOptional,
+  ZodObject: () => ZodObject,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodNumber: () => ZodNumber,
+  ZodNullable: () => ZodNullable,
+  ZodNull: () => ZodNull,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNever: () => ZodNever,
+  ZodNanoID: () => ZodNanoID,
+  ZodNaN: () => ZodNaN,
+  ZodMap: () => ZodMap,
+  ZodMAC: () => ZodMAC,
+  ZodLiteral: () => ZodLiteral,
+  ZodLazy: () => ZodLazy,
+  ZodKSUID: () => ZodKSUID,
+  ZodJWT: () => ZodJWT,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodIntersection: () => ZodIntersection,
+  ZodISOTime: () => ZodISOTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODate: () => ZodISODate,
+  ZodIPv6: () => ZodIPv6,
+  ZodIPv4: () => ZodIPv4,
+  ZodGUID: () => ZodGUID,
+  ZodFunction: () => ZodFunction,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFile: () => ZodFile,
+  ZodError: () => ZodError,
+  ZodEnum: () => ZodEnum,
+  ZodEmoji: () => ZodEmoji,
+  ZodEmail: () => ZodEmail,
+  ZodE164: () => ZodE164,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodDefault: () => ZodDefault,
+  ZodDate: () => ZodDate,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodCustom: () => ZodCustom,
+  ZodCodec: () => ZodCodec,
+  ZodCatch: () => ZodCatch,
+  ZodCUID2: () => ZodCUID2,
+  ZodCUID: () => ZodCUID,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodBoolean: () => ZodBoolean,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBigInt: () => ZodBigInt,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBase64: () => ZodBase64,
+  ZodArray: () => ZodArray,
+  ZodAny: () => ZodAny,
+  TimePrecision: () => TimePrecision,
+  NEVER: () => NEVER,
+  $output: () => $output,
+  $input: () => $input,
+  $brand: () => $brand
+});
+var zod_default;
+var init_zod = __esm(() => {
+  init_external();
+  init_external();
+  zod_default = exports_external;
+});
+
+export { exports_zod, init_zod };