@aikirun/worker 0.16.0 → 0.18.0

package/README.md

@@ -15,6 +15,7 @@ import { worker } from "@aikirun/worker";
 import { client } from "@aikirun/client";
 import { orderWorkflowV1 } from "./workflows.ts";
 
+// Set AIKI_API_KEY env variable or pass apiKey option
 const aikiClient = client({
 	url: "http://localhost:9850",
 	redis: { host: "localhost", port: 6379 },

package/dist/index.d.ts

@@ -9,10 +9,7 @@ type IsSubtype<SubT, SuperT> = SubT extends SuperT ? true : false;
 type And<T extends NonEmptyArray<boolean>> = T extends [infer First, ...infer Rest] ? false extends First ? false : Rest extends NonEmptyArray<boolean> ? And<Rest> : true : never;
 type Or<T extends NonEmptyArray<boolean>> = T extends [infer First, ...infer Rest] ? true extends First ? true : Rest extends NonEmptyArray<boolean> ? Or<Rest> : false : never;
 type PathFromObject<T, IncludeArrayKeys extends boolean = false> = T extends T ? PathFromObjectInternal<T, IncludeArrayKeys> : never;
-type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[
-    IsSubtype<T, object>,
-    Or<[IncludeArrayKeys, NonArrayObject<T> extends never ? false : true]>
-]> extends true ? {
+type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[IsSubtype<T, object>, Or<[IncludeArrayKeys, NonArrayObject<T> extends never ? false : true]>]> extends true ? {
     [K in Exclude<keyof T, symbol>]-?: And<[
         IsSubtype<NonNullable<T[K]>, object>,
         Or<[IncludeArrayKeys, NonArrayObject<NonNullable<T[K]>> extends never ? false : true]>

package/dist/index.js

@@ -1,6 +1,6 @@
 // ../../lib/array/utils.ts
 function isNonEmptyArray(value) {
-  return value.length > 0;
+  return value !== void 0 && value.length > 0;
 }
 
 // ../../lib/async/delay.ts
@@ -22,13 +22,6 @@ function delay(ms, options) {
   });
 }
 
-// ../../lib/async/fire-and-forget.ts
-function fireAndForget(promise, onError) {
-  promise.catch((error) => {
-    onError(error instanceof Error ? error : new Error(String(error)));
-  });
-}
-
 // ../../lib/object/overrider.ts
 function set(obj, path, value) {
   const keys = path.split(".");
@@ -60,18 +53,1230 @@ var objectOverrider = (defaultObj) => (obj) => {
 };
 
 // worker.ts
-import { INTERNAL } from "@aikirun/types/symbols";
+import { INTERNAL as INTERNAL7 } from "@aikirun/types/symbols";
 import {
-  WorkflowRunFailedError,
-  WorkflowRunNotExecutableError,
-  WorkflowRunSuspendedError
+  NonDeterminismError as NonDeterminismError3,
+  WorkflowRunFailedError as WorkflowRunFailedError4,
+  WorkflowRunNotExecutableError as WorkflowRunNotExecutableError2,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError6,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError5
 } from "@aikirun/types/workflow-run";
 import {
   createEventWaiters,
+  createReplayManifest,
   createSleeper,
   workflowRegistry,
-  workflowRunHandle
+  workflowRunHandle as workflowRunHandle2
 } from "@aikirun/workflow";
+
+// ../workflow/system/cancel-child-runs.ts
+import { NON_TERMINAL_WORKFLOW_RUN_STATUSES } from "@aikirun/types/workflow-run";
+
+// ../../lib/address/index.ts
+function getTaskAddress(name, inputHash) {
+  return `${name}:${inputHash}`;
+}
+function getWorkflowRunAddress(name, versionId, referenceId) {
+  return `${name}:${versionId}:${referenceId}`;
+}
+
+// ../../lib/crypto/hash.ts
+import { createHash } from "crypto";
+
+// ../../lib/json/stable-stringify.ts
+function stableStringify(value) {
+  return stringifyValue(value);
+}
+function stringifyValue(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stringifyValue).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const pairs = [];
+  for (const key of keys) {
+    const keyValue = value[key];
+    if (keyValue !== void 0) {
+      pairs.push(`${JSON.stringify(key)}:${stringifyValue(keyValue)}`);
+    }
+  }
+  return `{${pairs.join(",")}}`;
+}
+
+// ../../lib/crypto/hash.ts
+async function sha256(input) {
+  const data = new TextEncoder().encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function hashInput(input) {
+  return sha256(stableStringify({ input }));
+}
+
+// ../../lib/error/serializable.ts
+function createSerializableError(error) {
+  return error instanceof Error ? {
+    message: error.message,
+    name: error.name,
+    stack: error.stack,
+    cause: error.cause ? createSerializableError(error.cause) : void 0
+  } : {
+    message: String(error),
+    name: "UnknownError"
+  };
+}
+
+// ../../lib/retry/strategy.ts
+function withRetry(fn, strategy, options) {
+  return {
+    run: async (...args) => {
+      let attempts = 0;
+      while (true) {
+        if (options?.abortSignal?.aborted) {
+          return {
+            state: "aborted",
+            reason: options.abortSignal.reason
+          };
+        }
+        attempts++;
+        let result;
+        try {
+          result = await fn(...args);
+          if (options?.shouldRetryOnResult === void 0 || !await options.shouldRetryOnResult(result)) {
+            return {
+              state: "completed",
+              result,
+              attempts
+            };
+          }
+        } catch (err) {
+          if (options?.shouldNotRetryOnError !== void 0 && await options.shouldNotRetryOnError(err)) {
+            throw err;
+          }
+        }
+        const retryParams = getRetryParams(attempts, strategy);
+        if (!retryParams.retriesLeft) {
+          return {
+            state: "timeout"
+          };
+        }
+        await delay(retryParams.delayMs, { abortSignal: options?.abortSignal });
+      }
+    }
+  };
+}
+function getRetryParams(attempts, strategy) {
+  const strategyType = strategy.type;
+  switch (strategyType) {
+    case "never":
+      return {
+        retriesLeft: false
+      };
+    case "fixed":
+      if (attempts >= strategy.maxAttempts) {
+        return {
+          retriesLeft: false
+        };
+      }
+      return {
+        retriesLeft: true,
+        delayMs: strategy.delayMs
+      };
+    case "exponential": {
+      if (attempts >= strategy.maxAttempts) {
+        return {
+          retriesLeft: false
+        };
+      }
+      const delayMs = strategy.baseDelayMs * (strategy.factor ?? 2) ** (attempts - 1);
+      return {
+        retriesLeft: true,
+        delayMs: Math.min(delayMs, strategy.maxDelayMs ?? Number.POSITIVE_INFINITY)
+      };
+    }
+    case "jittered": {
+      if (attempts >= strategy.maxAttempts) {
+        return {
+          retriesLeft: false
+        };
+      }
+      const base = strategy.baseDelayMs * (strategy.jitterFactor ?? 2) ** (attempts - 1);
+      const delayMs = Math.random() * base;
+      return {
+        retriesLeft: true,
+        delayMs: Math.min(delayMs, strategy.maxDelayMs ?? Number.POSITIVE_INFINITY)
+      };
+    }
+    default:
+      return strategyType;
+  }
+}
+
+// ../task/task.ts
+import { INTERNAL } from "@aikirun/types/symbols";
+import { TaskFailedError } from "@aikirun/types/task";
+import {
+  NonDeterminismError,
+  WorkflowRunFailedError,
+  WorkflowRunRevisionConflictError,
+  WorkflowRunSuspendedError
+} from "@aikirun/types/workflow-run";
+function task(params) {
+  return new TaskImpl(params);
+}
+var TaskImpl = class {
+  constructor(params) {
+    this.params = params;
+    this.name = params.name;
+  }
+  name;
+  with() {
+    const startOpts = this.params.opts ?? {};
+    const startOptsOverrider = objectOverrider(startOpts);
+    return new TaskBuilderImpl(this, startOptsOverrider());
+  }
+  async start(run, ...args) {
+    return this.startWithOpts(run, this.params.opts ?? {}, ...args);
+  }
+  async startWithOpts(run, startOpts, ...args) {
+    const handle = run[INTERNAL].handle;
+    handle[INTERNAL].assertExecutionAllowed();
+    const inputRaw = args[0];
+    const input = await this.parse(handle, this.params.schema?.input, inputRaw, run.logger);
+    const inputHash = await hashInput(input);
+    const address = getTaskAddress(this.name, inputHash);
+    const replayManifest = run[INTERNAL].replayManifest;
+    if (replayManifest.hasUnconsumedEntries()) {
+      const existingTaskInfo = replayManifest.consumeNextTask(address);
+      if (existingTaskInfo) {
+        return this.getExistingTaskResult(run, handle, startOpts, input, existingTaskInfo);
+      }
+      await this.throwNonDeterminismError(run, handle, inputHash, replayManifest);
+    }
+    const attempts = 1;
+    const retryStrategy = startOpts.retry ?? { type: "never" };
+    const taskInfo = await handle[INTERNAL].transitionTaskState({
+      type: "create",
+      taskName: this.name,
+      options: startOpts,
+      taskState: { status: "running", attempts, input }
+    });
+    const logger = run.logger.child({
+      "aiki.component": "task-execution",
+      "aiki.taskName": this.name,
+      "aiki.taskId": taskInfo.id
+    });
+    logger.info("Task started", { "aiki.attempts": attempts });
+    const { output, lastAttempt } = await this.tryExecuteTask(
+      handle,
+      input,
+      taskInfo.id,
+      retryStrategy,
+      attempts,
+      run[INTERNAL].options.spinThresholdMs,
+      logger
+    );
+    await handle[INTERNAL].transitionTaskState({
+      taskId: taskInfo.id,
+      taskState: { status: "completed", attempts: lastAttempt, output }
+    });
+    logger.info("Task complete", { "aiki.attempts": lastAttempt });
+    return output;
+  }
+  async getExistingTaskResult(run, handle, startOpts, input, existingTaskInfo) {
+    const existingTaskState = existingTaskInfo.state;
+    if (existingTaskState.status === "completed") {
+      return this.parse(handle, this.params.schema?.output, existingTaskState.output, run.logger);
+    }
+    if (existingTaskState.status === "failed") {
+      throw new TaskFailedError(
+        existingTaskInfo.id,
+        existingTaskState.attempts,
+        existingTaskState.error.message
+      );
+    }
+    existingTaskState.status;
+    const attempts = existingTaskState.attempts;
+    const retryStrategy = startOpts.retry ?? { type: "never" };
+    this.assertRetryAllowed(existingTaskInfo.id, attempts, retryStrategy, run.logger);
+    run.logger.debug("Retrying task", {
+      "aiki.taskName": this.name,
+      "aiki.taskId": existingTaskInfo.id,
+      "aiki.attempts": attempts,
+      "aiki.taskStatus": existingTaskState.status
+    });
+    return this.retryAndExecute(run, handle, input, existingTaskInfo.id, startOpts, retryStrategy, attempts);
+  }
+  async throwNonDeterminismError(run, handle, inputHash, manifest) {
+    const unconsumedManifestEntries = manifest.getUnconsumedEntries();
+    run.logger.error("Replay divergence", {
+      "aiki.taskName": this.name,
+      "aiki.inputHash": inputHash,
+      "aiki.unconsumedManifestEntries": unconsumedManifestEntries
+    });
+    const error = new NonDeterminismError(run.id, handle.run.attempts, unconsumedManifestEntries);
+    await handle[INTERNAL].transitionState({
+      status: "failed",
+      cause: "self",
+      error: createSerializableError(error)
+    });
+    throw error;
+  }
+  async retryAndExecute(run, handle, input, taskId, startOpts, retryStrategy, previousAttempts) {
+    const attempts = previousAttempts + 1;
+    const taskInfo = await handle[INTERNAL].transitionTaskState({
+      type: "retry",
+      taskId,
+      options: startOpts,
+      taskState: { status: "running", attempts, input }
+    });
+    const logger = run.logger.child({
+      "aiki.component": "task-execution",
+      "aiki.taskName": this.name,
+      "aiki.taskId": taskInfo.id
+    });
+    logger.info("Task started", { "aiki.attempts": attempts });
+    const { output, lastAttempt } = await this.tryExecuteTask(
+      handle,
+      input,
+      taskInfo.id,
+      retryStrategy,
+      attempts,
+      run[INTERNAL].options.spinThresholdMs,
+      logger
+    );
+    await handle[INTERNAL].transitionTaskState({
+      taskId: taskInfo.id,
+      taskState: { status: "completed", attempts: lastAttempt, output }
+    });
+    logger.info("Task complete", { "aiki.attempts": lastAttempt });
+    return output;
+  }
+  async tryExecuteTask(handle, input, taskId, retryStrategy, currentAttempt, spinThresholdMs, logger) {
+    let attempts = currentAttempt;
+    while (true) {
+      try {
+        const outputRaw = await this.params.handler(input);
+        const output = await this.parse(handle, this.params.schema?.output, outputRaw, logger);
+        return { output, lastAttempt: attempts };
+      } catch (error) {
+        if (error instanceof WorkflowRunSuspendedError || error instanceof WorkflowRunFailedError || error instanceof WorkflowRunRevisionConflictError) {
+          throw error;
+        }
+        const serializableError = createSerializableError(error);
+        const retryParams = getRetryParams(attempts, retryStrategy);
+        if (!retryParams.retriesLeft) {
+          logger.error("Task failed", {
+            "aiki.attempts": attempts,
+            "aiki.reason": serializableError.message
+          });
+          await handle[INTERNAL].transitionTaskState({
+            taskId,
+            taskState: { status: "failed", attempts, error: serializableError }
+          });
+          throw new TaskFailedError(taskId, attempts, serializableError.message);
+        }
+        logger.debug("Task failed. It will be retried", {
+          "aiki.attempts": attempts,
+          "aiki.nextAttemptInMs": retryParams.delayMs,
+          "aiki.reason": serializableError.message
+        });
+        if (retryParams.delayMs <= spinThresholdMs) {
+          await delay(retryParams.delayMs);
+          attempts++;
+          continue;
+        }
+        await handle[INTERNAL].transitionTaskState({
+          taskId,
+          taskState: {
+            status: "awaiting_retry",
+            attempts,
+            error: serializableError,
+            nextAttemptInMs: retryParams.delayMs
+          }
+        });
+        throw new WorkflowRunSuspendedError(handle.run.id);
+      }
+    }
+  }
+  assertRetryAllowed(taskId, attempts, retryStrategy, logger) {
+    const retryParams = getRetryParams(attempts, retryStrategy);
+    if (!retryParams.retriesLeft) {
+      logger.error("Task retry not allowed", {
+        "aiki.taskName": this.name,
+        "aiki.taskId": taskId,
+        "aiki.attempts": attempts
+      });
+      throw new TaskFailedError(taskId, attempts, "Task retry not allowed");
+    }
+  }
+  async parse(handle, schema, data, logger) {
+    if (!schema) {
+      return data;
+    }
+    const schemaValidation = schema["~standard"].validate(data);
+    const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+    if (!schemaValidationResult.issues) {
+      return schemaValidationResult.value;
+    }
+    logger.error("Invalid task data", { "aiki.issues": schemaValidationResult.issues });
+    await handle[INTERNAL].transitionState({
+      status: "failed",
+      cause: "self",
+      error: {
+        name: "SchemaValidationError",
+        message: JSON.stringify(schemaValidationResult.issues)
+      }
+    });
+    throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
+  }
+};
+var TaskBuilderImpl = class _TaskBuilderImpl {
+  constructor(task2, startOptsBuilder) {
+    this.task = task2;
+    this.startOptsBuilder = startOptsBuilder;
+  }
+  opt(path, value) {
+    return new _TaskBuilderImpl(this.task, this.startOptsBuilder.with(path, value));
+  }
+  start(run, ...args) {
+    return this.task.startWithOpts(run, this.startOptsBuilder.build(), ...args);
+  }
+};
+
+// ../workflow/workflow.ts
+import { INTERNAL as INTERNAL6 } from "@aikirun/types/symbols";
+
+// ../workflow/workflow-version.ts
+import { INTERNAL as INTERNAL5 } from "@aikirun/types/symbols";
+import { TaskFailedError as TaskFailedError2 } from "@aikirun/types/task";
+import { SchemaValidationError as SchemaValidationError2 } from "@aikirun/types/validator";
+import {
+  NonDeterminismError as NonDeterminismError2,
+  WorkflowRunFailedError as WorkflowRunFailedError3,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError5,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError4
+} from "@aikirun/types/workflow-run";
+
+// ../../lib/duration/convert.ts
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 60 * MS_PER_SECOND;
+var MS_PER_HOUR = 60 * MS_PER_MINUTE;
+var MS_PER_DAY = 24 * MS_PER_HOUR;
+function toMilliseconds(duration) {
+  if (typeof duration === "number") {
+    assertIsPositiveNumber(duration);
+    return duration;
+  }
+  let totalMs = 0;
+  if (duration.days !== void 0) {
+    assertIsPositiveNumber(duration.days, "days");
+    totalMs += duration.days * MS_PER_DAY;
+  }
+  if (duration.hours !== void 0) {
+    assertIsPositiveNumber(duration.hours, "hours");
+    totalMs += duration.hours * MS_PER_HOUR;
+  }
+  if (duration.minutes !== void 0) {
+    assertIsPositiveNumber(duration.minutes, "minutes");
+    totalMs += duration.minutes * MS_PER_MINUTE;
+  }
+  if (duration.seconds !== void 0) {
+    assertIsPositiveNumber(duration.seconds, "seconds");
+    totalMs += duration.seconds * MS_PER_SECOND;
+  }
+  if (duration.milliseconds !== void 0) {
+    assertIsPositiveNumber(duration.milliseconds, "milliseconds");
+    totalMs += duration.milliseconds;
+  }
+  return totalMs;
+}
+function assertIsPositiveNumber(value, field) {
+  if (!Number.isFinite(value)) {
+    throw new Error(
+      field !== void 0 ? `'${field}' duration must be finite. Received: ${value}` : `Duration must be finite. Received: ${value}`
+    );
+  }
+  if (value < 0) {
+    throw new Error(
+      field !== void 0 ? `'${field}' duration must be non-negative. Received: ${value}` : `Duration must be non-negative. Received: ${value}`
+    );
+  }
+}
+
+// ../workflow/run/event.ts
+import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
+import { SchemaValidationError } from "@aikirun/types/validator";
+import {
+  WorkflowRunFailedError as WorkflowRunFailedError2,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError2,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError2
+} from "@aikirun/types/workflow-run";
+function createEventSenders(api, workflowRunId, eventsDefinition, logger) {
+  const senders = {};
+  for (const [eventName, eventDefinition] of Object.entries(eventsDefinition)) {
+    const sender = createEventSender(
+      api,
+      workflowRunId,
+      eventName,
+      eventDefinition.schema,
+      logger.child({ "aiki.eventName": eventName })
+    );
+    senders[eventName] = sender;
+  }
+  return senders;
+}
+function createEventSender(api, workflowRunId, eventName, schema, logger, options) {
+  const optsOverrider = objectOverrider(options ?? {});
+  const createBuilder = (optsBuilder) => ({
+    opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+    send: (...args) => createEventSender(api, workflowRunId, eventName, schema, logger, optsBuilder.build()).send(...args)
+  });
+  async function send(...args) {
+    let data = args[0];
+    if (schema) {
+      const schemaValidation = schema["~standard"].validate(data);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        logger.error("Invalid event data", { "aiki.issues": schemaValidationResult.issues });
+        throw new SchemaValidationError("Invalid event data", schemaValidationResult.issues);
+      }
+      data = schemaValidationResult.value;
+    }
+    await api.workflowRun.sendEventV1({
+      id: workflowRunId,
+      eventName,
+      data,
+      options
+    });
+    logger.info("Sent event to workflow", {
+      ...options?.reference ? { "aiki.referenceId": options.reference.id } : {}
+    });
+  }
+  return {
+    with: () => createBuilder(optsOverrider()),
+    send
+  };
+}
+function createEventMulticasters(workflowName, workflowVersionId, eventsDefinition) {
+  const senders = {};
+  for (const [eventName, eventDefinition] of Object.entries(eventsDefinition)) {
+    const sender = createEventMulticaster(
+      workflowName,
+      workflowVersionId,
+      eventName,
+      eventDefinition.schema
+    );
+    senders[eventName] = sender;
+  }
+  return senders;
+}
+function createEventMulticaster(workflowName, workflowVersionId, eventName, schema, options) {
+  const optsOverrider = objectOverrider(options ?? {});
+  const createBuilder = (optsBuilder) => ({
+    opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+    send: (client, runId, ...args) => createEventMulticaster(workflowName, workflowVersionId, eventName, schema, optsBuilder.build()).send(
+      client,
+      runId,
+      ...args
+    ),
+    sendByReferenceId: (client, referenceId, ...args) => createEventMulticaster(workflowName, workflowVersionId, eventName, schema, optsBuilder.build()).sendByReferenceId(
+      client,
+      referenceId,
+      ...args
+    )
+  });
+  async function send(client, runId, ...args) {
+    let data = args[0];
+    if (schema) {
+      const schemaValidation = schema["~standard"].validate(data);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        client.logger.error("Invalid event data", {
+          "aiki.workflowName": workflowName,
+          "aiki.workflowVersionId": workflowVersionId,
+          "aiki.eventName": eventName,
+          "aiki.issues": schemaValidationResult.issues
+        });
+        throw new SchemaValidationError("Invalid event data", schemaValidationResult.issues);
+      }
+      data = schemaValidationResult.value;
+    }
+    const runIds = Array.isArray(runId) ? runId : [runId];
+    if (!isNonEmptyArray(runIds)) {
+      return;
+    }
+    await client.api.workflowRun.multicastEventV1({
+      ids: runIds,
+      eventName,
+      data,
+      options
+    });
+    client.logger.info("Multicasted event to workflows", {
+      "aiki.workflowName": workflowName,
+      "aiki.workflowVersionId": workflowVersionId,
+      "aiki.workflowRunIds": runIds,
+      "aiki.eventName": eventName,
+      ...options?.reference ? { "aiki.eventReferenceId": options.reference.id } : {}
+    });
+  }
+  async function sendByReferenceId(client, referenceId, ...args) {
+    let data = args[0];
+    if (schema) {
+      const schemaValidation = schema["~standard"].validate(data);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        client.logger.error("Invalid event data", {
+          "aiki.workflowName": workflowName,
+          "aiki.workflowVersionId": workflowVersionId,
+          "aiki.eventName": eventName,
+          "aiki.issues": schemaValidationResult.issues
+        });
+        throw new SchemaValidationError("Invalid event data", schemaValidationResult.issues);
+      }
+      data = schemaValidationResult.value;
+    }
+    const referenceIds = Array.isArray(referenceId) ? referenceId : [referenceId];
+    if (!isNonEmptyArray(referenceIds)) {
+      return;
+    }
+    await client.api.workflowRun.multicastEventByReferenceV1({
+      references: referenceIds.map((referenceId2) => ({
+        name: workflowName,
+        versionId: workflowVersionId,
+        referenceId: referenceId2
+      })),
+      eventName,
+      data,
+      options
+    });
+    client.logger.info("Multicasted event by reference", {
+      "aiki.workflowName": workflowName,
+      "aiki.workflowVersionId": workflowVersionId,
+      "aiki.referenceIds": referenceIds,
+      "aiki.eventName": eventName,
+      ...options?.reference ? { "aiki.eventReferenceId": options.reference.id } : {}
+    });
+  }
+  return {
+    with: () => createBuilder(optsOverrider()),
+    send,
+    sendByReferenceId
+  };
+}
+
+// ../workflow/run/handle.ts
+import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
+import {
+  isTerminalWorkflowRunStatus,
+  WorkflowRunNotExecutableError,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError3
+} from "@aikirun/types/workflow-run";
+async function workflowRunHandle(client, runOrId, eventsDefinition, logger) {
+  const run = typeof runOrId !== "string" ? runOrId : (await client.api.workflowRun.getByIdV1({ id: runOrId })).run;
+  return new WorkflowRunHandleImpl(
+    client,
+    run,
+    eventsDefinition ?? {},
+    logger ?? client.logger.child({
+      "aiki.workflowName": run.name,
+      "aiki.workflowVersionId": run.versionId,
+      "aiki.workflowRunId": run.id
+    })
+  );
+}
+var WorkflowRunHandleImpl = class {
+  constructor(client, _run, eventsDefinition, logger) {
+    this._run = _run;
+    this.logger = logger;
+    this.api = client.api;
+    this.events = createEventSenders(client.api, this._run.id, eventsDefinition, this.logger);
+    this[INTERNAL3] = {
+      client,
+      transitionState: this.transitionState.bind(this),
+      transitionTaskState: this.transitionTaskState.bind(this),
+      assertExecutionAllowed: this.assertExecutionAllowed.bind(this)
+    };
+  }
+  api;
+  events;
+  [INTERNAL3];
+  get run() {
+    return this._run;
+  }
+  async refresh() {
+    const { run: currentRun } = await this.api.workflowRun.getByIdV1({ id: this.run.id });
+    this._run = currentRun;
+  }
+  // TODO: instead checking the current state, use the transition history
+  // because it is possible for a workflow to flash though a state
+  // and the handle will never know that the workflow hit that state
+  async waitForStatus(status, options) {
+    return this.waitForStatusByPolling(status, options);
+  }
+  async waitForStatusByPolling(expectedStatus, options) {
+    if (options?.abortSignal?.aborted) {
+      return {
+        success: false,
+        cause: "aborted"
+      };
+    }
+    const delayMs = options?.interval ? toMilliseconds(options.interval) : 1e3;
+    const maxAttempts = options?.timeout ? Math.ceil(toMilliseconds(options.timeout) / delayMs) : Number.POSITIVE_INFINITY;
+    const retryStrategy = { type: "fixed", maxAttempts, delayMs };
+    const loadState = async () => {
+      await this.refresh();
+      return this.run.state;
+    };
+    const isNeitherExpectedNorTerminal = (state) => state.status !== expectedStatus && !isTerminalWorkflowRunStatus(state.status);
+    if (!Number.isFinite(maxAttempts) && !options?.abortSignal) {
+      const maybeResult2 = await withRetry(loadState, retryStrategy, {
+        shouldRetryOnResult: async (state) => isNeitherExpectedNorTerminal(state)
+      }).run();
+      if (maybeResult2.state === "timeout") {
+        throw new Error("Something's wrong, this should've never timed out");
+      }
+      if (maybeResult2.result.status !== expectedStatus) {
+        return {
+          success: false,
+          cause: "run_terminated"
+        };
+      }
+      return {
+        success: true,
+        state: maybeResult2.result
+      };
+    }
+    const maybeResult = options?.abortSignal ? await withRetry(loadState, retryStrategy, {
+      abortSignal: options.abortSignal,
+      shouldRetryOnResult: async (state) => isNeitherExpectedNorTerminal(state)
+    }).run() : await withRetry(loadState, retryStrategy, {
+      shouldRetryOnResult: async (state) => isNeitherExpectedNorTerminal(state)
+    }).run();
+    this.logger.info("Maybe result", { maybeResult });
+    if (maybeResult.state === "completed") {
+      if (maybeResult.result.status !== expectedStatus) {
+        return {
+          success: false,
+          cause: "run_terminated"
+        };
+      }
+      return {
+        success: true,
+        state: maybeResult.result
+      };
+    }
+    return { success: false, cause: maybeResult.state };
+  }
+  async cancel(reason) {
+    await this.transitionState({ status: "cancelled", reason });
+    this.logger.info("Workflow cancelled");
+  }
+  async pause() {
+    await this.transitionState({ status: "paused" });
+    this.logger.info("Workflow paused");
+  }
+  async resume() {
+    await this.transitionState({ status: "scheduled", scheduledInMs: 0, reason: "resume" });
+    this.logger.info("Workflow resumed");
+  }
+  async awake() {
+    await this.transitionState({ status: "scheduled", scheduledInMs: 0, reason: "awake_early" });
+    this.logger.info("Workflow awoken");
+  }
+  async transitionState(targetState) {
+    try {
+      let response;
+      if (targetState.status === "scheduled" && (targetState.reason === "new" || targetState.reason === "resume" || targetState.reason === "awake_early") || targetState.status === "paused" || targetState.status === "cancelled") {
+        response = await this.api.workflowRun.transitionStateV1({
+          type: "pessimistic",
+          id: this.run.id,
+          state: targetState
+        });
+      } else {
+        response = await this.api.workflowRun.transitionStateV1({
+          type: "optimistic",
+          id: this.run.id,
+          state: targetState,
+          expectedRevision: this.run.revision
+        });
+      }
+      this._run.revision = response.revision;
+      this._run.state = response.state;
+      this._run.attempts = response.attempts;
+    } catch (error) {
+      if (isWorkflowRunRevisionConflictError(error)) {
+        throw new WorkflowRunRevisionConflictError3(this.run.id);
+      }
+      throw error;
+    }
+  }
+  async transitionTaskState(request) {
+    try {
+      const { taskInfo } = await this.api.workflowRun.transitionTaskStateV1({
+        ...request,
+        id: this.run.id,
+        expectedWorkflowRunRevision: this.run.revision
+      });
+      return taskInfo;
+    } catch (error) {
+      if (isWorkflowRunRevisionConflictError(error)) {
+        throw new WorkflowRunRevisionConflictError3(this.run.id);
+      }
+      throw error;
+    }
+  }
+  assertExecutionAllowed() {
+    const status = this.run.state.status;
+    if (status !== "queued" && status !== "running") {
+      throw new WorkflowRunNotExecutableError(this.run.id, status);
+    }
+  }
+};
+function isWorkflowRunRevisionConflictError(error) {
+  return error != null && typeof error === "object" && "code" in error && error.code === "WORKFLOW_RUN_REVISION_CONFLICT";
+}
+
+// ../workflow/run/handle-child.ts
+import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
+import {
+  isTerminalWorkflowRunStatus as isTerminalWorkflowRunStatus2,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError4,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError3
+} from "@aikirun/types/workflow-run";
+async function childWorkflowRunHandle(client, run, parentRun, childWorkflowRunWaitQueues, logger, eventsDefinition) {
+  const handle = await workflowRunHandle(client, run, eventsDefinition, logger);
+  return {
+    run: handle.run,
+    events: handle.events,
+    refresh: handle.refresh.bind(handle),
+    waitForStatus: createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logger),
+    cancel: handle.cancel.bind(handle),
+    pause: handle.pause.bind(handle),
+    resume: handle.resume.bind(handle),
+    awake: handle.awake.bind(handle),
+    [INTERNAL4]: handle[INTERNAL4]
+  };
+}
+function createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logger) {
+  const nextIndexByStatus = {
+    cancelled: 0,
+    completed: 0,
+    failed: 0
+  };
+  async function waitForStatus(expectedStatus, options) {
+    const parentRunHandle = parentRun[INTERNAL4].handle;
+    const nextIndex = nextIndexByStatus[expectedStatus];
+    const { run } = handle;
+    const childWorkflowRunWaits = childWorkflowRunWaitQueues[expectedStatus].childWorkflowRunWaits;
+    const existingChildWorkflowRunWait = childWorkflowRunWaits[nextIndex];
+    if (existingChildWorkflowRunWait) {
+      nextIndexByStatus[expectedStatus] = nextIndex + 1;
+      if (existingChildWorkflowRunWait.status === "timeout") {
+        logger.debug("Timed out waiting for child workflow status", {
+          "aiki.childWorkflowExpectedStatus": expectedStatus
+        });
+        return {
+          success: false,
+          cause: "timeout"
+        };
+      }
+      const childWorkflowRunStatus = existingChildWorkflowRunWait.childWorkflowRunState.status;
+      if (childWorkflowRunStatus === expectedStatus) {
+        return {
+          success: true,
+          state: existingChildWorkflowRunWait.childWorkflowRunState
+        };
+      }
+      if (isTerminalWorkflowRunStatus2(childWorkflowRunStatus)) {
+        logger.debug("Child workflow run reached termnial state", {
+          "aiki.childWorkflowTerminalStatus": childWorkflowRunStatus
+        });
+        return {
+          success: false,
+          cause: "run_terminated"
+        };
+      }
+      childWorkflowRunStatus;
+    }
+    const timeoutInMs = options?.timeout && toMilliseconds(options.timeout);
+    try {
+      await parentRunHandle[INTERNAL4].transitionState({
+        status: "awaiting_child_workflow",
+        childWorkflowRunId: run.id,
+        childWorkflowRunStatus: expectedStatus,
+        timeoutInMs
+      });
+      logger.info("Waiting for child Workflow", {
+        "aiki.childWorkflowExpectedStatus": expectedStatus,
+        ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
+      });
+    } catch (error) {
+      if (error instanceof WorkflowRunRevisionConflictError4) {
+        throw new WorkflowRunSuspendedError3(parentRun.id);
+      }
+      throw error;
+    }
+    throw new WorkflowRunSuspendedError3(parentRun.id);
+  }
+  return waitForStatus;
+}
+
+// ../workflow/workflow-version.ts
+var WorkflowVersionImpl = class {
+  constructor(name, versionId, params) {
+    this.name = name;
+    this.versionId = versionId;
+    this.params = params;
+    const eventsDefinition = this.params.events ?? {};
+    this.events = createEventMulticasters(this.name, this.versionId, eventsDefinition);
+    this[INTERNAL5] = {
+      eventsDefinition,
+      handler: this.handler.bind(this)
+    };
+  }
+  events;
+  [INTERNAL5];
+  with() {
+    const startOpts = this.params.opts ?? {};
+    const startOptsOverrider = objectOverrider(startOpts);
+    return new WorkflowBuilderImpl(this, startOptsOverrider());
+  }
+  async start(client, ...args) {
+    return this.startWithOpts(client, this.params.opts ?? {}, ...args);
+  }
+  async startWithOpts(client, startOpts, ...args) {
+    let input = args[0];
+    const schema = this.params.schema?.input;
+    if (schema) {
+      const schemaValidation = schema["~standard"].validate(input);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        client.logger.error("Invalid workflow data", { "aiki.issues": schemaValidationResult.issues });
+        throw new SchemaValidationError2("Invalid workflow data", schemaValidationResult.issues);
+      }
+      input = schemaValidationResult.value;
+    }
+    const { id } = await client.api.workflowRun.createV1({
+      name: this.name,
+      versionId: this.versionId,
+      input,
+      options: startOpts
+    });
+    client.logger.info("Created workflow", {
+      "aiki.workflowName": this.name,
+      "aiki.workflowVersionId": this.versionId,
+      "aiki.workflowRunId": id
+    });
+    return workflowRunHandle(client, id, this[INTERNAL5].eventsDefinition);
+  }
+  async startAsChild(parentRun, ...args) {
+    return this.startAsChildWithOpts(parentRun, this.params.opts ?? {}, ...args);
+  }
+  async startAsChildWithOpts(parentRun, startOpts, ...args) {
+    const parentRunHandle = parentRun[INTERNAL5].handle;
+    parentRunHandle[INTERNAL5].assertExecutionAllowed();
+    const { client } = parentRunHandle[INTERNAL5];
+    const inputRaw = args[0];
+    const input = await this.parse(parentRunHandle, this.params.schema?.input, inputRaw, parentRun.logger);
+    const inputHash = await hashInput(input);
+    const referenceId = startOpts.reference?.id;
+    const address = getWorkflowRunAddress(this.name, this.versionId, referenceId ?? inputHash);
+    const replayManifest = parentRun[INTERNAL5].replayManifest;
+    if (replayManifest.hasUnconsumedEntries()) {
+      const existingRunInfo = replayManifest.consumeNextChildWorkflowRun(address);
+      if (existingRunInfo) {
+        const { run: existingRun } = await client.api.workflowRun.getByIdV1({ id: existingRunInfo.id });
+        if (existingRun.state.status === "completed") {
+          await this.parse(parentRunHandle, this.params.schema?.output, existingRun.state.output, parentRun.logger);
+        }
+        const logger2 = parentRun.logger.child({
+          "aiki.childWorkflowName": existingRun.name,
+          "aiki.childWorkflowVersionId": existingRun.versionId,
+          "aiki.childWorkflowRunId": existingRun.id
+        });
+        return childWorkflowRunHandle(
+          client,
+          existingRun,
+          parentRun,
+          existingRunInfo.childWorkflowRunWaitQueues,
+          logger2,
+          this[INTERNAL5].eventsDefinition
+        );
+      }
+      await this.throwNonDeterminismError(parentRun, parentRunHandle, inputHash, referenceId, replayManifest);
+    }
+    const shard = parentRun.options.shard;
+    const { id: newRunId } = await client.api.workflowRun.createV1({
+      name: this.name,
+      versionId: this.versionId,
+      input,
+      parentWorkflowRunId: parentRun.id,
+      options: shard === void 0 ? startOpts : { ...startOpts, shard }
+    });
+    const { run: newRun } = await client.api.workflowRun.getByIdV1({ id: newRunId });
+    const logger = parentRun.logger.child({
+      "aiki.childWorkflowName": newRun.name,
+      "aiki.childWorkflowVersionId": newRun.versionId,
+      "aiki.childWorkflowRunId": newRun.id
+    });
+    logger.info("Created child workflow");
+    return childWorkflowRunHandle(
+      client,
+      newRun,
+      parentRun,
+      {
+        cancelled: { childWorkflowRunWaits: [] },
+        completed: { childWorkflowRunWaits: [] },
+        failed: { childWorkflowRunWaits: [] }
+      },
+      logger,
+      this[INTERNAL5].eventsDefinition
+    );
+  }
+  async throwNonDeterminismError(parentRun, parentRunHandle, inputHash, referenceId, manifest) {
+    const unconsumedManifestEntries = manifest.getUnconsumedEntries();
+    const logMeta = {
+      "aiki.workflowName": this.name,
+      "aiki.inputHash": inputHash,
+      "aiki.unconsumedManifestEntries": unconsumedManifestEntries
+    };
+    if (referenceId !== void 0) {
+      logMeta["aiki.referenceId"] = referenceId;
+    }
+    parentRun.logger.error("Replay divergence", logMeta);
+    const error = new NonDeterminismError2(parentRun.id, parentRunHandle.run.attempts, unconsumedManifestEntries);
+    await parentRunHandle[INTERNAL5].transitionState({
+      status: "failed",
+      cause: "self",
+      error: createSerializableError(error)
+    });
+    throw error;
+  }
+  async getHandleById(client, runId) {
+    return workflowRunHandle(client, runId, this[INTERNAL5].eventsDefinition);
+  }
+  async getHandleByReferenceId(client, referenceId) {
+    const { run } = await client.api.workflowRun.getByReferenceIdV1({
+      name: this.name,
+      versionId: this.versionId,
+      referenceId
+    });
+    return workflowRunHandle(client, run, this[INTERNAL5].eventsDefinition);
+  }
+  async handler(run, input, context) {
+    const { logger } = run;
+    const { handle } = run[INTERNAL5];
+    handle[INTERNAL5].assertExecutionAllowed();
+    const retryStrategy = this.params.opts?.retry ?? { type: "never" };
+    const state = handle.run.state;
+    if (state.status === "queued" && state.reason === "retry") {
+      await this.assertRetryAllowed(handle, retryStrategy, logger);
+    }
+    logger.info("Starting workflow");
+    await handle[INTERNAL5].transitionState({ status: "running" });
+    const output = await this.tryExecuteWorkflow(input, run, context, retryStrategy);
+    await handle[INTERNAL5].transitionState({ status: "completed", output });
+    logger.info("Workflow complete");
+  }
+  async tryExecuteWorkflow(input, run, context, retryStrategy) {
+    const { handle } = run[INTERNAL5];
+    while (true) {
+      try {
+        const outputRaw = await this.params.handler(run, input, context);
+        const output = await this.parse(handle, this.params.schema?.output, outputRaw, run.logger);
+        return output;
+      } catch (error) {
+        if (error instanceof WorkflowRunSuspendedError4 || error instanceof WorkflowRunFailedError3 || error instanceof WorkflowRunRevisionConflictError5 || error instanceof NonDeterminismError2) {
+          throw error;
+        }
+        const attempts = handle.run.attempts;
+        const retryParams = getRetryParams(attempts, retryStrategy);
+        if (!retryParams.retriesLeft) {
+          const failedState = this.createFailedState(error);
+          await handle[INTERNAL5].transitionState(failedState);
+          const logMeta2 = {};
+          for (const [key, value] of Object.entries(failedState)) {
+            logMeta2[`aiki.${key}`] = value;
+          }
+          run.logger.error("Workflow failed", {
+            "aiki.attempts": attempts,
+            ...logMeta2
+          });
+          throw new WorkflowRunFailedError3(run.id, attempts);
+        }
+        const awaitingRetryState = this.createAwaitingRetryState(error, retryParams.delayMs);
+        await handle[INTERNAL5].transitionState(awaitingRetryState);
+        const logMeta = {};
+        for (const [key, value] of Object.entries(awaitingRetryState)) {
+          logMeta[`aiki.${key}`] = value;
+        }
+        run.logger.info("Workflow awaiting retry", {
+          "aiki.attempts": attempts,
+          ...logMeta
+        });
+        throw new WorkflowRunSuspendedError4(run.id);
+      }
+    }
+  }
+  async assertRetryAllowed(handle, retryStrategy, logger) {
+    const { id, attempts } = handle.run;
+    const retryParams = getRetryParams(attempts, retryStrategy);
+    if (!retryParams.retriesLeft) {
+      logger.error("Workflow retry not allowed", { "aiki.attempts": attempts });
+      const error = new WorkflowRunFailedError3(id, attempts);
+      await handle[INTERNAL5].transitionState({
+        status: "failed",
+        cause: "self",
+        error: createSerializableError(error)
+      });
+      throw error;
+    }
+  }
+  async parse(handle, schema, data, logger) {
+    if (!schema) {
+      return data;
+    }
+    const schemaValidation = schema["~standard"].validate(data);
+    const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+    if (!schemaValidationResult.issues) {
+      return schemaValidationResult.value;
+    }
+    logger.error("Invalid workflow data", { "aiki.issues": schemaValidationResult.issues });
+    await handle[INTERNAL5].transitionState({
+      status: "failed",
+      cause: "self",
+      error: {
+        name: "SchemaValidationError",
+        message: JSON.stringify(schemaValidationResult.issues)
+      }
+    });
+    throw new WorkflowRunFailedError3(handle.run.id, handle.run.attempts);
+  }
+  createFailedState(error) {
+    if (error instanceof TaskFailedError2) {
+      return {
+        status: "failed",
+        cause: "task",
+        taskId: error.taskId
+      };
+    }
+    return {
+      status: "failed",
+      cause: "self",
+      error: createSerializableError(error)
+    };
+  }
+  createAwaitingRetryState(error, nextAttemptInMs) {
+    if (error instanceof TaskFailedError2) {
+      return {
+        status: "awaiting_retry",
+        cause: "task",
+        nextAttemptInMs,
+        taskId: error.taskId
+      };
+    }
+    return {
+      status: "awaiting_retry",
+      cause: "self",
+      nextAttemptInMs,
+      error: createSerializableError(error)
+    };
+  }
+};
+var WorkflowBuilderImpl = class _WorkflowBuilderImpl {
+  constructor(workflow2, startOptsBuilder) {
+    this.workflow = workflow2;
+    this.startOptsBuilder = startOptsBuilder;
+  }
+  opt(path, value) {
+    return new _WorkflowBuilderImpl(this.workflow, this.startOptsBuilder.with(path, value));
+  }
+  start(client, ...args) {
+    return this.workflow.startWithOpts(client, this.startOptsBuilder.build(), ...args);
+  }
+  startAsChild(parentRun, ...args) {
+    return this.workflow.startAsChildWithOpts(parentRun, this.startOptsBuilder.build(), ...args);
+  }
+};
+
+// ../workflow/workflow.ts
+function workflow(params) {
+  return new WorkflowImpl(params);
+}
+var WorkflowImpl = class {
+  name;
+  [INTERNAL6];
+  workflowVersions = /* @__PURE__ */ new Map();
+  constructor(params) {
+    this.name = params.name;
+    this[INTERNAL6] = {
+      getAllVersions: this.getAllVersions.bind(this),
+      getVersion: this.getVersion.bind(this)
+    };
+  }
+  v(versionId, params) {
+    if (this.workflowVersions.has(versionId)) {
+      throw new Error(`Workflow "${this.name}:${versionId}" already exists`);
+    }
+    const workflowVersion = new WorkflowVersionImpl(this.name, versionId, params);
+    this.workflowVersions.set(
+      versionId,
+      workflowVersion
+    );
+    return workflowVersion;
+  }
+  getAllVersions() {
+    return Array.from(this.workflowVersions.values());
+  }
+  getVersion(versionId) {
+    return this.workflowVersions.get(versionId);
+  }
+};
+
+// ../workflow/system/cancel-child-runs.ts
+var createCancelChildRunsV1 = (api) => {
+  const listNonTerminalChildRuns = task({
+    name: "aiki:list-non-terminal-child-runs",
+    async handler(parentRunId) {
+      const { runs } = await api.workflowRun.listChildRunsV1({
+        parentRunId,
+        status: NON_TERMINAL_WORKFLOW_RUN_STATUSES
+      });
+      return runs.map((r) => r.id);
+    }
+  });
+  const cancelRuns = task({
+    name: "aiki:cancel-runs",
+    async handler(runIds) {
+      const { cancelledIds } = await api.workflowRun.cancelByIdsV1({ ids: runIds });
+      return cancelledIds;
+    }
+  });
+  return workflow({ name: "aiki:cancel-child-runs" }).v("1.0.0", {
+    async handler(run, parentRunId) {
+      const childRunIds = await listNonTerminalChildRuns.start(run, parentRunId);
+      if (!isNonEmptyArray(childRunIds)) {
+        return;
+      }
+      await cancelRuns.start(run, childRunIds);
+    }
+  });
+};
+
+// ../workflow/system/index.ts
+function getSystemWorkflows(api) {
+  return [createCancelChildRunsV1(api)];
+}
+
+// worker.ts
+import { ulid } from "ulidx";
 function worker(params) {
   return new WorkerImpl(params);
 }
