@trigger.dev/core 0.0.0-v3-canary-20240324201508 → 0.0.0-v3-canary-20240325172431

package/dist/v3/index.js

@@ -256,7 +256,8 @@ var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
     id: zod.z.string(),
     image: zod.z.string(),
     envId: zod.z.string(),
-    runId: zod.z.string()
+    runId: zod.z.string(),
+    version: zod.z.string()
   })
 ]);
 var serverWebsocketMessages = {
@@ -356,17 +357,62 @@ var RateLimitOptions = zod.z.discriminatedUnion("type", [
   SlidingWindowRateLimit
 ]);
 var RetryOptions = zod.z.object({
+  /** The number of attempts before giving up */
   maxAttempts: zod.z.number().int().optional(),
+  /** The exponential factor to use when calculating the next retry time.
+  *
+  * Each subsequent retry will be calculated as `previousTimeout * factor`
+  */
   factor: zod.z.number().optional(),
+  /** The minimum time to wait before retrying */
   minTimeoutInMs: zod.z.number().int().optional(),
+  /** The maximum time to wait before retrying */
   maxTimeoutInMs: zod.z.number().int().optional(),
+  /** Randomize the timeout between retries.
+  *
+  * This can be useful to prevent the thundering herd problem where all retries happen at the same time.
+  */
   randomize: zod.z.boolean().optional()
 });
 var QueueOptions = zod.z.object({
-  /** @deprecated This feature is coming soon */
-  rateLimit: RateLimitOptions.optional(),
+  /** You can define a shared queue and then pass the name in to your task.
+     * 
+     * @example
+     * 
+     * ```ts
+     * const myQueue = queue({
+        name: "my-queue",
+        concurrencyLimit: 1,
+      });
+  
+      export const task1 = task({
+        id: "task-1",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+  
+      export const task2 = task({
+        id: "task-2",
+        queue: {
+          name: "my-queue",
+        },
+        run: async (payload: { message: string }) => {
+          // ...
+        },
+      });
+     * ```
+     */
+  name: zod.z.string().optional(),
+  /** An optional property that specifies the maximum number of concurrent run executions.
+  *
+  * If this property is omitted, the task can potentially use up the full concurrency of an environment. */
   concurrencyLimit: zod.z.number().int().min(1).max(1e3).optional(),
-  name: zod.z.string().optional()
+  /** @deprecated This feature is coming soon */
+  rateLimit: RateLimitOptions.optional()
 });
 var TaskMetadata = zod.z.object({
   id: zod.z.string(),
@@ -443,10 +489,21 @@ var ProdChildToWorkerMessages = {
   READY_TO_DISPOSE: {
     message: zod.z.undefined()
   },
+  READY_FOR_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
   WAIT_FOR_DURATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      ms: zod.z.number()
+      ms: zod.z.number(),
+      now: zod.z.number()
     }),
     callback: zod.z.object({
       willCheckpointAndRestore: zod.z.boolean()
@@ -455,14 +512,14 @@ var ProdChildToWorkerMessages = {
   WAIT_FOR_TASK: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      id: zod.z.string()
+      friendlyId: zod.z.string()
     })
   },
   WAIT_FOR_BATCH: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      id: zod.z.string(),
-      runs: zod.z.string().array()
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array()
     })
   },
   UNCAUGHT_EXCEPTION: {
@@ -676,6 +733,11 @@ var Machine = zod.z.object({
   cpu: zod.z.string().default("1").optional(),
   memory: zod.z.string().default("500Mi").optional()
 });
+var WaitReason = zod.z.enum([
+  "WAIT_FOR_DURATION",
+  "WAIT_FOR_TASK",
+  "WAIT_FOR_BATCH"
+]);
 var ProviderToPlatformMessages = {
   LOG: {
     message: zod.z.object({
@@ -706,7 +768,7 @@ var PlatformToProviderMessages = {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       imageTag: zod.z.string(),
-      contentHash: zod.z.string(),
+      shortCode: zod.z.string(),
       envId: zod.z.string(),
       apiKey: zod.z.string(),
       apiUrl: zod.z.string()
@@ -737,13 +799,13 @@ var PlatformToProviderMessages = {
       version: zod.z.literal("v1").default("v1"),
       checkpointId: zod.z.string(),
       runId: zod.z.string(),
-      attemptId: zod.z.string(),
       type: zod.z.enum([
         "DOCKER",
         "KUBERNETES"
       ]),
       location: zod.z.string(),
-      reason: zod.z.string().optional()
+      reason: zod.z.string().optional(),
+      imageRef: zod.z.string()
     })
   },
   DELETE: {
@@ -795,8 +857,8 @@ var CoordinatorToPlatformMessages = {
   READY_FOR_EXECUTION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string(),
-      runId: zod.z.string()
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
     }),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
@@ -811,19 +873,19 @@ var CoordinatorToPlatformMessages = {
   READY_FOR_RESUME: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string(),
-      type: zod.z.enum([
-        "WAIT_FOR_DURATION",
-        "WAIT_FOR_TASK",
-        "WAIT_FOR_BATCH"
-      ])
+      attemptFriendlyId: zod.z.string(),
+      type: WaitReason
     })
   },
   TASK_RUN_COMPLETED: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       execution: ProdTaskRunExecution,
-      completion: TaskRunExecutionResult
+      completion: TaskRunExecutionResult,
+      checkpoint: zod.z.object({
+        docker: zod.z.boolean(),
+        location: zod.z.string()
+      }).optional()
     })
   },
   TASK_HEARTBEAT: {
@@ -835,21 +897,23 @@ var CoordinatorToPlatformMessages = {
   CHECKPOINT_CREATED: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string(),
       docker: zod.z.boolean(),
       location: zod.z.string(),
       reason: zod.z.discriminatedUnion("type", [
         zod.z.object({
           type: zod.z.literal("WAIT_FOR_DURATION"),
-          ms: zod.z.number()
+          ms: zod.z.number(),
+          now: zod.z.number()
         }),
         zod.z.object({
           type: zod.z.literal("WAIT_FOR_BATCH"),
-          id: zod.z.string()
+          batchFriendlyId: zod.z.string(),
+          runFriendlyIds: zod.z.string().array()
         }),
         zod.z.object({
           type: zod.z.literal("WAIT_FOR_TASK"),
-          id: zod.z.string()
+          friendlyId: zod.z.string()
         }),
         zod.z.object({
           type: zod.z.literal("RETRYING_AFTER_FAILURE"),
@@ -871,10 +935,12 @@ var CoordinatorToPlatformMessages = {
   }
 };
 var PlatformToCoordinatorMessages = {
-  RESUME: {
+  RESUME_AFTER_DEPENDENCY: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
       attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string(),
       completions: TaskRunExecutionResult.array(),
       executions: TaskRunExecution.array()
     })
@@ -882,13 +948,21 @@ var PlatformToCoordinatorMessages = {
   RESUME_AFTER_DURATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string()
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string()
     })
   },
   REQUEST_ATTEMPT_CANCELLATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string()
+      attemptId: zod.z.string(),
+      attemptFriendlyId: zod.z.string()
+    })
+  },
+  READY_FOR_RETRY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
     })
   }
 };
