@aikirun/worker 0.23.1 → 0.24.1

package/dist/index.js

@@ -52,125 +52,7 @@ var objectOverrider = (defaultObj) => (obj) => {
   return createBuilder([]);
 };
 
-// worker.ts
-import { INTERNAL as INTERNAL7 } from "@aikirun/types/symbols";
-import {
-  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 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) {
@@ -218,1049 +100,65 @@ function getRetryParams(attempts, strategy) {
   }
 }
 
-// ../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
+// ../subscriber/db/db-subscriber.ts
+function dbSubscriber(params) {
+  const { api, options } = params;
+  const intervalMs = options?.intervalMs ?? 1e3;
+  const maxRetryIntervalMs = options?.maxRetryIntervalMs ?? 3e4;
+  const atCapacityIntervalMs = options?.atCapacityIntervalMs ?? 500;
+  const claimMinIdleTimeMs = options?.claimMinIdleTimeMs ?? 9e4;
+  const getNextDelay = (delayParams) => {
+    switch (delayParams.type) {
+      case "polled":
+      case "heartbeat":
+        return intervalMs;
+      case "at_capacity":
+        return atCapacityIntervalMs;
+      case "retry": {
+        const retryParams = getRetryParams(delayParams.attemptNumber, {
+          type: "jittered",
+          maxAttempts: Number.POSITIVE_INFINITY,
+          baseDelayMs: intervalMs,
+          maxDelayMs: maxRetryIntervalMs
         });
-        if (retryParams.delayMs <= spinThresholdMs) {
-          await delay(retryParams.delayMs);
-          attempts++;
-          continue;
+        if (!retryParams.retriesLeft) {
+          return maxRetryIntervalMs;
         }
-        await handle[INTERNAL].transitionTaskState({
-          taskId,
-          taskState: {
-            status: "awaiting_retry",
-            attempts,
-            error: serializableError,
-            nextAttemptInMs: retryParams.delayMs
-          }
-        });
-        throw new WorkflowRunSuspendedError(handle.run.id);
+        return retryParams.delayMs;
       }
+      default:
+        return delayParams;
     }
-  }
-  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
+  return (context) => {
+    const { workerId, workflows, shards } = context;
+    const workflowFilters = !isNonEmptyArray(shards) ? workflows.map((workflow) => ({ name: workflow.name, versionId: workflow.versionId })) : workflows.flatMap(
+      (workflow) => shards.map((shard) => ({ name: workflow.name, versionId: workflow.versionId, shard }))
     );
-    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 {
-  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;
-  }
-  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 };
-    let afterStateTransitionId = this._run.stateTransitionId;
-    const hasTerminated = async () => {
-      const { terminated, latestStateTransitionId } = await this.api.workflowRun.hasTerminatedV1({
-        id: this._run.id,
-        afterStateTransitionId
-      });
-      afterStateTransitionId = latestStateTransitionId;
-      return terminated;
-    };
-    const shouldRetryOnResult = async (terminated) => !terminated;
-    const maybeResult = options?.abortSignal ? await withRetry(hasTerminated, retryStrategy, {
-      abortSignal: options.abortSignal,
-      shouldRetryOnResult
-    }).run() : await withRetry(hasTerminated, retryStrategy, { shouldRetryOnResult }).run();
-    if (maybeResult.state === "timeout") {
-      if (!Number.isFinite(maxAttempts)) {
-        throw new Error("Something's wrong, this should've never timed out");
-      }
-      return { success: false, cause: "timeout" };
-    }
-    if (maybeResult.state === "aborted") {
-      return { success: false, cause: "aborted" };
-    }
-    maybeResult.state;
-    await this.refresh();
-    if (this._run.state.status === expectedStatus) {
-      return {
-        success: true,
-        state: this._run.state
-      };
-    }
-    return { success: false, cause: "run_terminated" };
-  }
-  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,
-  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 (isTerminalWorkflowRunStatus(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 {
+      getNextDelay,
+      async getNextBatch(size) {
+        const response = await api.workflowRun.claimReadyV1({
+          workerId,
+          workflows: workflowFilters,
+          limit: size,
+          claimMinIdleTimeMs
         });
-        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: [] }
+        return response.runs.map((run) => ({
+          data: { workflowRunId: run.id }
+        }));
       },
-      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)
+      heartbeat: (workflowRunId) => api.workflowRun.heartbeatV1({ id: workflowRunId })
     };
-  }
-  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 {
+  executeWorkflowRun,
+  getSystemWorkflows,
+  workflowRegistry
+} from "@aikirun/workflow";
 import { ulid } from "ulidx";
 function worker(params) {
   return new WorkerImpl(params);
@@ -1268,76 +166,61 @@ function worker(params) {
 var WorkerImpl = class {
   constructor(params) {
     this.params = params;
-    this.name = params.name;
   }
-  name;
   with() {
-    const spawnOpts = this.params.opts ?? {};
-    const spawnOptsOverrider = objectOverrider(spawnOpts);
-    return new WorkerBuilderImpl(this, spawnOptsOverrider());
+    const spawnOptions = this.params.options ?? {};
+    const spawnOptionsOverrider = objectOverrider(spawnOptions);
+    return new WorkerBuilderImpl(this, spawnOptionsOverrider());
   }
   async spawn(client) {
-    return this.spawnWithOpts(client, this.params.opts ?? {});
+    return this.spawnWithOptions(client, this.params.options ?? {});
   }
-  async spawnWithOpts(client, spawnOpts) {
-    const handle = new WorkerHandleImpl(client, this.params, spawnOpts);
+  async spawnWithOptions(client, spawnOptions) {
+    const handle = new WorkerHandleImpl(client, this.params, spawnOptions);
     await handle._start();
     return handle;
   }
 };
 var WorkerHandleImpl = class {
-  constructor(client, params, spawnOpts) {
+  constructor(client, params, spawnOptions) {
     this.client = client;
     this.params = params;
-    this.spawnOpts = spawnOpts;
+    this.spawnOptions = spawnOptions;
     this.id = ulid();
-    this.name = params.name;
-    this.workflowRunOpts = {
-      heartbeatIntervalMs: this.spawnOpts.workflowRun?.heartbeatIntervalMs ?? 3e4,
-      spinThresholdMs: this.spawnOpts.workflowRun?.spinThresholdMs ?? 10
+    this.workflowRunOptions = {
+      heartbeatIntervalMs: this.spawnOptions.workflowRun?.heartbeatIntervalMs ?? 3e4,
+      spinThresholdMs: this.spawnOptions.workflowRun?.spinThresholdMs ?? 10
     };
     this.registry = workflowRegistry().addMany(getSystemWorkflows(client.api)).addMany(this.params.workflows);
-    const reference = this.spawnOpts.reference;
+    const reference = this.spawnOptions.reference;
     this.logger = client.logger.child({
       "aiki.component": "worker",
       "aiki.workerId": this.id,
-      "aiki.workerName": this.name,
       ...reference && { "aiki.workerReferenceId": reference.id }
     });
   }
   id;
-  name;
-  workflowRunOpts;
+  workflowRunOptions;
   registry;
   logger;
   abortController;
-  subscriberStrategy;
-  fallbackSubscriberStrategy;
+  subscriber;
+  fallbackSubscriber;
   pollPromise;
   activeWorkflowRunsById = /* @__PURE__ */ new Map();
   async _start() {
-    const workflows = this.registry.getAll();
-    const subscriberStrategyParams = this.params.subscriber ?? { type: "db" };
-    const subscriberStrategyBuilder = this.client[INTERNAL7].subscriber.create(
-      subscriberStrategyParams,
-      workflows,
-      this.spawnOpts.shards
-    );
-    this.subscriberStrategy = await subscriberStrategyBuilder.init(this.id, {
-      onError: (error) => this.handleSubscriberError(error),
-      onStop: () => this.stop()
-    });
-    if (subscriberStrategyParams.type !== "db") {
-      const fallbackSubscriberStrategyBuilder = this.client[INTERNAL7].subscriber.create(
-        { type: "db" },
-        workflows,
-        this.spawnOpts.shards
-      );
-      this.fallbackSubscriberStrategy = await fallbackSubscriberStrategyBuilder.init(this.id, {
-        onError: (error) => this.handleSubscriberError(error),
-        onStop: () => this.stop()
-      });
-    }
+    const subscriberContext = {
+      workerId: this.id,
+      workflows: this.registry.getAll(),
+      shards: this.spawnOptions.shards,
+      logger: this.logger
+    };
+    const createSubscriber = this.params.subscriber ?? dbSubscriber({ api: this.client.api });
+    const subscriber = createSubscriber(subscriberContext);
+    this.subscriber = subscriber instanceof Promise ? await subscriber : subscriber;
+    const createFallbackSubscriber = dbSubscriber({ api: this.client.api });
+    const fallbackSubscriber = createFallbackSubscriber(subscriberContext);
+    this.fallbackSubscriber = fallbackSubscriber instanceof Promise ? await fallbackSubscriber : fallbackSubscriber;
     this.abortController = new AbortController();
     const abortSignal = this.abortController.signal;
     this.pollPromise = this.poll(abortSignal).catch((error) => {
@@ -1352,11 +235,13 @@ var WorkerHandleImpl = class {
     this.logger.info("Worker stopping");
     this.abortController?.abort();
     await this.pollPromise;
+    await this.subscriber?.close?.();
+    await this.fallbackSubscriber?.close?.();
     const activeWorkflowRuns = Array.from(this.activeWorkflowRunsById.values());
     if (activeWorkflowRuns.length === 0) {
       return;
     }
-    const timeoutMs = this.spawnOpts.gracefulShutdownTimeoutMs ?? 5e3;
+    const timeoutMs = this.spawnOptions.gracefulShutdownTimeoutMs ?? 5e3;
     if (timeoutMs > 0) {
       await Promise.race([Promise.allSettled(activeWorkflowRuns.map((w) => w.executionPromise)), delay(timeoutMs)]);
     }
@@ -1370,60 +255,59 @@ var WorkerHandleImpl = class {
     this.activeWorkflowRunsById.clear();
   }
   async poll(abortSignal) {
-    if (!this.subscriberStrategy) {
-      throw new Error("Subscriber strategy not initialized");
+    if (!this.subscriber) {
+      throw new Error("Subscriber not initialized");
     }
     this.logger.info("Worker started", {
       "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 });
+    const maxConcurrentWorkflowRuns = this.spawnOptions.maxConcurrentWorkflowRuns ?? 1;
+    let activeSubscriber = this.subscriber;
+    let nextDelayMs = activeSubscriber.getNextDelay({ type: "polled", foundWork: false });
     let subscriberFailedAttempts = 0;
     while (!abortSignal.aborted) {
       await delay(nextDelayMs, { abortSignal });
       const availableCapacity = maxConcurrentWorkflowRuns - this.activeWorkflowRunsById.size;
       if (availableCapacity <= 0) {
-        nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "at_capacity" });
+        nextDelayMs = activeSubscriber.getNextDelay({ type: "at_capacity" });
         continue;
       }
       const nextBatchResponse = await this.fetchNextWorkflowRunBatch(availableCapacity, subscriberFailedAttempts);
       if (!nextBatchResponse.success) {
         subscriberFailedAttempts++;
-        nextDelayMs = this.subscriberStrategy.getNextDelay({
+        nextDelayMs = activeSubscriber.getNextDelay({
           type: "retry",
           attemptNumber: subscriberFailedAttempts
         });
         continue;
       }
       subscriberFailedAttempts = 0;
+      activeSubscriber = nextBatchResponse.subscriber;
       if (!isNonEmptyArray(nextBatchResponse.batch)) {
-        nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "polled", foundWork: false });
+        nextDelayMs = activeSubscriber.getNextDelay({ type: "polled", foundWork: false });
         continue;
       }
       await this.enqueueWorkflowRunBatch(nextBatchResponse.batch, nextBatchResponse.subscriber, abortSignal);
-      nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "polled", foundWork: true });
+      nextDelayMs = activeSubscriber.getNextDelay({ type: "polled", foundWork: true });
     }
   }
   async fetchNextWorkflowRunBatch(size, subscriberFailedAttempts) {
-    if (!this.subscriberStrategy) {
-      return {
-        success: false,
-        error: new Error("Subscriber strategy not initialized")
-      };
+    if (!this.subscriber) {
+      throw new Error("Subscriber not initialized");
     }
     try {
-      const batch = await this.subscriberStrategy.getNextBatch(size);
-      return { success: true, batch, subscriber: this.subscriberStrategy };
+      const batch = await this.subscriber.getNextBatch(size);
+      return { success: true, batch, subscriber: this.subscriber };
     } catch (error) {
       this.logger.error("Error getting next workflow runs batch", {
         "aiki.error": error instanceof Error ? error.message : String(error)
       });
-      if (this.fallbackSubscriberStrategy && subscriberFailedAttempts >= 2) {
+      if (this.fallbackSubscriber && subscriberFailedAttempts >= 2) {
         try {
-          const batch = await this.fallbackSubscriberStrategy.getNextBatch(size);
-          return { success: true, batch, subscriber: this.fallbackSubscriberStrategy };
+          const batch = await this.fallbackSubscriber.getNextBatch(size);
+          return { success: true, batch, subscriber: this.fallbackSubscriber };
         } catch (fallbackError) {
-          this.logger.error("Fallback subscriber strategy for getting next workflow runs batch also failed", {
+          this.logger.error("Fallback subscriber also failed to get next workflow runs batch", {
             "aiki.error": fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
           });
         }
@@ -1440,8 +324,15 @@ var WorkerHandleImpl = class {
         });
         continue;
       }
-      const { run: workflowRun } = await this.client.api.workflowRun.getByIdV1({ id: workflowRunId });
-      if (!workflowRun) {
+      let workflowRun;
+      try {
+        const response = await this.client.api.workflowRun.getByIdV1({ id: workflowRunId });
+        workflowRun = response.run;
+      } catch (error) {
+        this.logger.warn("Failed to fetch workflow run", {
+          "aiki.workflowRunId": workflowRunId,
+          "aiki.error": error instanceof Error ? error.message : String(error)
+        });
         if (subscriber.acknowledge) {
           await subscriber.acknowledge(workflowRunId).catch(() => {
           });
@@ -1476,94 +367,49 @@ var WorkerHandleImpl = class {
   }
   async executeWorkflow(workflowRun, workflowVersion, subscriber) {
     const logger = this.logger.child({
-      "aiki.component": "workflow-execution",
       "aiki.workflowName": workflowRun.name,
       "aiki.workflowVersionId": workflowRun.versionId,
       "aiki.workflowRunId": workflowRun.id
     });
-    let heartbeatInterval;
-    let shouldAcknowledge = false;
-    try {
-      const heartbeat = subscriber.heartbeat;
-      if (heartbeat) {
-        heartbeatInterval = setInterval(() => {
-          try {
-            heartbeat(workflowRun.id);
-          } catch (error) {
-            logger.warn("Failed to send heartbeat", {
-              "aiki.error": error instanceof Error ? error.message : String(error)
-            });
-          }
-        }, this.workflowRunOpts.heartbeatIntervalMs);
-      }
-      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 ?? {},
-          logger,
-          sleep: createSleeper(handle, logger),
-          events: createEventWaiters(handle, eventsDefinition, logger),
-          [INTERNAL7]: {
-            handle,
-            replayManifest: createReplayManifest(workflowRun),
-            options: { spinThresholdMs: this.workflowRunOpts.spinThresholdMs }
-          }
-        },
-        workflowRun.input,
-        appContext
-      );
-      shouldAcknowledge = true;
-    } catch (error) {
-      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", {
-          "aiki.error": error instanceof Error ? error.message : String(error),
-          "aiki.stack": error instanceof Error ? error.stack : void 0
-        });
-        shouldAcknowledge = false;
-      }
-    } finally {
-      if (heartbeatInterval) clearInterval(heartbeatInterval);
-      if (subscriber.acknowledge) {
-        if (shouldAcknowledge) {
-          try {
-            await subscriber.acknowledge(workflowRun.id);
-          } catch (error) {
-            logger.error("Failed to acknowledge message, it may be reprocessed", {
-              "aiki.errorType": "MESSAGE_ACK_FAILED",
-              "aiki.error": error instanceof Error ? error.message : String(error)
-            });
-          }
-        } else {
-          logger.debug("Message left in PEL for retry");
+    const heartbeat = subscriber.heartbeat;
+    const success = await executeWorkflowRun({
+      client: this.client,
+      workflowRun,
+      workflowVersion,
+      logger,
+      options: {
+        spinThresholdMs: this.workflowRunOptions.spinThresholdMs,
+        heartbeatIntervalMs: this.workflowRunOptions.heartbeatIntervalMs
+      },
+      heartbeat: heartbeat ? () => heartbeat(workflowRun.id) : void 0
+    });
+    if (subscriber.acknowledge) {
+      if (success) {
+        try {
+          await subscriber.acknowledge(workflowRun.id);
+        } catch (error) {
+          logger.error("Failed to acknowledge message, it may be reprocessed", {
+            "aiki.errorType": "MESSAGE_ACK_FAILED",
+            "aiki.error": error instanceof Error ? error.message : String(error)
+          });
         }
+      } else {
+        logger.debug("Message left pending for retry");
       }
-      this.activeWorkflowRunsById.delete(workflowRun.id);
     }
-  }
-  handleSubscriberError(error) {
-    this.logger.warn("Subscriber error", {
-      "aiki.error": error.message,
-      "aiki.stack": error.stack
-    });
+    this.activeWorkflowRunsById.delete(workflowRun.id);
   }
 };
 var WorkerBuilderImpl = class _WorkerBuilderImpl {
-  constructor(worker2, spawnOptsBuilder) {
+  constructor(worker2, spawnOptionsBuilder) {
     this.worker = worker2;
-    this.spawnOptsBuilder = spawnOptsBuilder;
+    this.spawnOptionsBuilder = spawnOptionsBuilder;
   }
   opt(path, value) {
-    return new _WorkerBuilderImpl(this.worker, this.spawnOptsBuilder.with(path, value));
+    return new _WorkerBuilderImpl(this.worker, this.spawnOptionsBuilder.with(path, value));
   }
   spawn(client) {
-    return this.worker.spawnWithOpts(client, this.spawnOptsBuilder.build());
+    return this.worker.spawnWithOptions(client, this.spawnOptionsBuilder.build());
   }
 };
 export {