@@ -100,13 +1305,13 @@ var WorkerHandleImpl = class {
     this.client = client;
     this.params = params;
     this.spawnOpts = spawnOpts;
-    this.id = crypto.randomUUID();
+    this.id = ulid();
     this.name = params.name;
     this.workflowRunOpts = {
       heartbeatIntervalMs: this.spawnOpts.workflowRun?.heartbeatIntervalMs ?? 3e4,
       spinThresholdMs: this.spawnOpts.workflowRun?.spinThresholdMs ?? 10
     };
-    this.registry = workflowRegistry().addMany(this.params.workflows);
+    this.registry = workflowRegistry().addMany(getSystemWorkflows(client.api)).addMany(this.params.workflows);
     const reference = this.spawnOpts.reference;
     this.logger = client.logger.child({
       "aiki.component": "worker",
@@ -122,9 +1327,10 @@ var WorkerHandleImpl = class {
   logger;
   abortController;
   subscriberStrategy;
+  pollPromise;
   activeWorkflowRunsById = /* @__PURE__ */ new Map();
   async _start() {
-    const subscriberStrategyBuilder = this.client[INTERNAL].subscriber.create(
+    const subscriberStrategyBuilder = this.client[INTERNAL7].subscriber.create(
       this.params.subscriber ?? { type: "redis" },
       this.registry.getAll(),
       this.spawnOpts.shards
@@ -135,7 +1341,7 @@ var WorkerHandleImpl = class {
     });
     this.abortController = new AbortController();
     const abortSignal = this.abortController.signal;
-    fireAndForget(this.poll(abortSignal), (error) => {
+    this.pollPromise = this.poll(abortSignal).catch((error) => {
       if (!abortSignal.aborted) {
         this.logger.error("Unexpected error", {
           "aiki.error": error.message
@@ -146,6 +1352,7 @@ var WorkerHandleImpl = class {
   async stop() {
     this.logger.info("Worker stopping");
     this.abortController?.abort();
+    await this.pollPromise;
     const activeWorkflowRuns = Array.from(this.activeWorkflowRunsById.values());
     if (activeWorkflowRuns.length === 0) {
       return;
@@ -168,7 +1375,7 @@ var WorkerHandleImpl = class {
       throw new Error("Subscriber strategy not initialized");
     }
     this.logger.info("Worker started", {
-      "aiki.registeredWorkflows": this.params.workflows.map((w) => `${w.name}/${w.versionId}`)
+      "aiki.registeredWorkflows": this.params.workflows.map((w) => `${w.name}:${w.versionId}`)
     });
     const maxConcurrentWorkflowRuns = this.spawnOpts.maxConcurrentWorkflowRuns ?? 1;
     let nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "polled", foundWork: false });
@@ -287,26 +1494,30 @@ var WorkerHandleImpl = class {
           }
         }, this.workflowRunOpts.heartbeatIntervalMs);
       }
-      const eventsDefinition = workflowVersion[INTERNAL].eventsDefinition;
-      const handle = await workflowRunHandle(this.client, workflowRun, eventsDefinition, logger);
-      const appContext = this.client[INTERNAL].createContext ? await this.client[INTERNAL].createContext(workflowRun) : null;
-      await workflowVersion[INTERNAL].handler(
+      const eventsDefinition = workflowVersion[INTERNAL7].eventsDefinition;
+      const handle = await workflowRunHandle2(this.client, workflowRun, eventsDefinition, logger);
+      const appContext = this.client[INTERNAL7].createContext ? await this.client[INTERNAL7].createContext(workflowRun) : null;
+      await workflowVersion[INTERNAL7].handler(
         {
           id: workflowRun.id,
           name: workflowRun.name,
           versionId: workflowRun.versionId,
-          options: workflowRun.options,
+          options: workflowRun.options ?? {},
           logger,
           sleep: createSleeper(handle, logger),
           events: createEventWaiters(handle, eventsDefinition, logger),
-          [INTERNAL]: { handle, options: { spinThresholdMs: this.workflowRunOpts.spinThresholdMs } }
+          [INTERNAL7]: {
+            handle,
+            replayManifest: createReplayManifest(workflowRun),
+            options: { spinThresholdMs: this.workflowRunOpts.spinThresholdMs }
+          }
         },
         workflowRun.input,
         appContext
       );
       shouldAcknowledge = true;
     } catch (error) {
-      if (error instanceof WorkflowRunNotExecutableError || error instanceof WorkflowRunSuspendedError || error instanceof WorkflowRunFailedError) {
+      if (error instanceof WorkflowRunNotExecutableError2 || error instanceof WorkflowRunSuspendedError5 || error instanceof WorkflowRunFailedError4 || error instanceof WorkflowRunRevisionConflictError6 || error instanceof NonDeterminismError3) {
         shouldAcknowledge = true;
       } else {
         logger.error("Unexpected error during workflow execution", {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/worker",
-	"version": "0.16.0",
+	"version": "0.18.0",
 	"description": "Worker SDK for Aiki - execute workflows and tasks with durable state management and automatic recovery",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,9 +18,10 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.16.0",
-		"@aikirun/client": "0.16.0",
-		"@aikirun/workflow": "0.16.0"
+		"@aikirun/types": "0.18.0",
+		"@aikirun/client": "0.18.0",
+		"@aikirun/workflow": "0.18.0",
+		"ulidx": "^2.4.1"
 	},
 	"publishConfig": {
 		"access": "public"