@@ -955,19 +1029,25 @@ var ProdWorkerToCoordinatorMessages = {
   READY_FOR_EXECUTION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string(),
-      runId: zod.z.string()
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
     })
   },
   READY_FOR_RESUME: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      attemptId: zod.z.string(),
-      type: zod.z.enum([
-        "WAIT_FOR_DURATION",
-        "WAIT_FOR_TASK",
-        "WAIT_FOR_BATCH"
-      ])
+      attemptFriendlyId: zod.z.string(),
+      type: WaitReason
+    })
+  },
+  READY_FOR_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
+    })
+  },
+  CANCEL_CHECKPOINT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1")
     })
   },
   TASK_HEARTBEAT: {
@@ -983,14 +1063,16 @@ var ProdWorkerToCoordinatorMessages = {
       completion: TaskRunExecutionResult
     }),
     callback: zod.z.object({
-      didCheckpoint: zod.z.boolean(),
+      willCheckpointAndRestore: zod.z.boolean(),
       shouldExit: zod.z.boolean()
     })
   },
   WAIT_FOR_DURATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      ms: zod.z.number()
+      ms: zod.z.number(),
+      now: zod.z.number(),
+      attemptFriendlyId: zod.z.string()
     }),
     callback: zod.z.object({
       willCheckpointAndRestore: zod.z.boolean()
@@ -999,7 +1081,9 @@ var ProdWorkerToCoordinatorMessages = {
   WAIT_FOR_TASK: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      id: zod.z.string()
+      friendlyId: zod.z.string(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: zod.z.string()
     }),
     callback: zod.z.object({
       willCheckpointAndRestore: zod.z.boolean()
@@ -1008,8 +1092,10 @@ var ProdWorkerToCoordinatorMessages = {
   WAIT_FOR_BATCH: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
-      id: zod.z.string(),
-      runs: zod.z.string().array()
+      batchFriendlyId: zod.z.string(),
+      runFriendlyIds: zod.z.string().array(),
+      // This is the attempt that is waiting
+      attemptFriendlyId: zod.z.string()
     }),
     callback: zod.z.object({
       willCheckpointAndRestore: zod.z.boolean()
@@ -1028,7 +1114,7 @@ var ProdWorkerToCoordinatorMessages = {
   }
 };
 var CoordinatorToProdWorkerMessages = {
-  RESUME: {
+  RESUME_AFTER_DEPENDENCY: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       attemptId: zod.z.string(),
@@ -1058,6 +1144,12 @@ var CoordinatorToProdWorkerMessages = {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1")
     })
+  },
+  READY_FOR_RETRY: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
   }
 };
 var ProdWorkerSocketData = zod.z.object({
@@ -1065,9 +1157,10 @@ var ProdWorkerSocketData = zod.z.object({
   projectRef: zod.z.string(),
   envId: zod.z.string(),
   runId: zod.z.string(),
-  attemptId: zod.z.string(),
+  attemptFriendlyId: zod.z.string().optional(),
   podName: zod.z.string(),
-  deploymentId: zod.z.string()
+  deploymentId: zod.z.string(),
+  deploymentVersion: zod.z.string()
 });
 var PRIMARY_VARIANT = "primary";
 var Variant = zod.z.enum([
@@ -1201,12 +1294,22 @@ var FetchRetryStrategy = zod.z.discriminatedUnion("strategy", [
   FetchRetryHeadersStrategy,
   FetchRetryBackoffStrategy
 ]);
-var FetchRetryOptions = zod.z.record(FetchRetryStrategy);
+var FetchRetryByStatusOptions = zod.z.record(zod.z.string(), FetchRetryStrategy);
 var FetchTimeoutOptions = zod.z.object({
   /** The maximum time to wait for the request to complete. */
   durationInMs: zod.z.number().optional(),
   retry: RetryOptions.optional()
 });
+var FetchRetryOptions = zod.z.object({
+  /** The retrying strategy for specific status codes. */
+  byStatus: FetchRetryByStatusOptions.optional(),
+  /** The timeout options for the request. */
+  timeout: RetryOptions.optional(),
+  /**
+  * The retrying strategy for connection errors.
+  */
+  connectionError: RetryOptions.optional()
+});
 var ExceptionEventProperties = zod.z.object({
   type: zod.z.string().optional(),
   message: zod.z.string().optional(),
@@ -1245,6 +1348,18 @@ function isCancellationSpanEvent(event) {
   return event.name === "cancellation";
 }
 __name(isCancellationSpanEvent, "isCancellationSpanEvent");
+var SpanMessagingEvent = zod.z.object({
+  system: zod.z.string().optional(),
+  client_id: zod.z.string().optional(),
+  operation: zod.z.enum([
+    "publish",
+    "create",
+    "receive",
+    "deliver"
+  ]),
+  message: zod.z.any(),
+  destination: zod.z.string().optional()
+});
 
 // src/zodfetch.ts
 async function zodfetch(schema, url, requestInit) {
@@ -1325,9 +1440,9 @@ function flattenAttributes(obj, prefix) {
     if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
         if (typeof value[i] === "object" && value[i] !== null) {
-          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.${i}`));
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
         } else {
-          result[`${newPrefix}.${i}`] = value[i];
+          result[`${newPrefix}.[${i}]`] = value[i];
         }
       }
     } else if (isRecord(value)) {
@@ -1346,32 +1461,45 @@ function isRecord(value) {
 }
 __name(isRecord, "isRecord");
 function unflattenAttributes(obj) {
-  if (obj === null || obj === void 0 || typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || Array.isArray(obj)) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
     return obj;
   }
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".");
+    const parts = key.split(".").reduce((acc, part) => {
+      if (detectIsArrayIndex(part)) {
+        acc.push(part);
+      } else {
+        acc.push(...part.split(/\.\[(.*?)\]/).filter(Boolean));
+      }
+      return acc;
+    }, []);
     let current = result;
     for (let i = 0; i < parts.length - 1; i++) {
       const part = parts[i];
-      if (typeof part === "string") {
-        const nextPart = parts[i + 1];
-        const isArray = nextPart ? parseInt(nextPart, 10).toString() === nextPart : false;
-        if (current[part] == null) {
-          current[part] = isArray ? [] : {};
-        }
-        current = current[part];
+      const isArray = detectIsArrayIndex(part);
+      const cleanPart = isArray ? part.substring(1, part.length - 1) : part;
+      const nextIsArray = detectIsArrayIndex(parts[i + 1]);
+      if (!current[cleanPart]) {
+        current[cleanPart] = nextIsArray ? [] : {};
       }
+      current = current[cleanPart];
     }
     const lastPart = parts[parts.length - 1];
-    if (typeof lastPart === "string") {
-      current[lastPart] = value;
-    }
+    const cleanLastPart = detectIsArrayIndex(lastPart) ? parseInt(lastPart.substring(1, lastPart.length - 1), 10) : lastPart;
+    current[cleanLastPart] = value;
   }
   return result;
 }
 __name(unflattenAttributes, "unflattenAttributes");
+function detectIsArrayIndex(key) {
+  const match = key.match(/^\[(\d+)\]$/);
+  if (match) {
+    return true;
+  }
+  return false;
+}
+__name(detectIsArrayIndex, "detectIsArrayIndex");
 function primitiveValueOrflattenedAttributes(obj, prefix) {
   if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
     return obj;
@@ -1428,7 +1556,8 @@ var SemanticInternalAttributes = {
   METADATA: "$metadata",
   TRIGGER: "$trigger",
   PAYLOAD: "$payload",
-  SHOW_ACTIONS: "show.actions",
+  SHOW: "$show",
+  SHOW_ACTIONS: "$show.actions",
   WORKER_ID: "worker.id",
   WORKER_VERSION: "worker.version",
   CLI_VERSION: "cli.version",
@@ -1696,14 +1825,17 @@ var _ZodMessageHandler = class _ZodMessageHandler {
     };
   }
   registerHandlers(emitter, logger2) {
-    const log = logger2 ?? console.log;
+    const log = logger2 ?? console;
     if (!__privateGet(this, _handlers)) {
-      log("No handlers provided");
+      log.info("No handlers provided");
       return;
     }
     for (const eventName of Object.keys(__privateGet(this, _schema))) {
       emitter.on(eventName, async (message, callback) => {
-        log(`handling ${eventName}`, message);
+        log.info(`handling ${eventName}`, {
+          payload: message,
+          hasCallback: !!callback
+        });
         let ack;
         if ("payload" in message) {
           ack = await this.handleMessage({
@@ -1821,27 +1953,37 @@ var _ZodSocketMessageHandler = class _ZodSocketMessageHandler {
     };
   }
   registerHandlers(emitter, logger2) {
-    const log = logger2 ?? console.log;
+    const log = logger2 ?? console;
     if (!__privateGet(this, _handlers2)) {
-      log("No handlers provided");
+      log.info("No handlers provided");
       return;
     }
     for (const eventName of Object.keys(__privateGet(this, _handlers2))) {
       emitter.on(eventName, async (message, callback) => {
-        log(`handling ${eventName}`, message);
+        log.info(`handling ${eventName}`, {
+          payload: message,
+          hasCallback: !!callback
+        });
         let ack;
-        if ("payload" in message) {
-          ack = await this.handleMessage({
-            type: eventName,
-            ...message
-          });
-        } else {
-          const { version, ...payload } = message;
-          ack = await this.handleMessage({
-            type: eventName,
-            version,
-            payload
+        try {
+          if ("payload" in message) {
+            ack = await this.handleMessage({
+              type: eventName,
+              ...message
+            });
+          } else {
+            const { version, ...payload } = message;
+            ack = await this.handleMessage({
+              type: eventName,
+              version,
+              payload
+            });
+          }
+        } catch (error) {
+          log.error("Error while handling message", {
+            error
           });
+          return;
         }
         if (callback && typeof callback === "function") {
           callback(ack);
@@ -1912,7 +2054,9 @@ var _ZodSocketConnection = class _ZodSocketConnection {
       },
       extraHeaders: opts.extraHeaders
     });
-    __privateSet(this, _logger, createLogger(`[${opts.namespace}][${this.socket.id}]`));
+    __privateSet(this, _logger, new SimpleStructuredLogger(opts.namespace, exports.LogLevel.info, {
+      socketId: this.socket.id
+    }));
     __privateSet(this, _handler, new ZodSocketMessageHandler({
       schema: opts.serverMessages,
       handlers: opts.handlers
@@ -1923,19 +2067,22 @@ var _ZodSocketConnection = class _ZodSocketConnection {
       socket: this.socket
     }));
     this.socket.on("connect_error", async (error) => {
-      __privateGet(this, _logger).call(this, `connect_error: ${error}`);
+      __privateGet(this, _logger).error(`connect_error: ${error}`);
       if (opts.onError) {
         await opts.onError(this.socket, error, __privateGet(this, _logger));
       }
     });
     this.socket.on("connect", async () => {
-      __privateGet(this, _logger).call(this, "connect");
+      __privateGet(this, _logger).info("connect");
       if (opts.onConnection) {
         await opts.onConnection(this.socket, __privateGet(this, _handler), __privateGet(this, _sender2), __privateGet(this, _logger));
       }
     });
     this.socket.on("disconnect", async (reason, description) => {
-      __privateGet(this, _logger).call(this, "disconnect");
+      __privateGet(this, _logger).info("disconnect", {
+        reason,
+        description
+      });
       if (opts.onDisconnect) {
         await opts.onDisconnect(this.socket, reason, description, __privateGet(this, _logger));
       }
@@ -1959,16 +2106,79 @@ _handler = new WeakMap();
 _logger = new WeakMap();
 __name(_ZodSocketConnection, "ZodSocketConnection");
 var ZodSocketConnection = _ZodSocketConnection;
-function createLogger(prefix) {
-  return (...args) => console.log(prefix, ...args);
-}
-__name(createLogger, "createLogger");
 
 // src/v3/zodNamespace.ts
-var _handler2;
+exports.LogLevel = void 0;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["log"] = 0] = "log";
+  LogLevel2[LogLevel2["error"] = 1] = "error";
+  LogLevel2[LogLevel2["warn"] = 2] = "warn";
+  LogLevel2[LogLevel2["info"] = 3] = "info";
+  LogLevel2[LogLevel2["debug"] = 4] = "debug";
+})(exports.LogLevel || (exports.LogLevel = {}));
+var _structuredLog, structuredLog_fn;
+var _SimpleStructuredLogger = class _SimpleStructuredLogger {
+  constructor(name, level = [
+    "1",
+    "true"
+  ].includes(process.env.DEBUG ?? "") ? exports.LogLevel.debug : exports.LogLevel.info, fields) {
+    __privateAdd(this, _structuredLog);
+    this.name = name;
+    this.level = level;
+    this.fields = fields;
+  }
+  child(fields, level) {
+    return new _SimpleStructuredLogger(this.name, level, {
+      ...this.fields,
+      ...fields
+    });
+  }
+  log(message, ...args) {
+    if (this.level < exports.LogLevel.log)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, "log", ...args);
+  }
+  error(message, ...args) {
+    if (this.level < exports.LogLevel.error)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, "error", ...args);
+  }
+  warn(message, ...args) {
+    if (this.level < exports.LogLevel.warn)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, "warn", ...args);
+  }
+  info(message, ...args) {
+    if (this.level < exports.LogLevel.info)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, "info", ...args);
+  }
+  debug(message, ...args) {
+    if (this.level < exports.LogLevel.debug)
+      return;
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, "debug", ...args);
+  }
+};
+_structuredLog = new WeakSet();
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, level, ...args) {
+  const structuredLog = {
+    ...args.length === 1 ? args[0] : args,
+    ...this.fields,
+    timestamp: /* @__PURE__ */ new Date(),
+    name: this.name,
+    message,
+    level
+  };
+  loggerFunction(JSON.stringify(structuredLog));
+}, "#structuredLog");
+__name(_SimpleStructuredLogger, "SimpleStructuredLogger");
+var SimpleStructuredLogger = _SimpleStructuredLogger;
+var _logger2, _handler2;
 var _ZodNamespace = class _ZodNamespace {
   constructor(opts) {
+    __privateAdd(this, _logger2, void 0);
     __privateAdd(this, _handler2, void 0);
+    __privateSet(this, _logger2, opts.logger ?? new SimpleStructuredLogger(opts.name));
     __privateSet(this, _handler2, new ZodSocketMessageHandler({
       schema: opts.clientMessages,
       handlers: opts.handlers
@@ -1990,7 +2200,10 @@ var _ZodNamespace = class _ZodNamespace {
     });
     if (opts.preAuth) {
       this.namespace.use(async (socket, next) => {
-        const logger2 = createLogger2(`[${opts.name}][${socket.id}][preAuth]`);
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "preAuth"
+        });
         if (typeof opts.preAuth === "function") {
           await opts.preAuth(socket, next, logger2);
         }
@@ -1998,34 +2211,43 @@ var _ZodNamespace = class _ZodNamespace {
     }
     if (opts.authToken) {
       this.namespace.use((socket, next) => {
-        const logger2 = createLogger2(`[${opts.name}][${socket.id}][auth]`);
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "auth"
+        });
         const { auth } = socket.handshake;
         if (!("token" in auth)) {
-          logger2("no token");
+          logger2.error("no token");
           return socket.disconnect(true);
         }
         if (auth.token !== opts.authToken) {
-          logger2("invalid token");
+          logger2.error("invalid token");
           return socket.disconnect(true);
         }
-        logger2("success");
+        logger2.info("success");
         next();
       });
     }
     if (opts.postAuth) {
       this.namespace.use(async (socket, next) => {
-        const logger2 = createLogger2(`[${opts.name}][${socket.id}][postAuth]`);
+        const logger2 = __privateGet(this, _logger2).child({
+          socketId: socket.id,
+          socketStage: "auth"
+        });
         if (typeof opts.postAuth === "function") {
           await opts.postAuth(socket, next, logger2);
         }
       });
     }
     this.namespace.on("connection", async (socket) => {
-      const logger2 = createLogger2(`[${opts.name}][${socket.id}]`);
-      logger2("connection");
+      const logger2 = __privateGet(this, _logger2).child({
+        socketId: socket.id,
+        socketStage: "connection"
+      });
+      logger2.info("connected");
       __privateGet(this, _handler2).registerHandlers(socket, logger2);
       socket.on("disconnect", async (reason, description) => {
-        logger2("disconnect", {
+        logger2.info("disconnect", {
           reason,
           description
         });
@@ -2034,7 +2256,9 @@ var _ZodNamespace = class _ZodNamespace {
         }
       });
       socket.on("error", async (error) => {
-        logger2("error", error);
+        logger2.error("error", {
+          error
+        });
         if (opts.onError) {
           await opts.onError(socket, error, logger2);
         }
@@ -2048,13 +2272,10 @@ var _ZodNamespace = class _ZodNamespace {
     return this.namespace.fetchSockets();
   }
 };
+_logger2 = new WeakMap();
 _handler2 = new WeakMap();
 __name(_ZodNamespace, "ZodNamespace");
 var ZodNamespace = _ZodNamespace;
-function createLogger2(prefix) {
-  return (...args) => console.log(prefix, ...args);
-}
-__name(createLogger2, "createLogger");
 var messageSchema2 = zod.z.object({
   version: zod.z.literal("v1").default("v1"),
   type: zod.z.string(),
@@ -2829,6 +3050,7 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
   }
   async waitForDuration(ms) {
     let timeout;
+    const now = Date.now();
     const resolveAfterDuration = new Promise((resolve) => {
       timeout = setTimeout(resolve, ms);
     });
@@ -2843,13 +3065,19 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
       };
     });
     const { willCheckpointAndRestore } = await this.ipc.sendWithAck("WAIT_FOR_DURATION", {
-      ms
+      ms,
+      now
     });
     if (!willCheckpointAndRestore) {
       await resolveAfterDuration;
       return;
     }
-    await waitForRestore;
+    this.ipc.send("READY_FOR_CHECKPOINT", {});
+    await Promise.race([
+      waitForRestore,
+      resolveAfterDuration
+    ]);
+    this.ipc.send("CANCEL_CHECKPOINT", {});
     clearTimeout(timeout);
   }
   resumeAfterRestore() {
@@ -2870,7 +3098,7 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
       });
     });
     await this.ipc.send("WAIT_FOR_TASK", {
-      id: params.id
+      friendlyId: params.id
     });
     return await promise;
   }
@@ -2890,8 +3118,8 @@ var _ProdRuntimeManager = class _ProdRuntimeManager {
       });
     }));
     await this.ipc.send("WAIT_FOR_BATCH", {
-      id: params.id,
-      runs: params.runs
+      batchFriendlyId: params.id,
+      runFriendlyIds: params.runs
     });
     const results = await promise;
     return {
@@ -3184,6 +3412,16 @@ var defaultRetryOptions = {
   maxTimeoutInMs: 6e4,
   randomize: true
 };
+var defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions
+    }
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions
+};
 function calculateNextRetryDelay(options, attempt) {
   const opts = {
     ...defaultRetryOptions,
@@ -3814,6 +4052,7 @@ exports.ExceptionEventProperties = ExceptionEventProperties;
 exports.ExceptionSpanEvent = ExceptionSpanEvent;
 exports.ExternalBuildData = ExternalBuildData;
 exports.FetchRetryBackoffStrategy = FetchRetryBackoffStrategy;
+exports.FetchRetryByStatusOptions = FetchRetryByStatusOptions;
 exports.FetchRetryHeadersStrategy = FetchRetryHeadersStrategy;
 exports.FetchRetryOptions = FetchRetryOptions;
 exports.FetchRetryStrategy = FetchRetryStrategy;
@@ -3849,9 +4088,11 @@ exports.RateLimitOptions = RateLimitOptions;
 exports.RetryOptions = RetryOptions;
 exports.SemanticInternalAttributes = SemanticInternalAttributes;
 exports.SharedQueueToClientMessages = SharedQueueToClientMessages;
+exports.SimpleStructuredLogger = SimpleStructuredLogger;
 exports.SlidingWindowRateLimit = SlidingWindowRateLimit;
 exports.SpanEvent = SpanEvent;
 exports.SpanEvents = SpanEvents;
+exports.SpanMessagingEvent = SpanMessagingEvent;
 exports.StartDeploymentIndexingRequestBody = StartDeploymentIndexingRequestBody;
 exports.StartDeploymentIndexingResponseBody = StartDeploymentIndexingResponseBody;
 exports.TaskContextSpanProcessor = TaskContextSpanProcessor;
@@ -3886,6 +4127,7 @@ exports.TriggerTaskRequestBody = TriggerTaskRequestBody;
 exports.TriggerTaskResponse = TriggerTaskResponse;
 exports.TriggerTracer = TriggerTracer;
 exports.UncaughtExceptionMessage = UncaughtExceptionMessage;
+exports.WaitReason = WaitReason;
 exports.WhoAmIResponseSchema = WhoAmIResponseSchema;
 exports.ZodIpcConnection = ZodIpcConnection;
 exports.ZodMessageHandler = ZodMessageHandler;
@@ -3904,6 +4146,7 @@ exports.childToWorkerMessages = childToWorkerMessages;
 exports.clientWebsocketMessages = clientWebsocketMessages;
 exports.correctErrorStackTrace = correctErrorStackTrace;
 exports.createErrorTaskError = createErrorTaskError;
+exports.defaultFetchRetryOptions = defaultFetchRetryOptions;
 exports.defaultRetryOptions = defaultRetryOptions;
 exports.detectDependencyVersion = detectDependencyVersion;
 exports.eventFilterMatches = eventFilterMatches;