@aikirun/workflow 0.23.1 → 0.24.0

package/dist/index.js

@@ -58,64 +58,6 @@ function isNonEmptyArray(value) {
   return value !== void 0 && value.length > 0;
 }
 
-// ../../lib/async/delay.ts
-function delay(ms, options) {
-  const abortSignal = options?.abortSignal;
-  if (abortSignal?.aborted) {
-    return Promise.reject(abortSignal.reason);
-  }
-  return new Promise((resolve, reject) => {
-    const abort = () => {
-      clearTimeout(timeout);
-      reject(abortSignal?.reason);
-    };
-    const timeout = setTimeout(() => {
-      abortSignal?.removeEventListener("abort", abort);
-      resolve();
-    }, ms);
-    abortSignal?.addEventListener("abort", abort, { once: true });
-  });
-}
-
-// ../../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/duration/convert.ts
 var MS_PER_SECOND = 1e3;
 var MS_PER_MINUTE = 60 * MS_PER_SECOND;
@@ -162,19 +104,6 @@ function assertIsPositiveNumber(value, field) {
   }
 }
 
-// ../../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/object/overrider.ts
 function set(obj, path, value) {
   const keys = path.split(".");
@@ -205,92 +134,6 @@ var objectOverrider = (defaultObj) => (obj) => {
   return createBuilder([]);
 };
 
-// ../../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;
-  }
-}
-
 // run/event.ts
 import { INTERNAL } from "@aikirun/types/symbols";
 import { SchemaValidationError } from "@aikirun/types/validator";
@@ -298,7 +141,7 @@ import {
   WorkflowRunFailedError,
   WorkflowRunRevisionConflictError,
   WorkflowRunSuspendedError
-} from "@aikirun/types/workflow-run";
+} from "@aikirun/types/workflow-run-error";
 function event(params) {
   return {
     // biome-ignore lint/style/useNamingConvention: phantom type marker
@@ -388,10 +231,10 @@ function createEventSenders(api, workflowRunId, eventsDefinition, logger) {
   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)
+  const optionsOverrider = objectOverrider(options ?? {});
+  const createBuilder = (optionsBuilder) => ({
+    opt: (path, value) => createBuilder(optionsBuilder.with(path, value)),
+    send: (...args) => createEventSender(api, workflowRunId, eventName, schema, logger, optionsBuilder.build()).send(...args)
   });
   async function send(...args) {
     let data = args[0];
@@ -415,7 +258,7 @@ function createEventSender(api, workflowRunId, eventName, schema, logger, option
     });
   }
   return {
-    with: () => createBuilder(optsOverrider()),
+    with: () => createBuilder(optionsOverrider()),
     send
   };
 }
@@ -433,19 +276,21 @@ function createEventMulticasters(workflowName, workflowVersionId, eventsDefiniti
   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(
+  const optionsOverrider = objectOverrider(options ?? {});
+  const createBuilder = (optionsBuilder) => ({
+    opt: (path, value) => createBuilder(optionsBuilder.with(path, value)),
+    send: (client, runId, ...args) => createEventMulticaster(workflowName, workflowVersionId, eventName, schema, optionsBuilder.build()).send(
       client,
       runId,
       ...args
     ),
-    sendByReferenceId: (client, referenceId, ...args) => createEventMulticaster(workflowName, workflowVersionId, eventName, schema, optsBuilder.build()).sendByReferenceId(
-      client,
-      referenceId,
-      ...args
-    )
+    sendByReferenceId: (client, referenceId, ...args) => createEventMulticaster(
+      workflowName,
+      workflowVersionId,
+      eventName,
+      schema,
+      optionsBuilder.build()
+    ).sendByReferenceId(client, referenceId, ...args)
   });
   async function send(client, runId, ...args) {
     let data = args[0];
@@ -520,18 +365,130 @@ function createEventMulticaster(workflowName, workflowVersionId, eventName, sche
     });
   }
   return {
-    with: () => createBuilder(optsOverrider()),
+    with: () => createBuilder(optionsOverrider()),
     send,
     sendByReferenceId
   };
 }
 
+// run/execute.ts
+import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
+import {
+  NonDeterminismError,
+  WorkflowRunFailedError as WorkflowRunFailedError2,
+  WorkflowRunNotExecutableError as WorkflowRunNotExecutableError2,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError4,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError3
+} from "@aikirun/types/workflow-run-error";
+
+// ../../lib/async/delay.ts
+function delay(ms, options) {
+  const abortSignal = options?.abortSignal;
+  if (abortSignal?.aborted) {
+    return Promise.reject(abortSignal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timeout);
+      reject(abortSignal?.reason);
+    };
+    const timeout = setTimeout(() => {
+      abortSignal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    abortSignal?.addEventListener("abort", abort, { once: true });
+  });
+}
+
+// ../../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;
+  }
+}
+
 // run/handle.ts
 import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
-import {
-  WorkflowRunNotExecutableError,
-  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError2
-} from "@aikirun/types/workflow-run";
+import { WorkflowRunNotExecutableError, WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError2 } from "@aikirun/types/workflow-run-error";
 async function workflowRunHandle(client, runOrId, eventsDefinition, logger) {
   const run = typeof runOrId !== "string" ? runOrId : (await client.api.workflowRun.getByIdV1({ id: runOrId })).run;
   return new WorkflowRunHandleImpl(
@@ -707,10 +664,10 @@ function createReplayManifest(run) {
       if (nextIndex >= taskCount) {
         return void 0;
       }
-      const task = taskQueues[address].tasks[nextIndex];
+      const task2 = taskQueues[address].tasks[nextIndex];
       nextTaskIndexByAddress[address] = nextIndex + 1;
       consumedEntries++;
-      return task;
+      return task2;
     },
     consumeNextChildWorkflowRun(address) {
       const childWorkflowRunCount = childWorkflowRunCountByAddress[address] ?? 0;
@@ -750,10 +707,7 @@ function createReplayManifest(run) {
 
 // run/sleeper.ts
 import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
-import {
-  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError3,
-  WorkflowRunSuspendedError as WorkflowRunSuspendedError2
-} from "@aikirun/types/workflow-run";
+import { WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError3, WorkflowRunSuspendedError as WorkflowRunSuspendedError2 } from "@aikirun/types/workflow-run-error";
 var MAX_SLEEP_YEARS = 10;
 var MAX_SLEEP_MS = MAX_SLEEP_YEARS * 365 * 24 * 60 * 60 * 1e3;
 function createSleeper(handle, logger) {
@@ -832,9 +786,64 @@ function createSleeper(handle, logger) {
   };
 }
 
+// run/execute.ts
+async function executeWorkflowRun(params) {
+  const { client, workflowRun, workflowVersion, logger, options, heartbeat } = params;
+  let heartbeatInterval;
+  try {
+    if (heartbeat) {
+      heartbeatInterval = setInterval(async () => {
+        try {
+          await heartbeat();
+          logger.debug("Heartbeat sent");
+        } catch (error) {
+          logger.warn("Failed to send heartbeat", {
+            "aiki.error": error instanceof Error ? error.message : String(error)
+          });
+        }
+      }, options.heartbeatIntervalMs);
+    }
+    const eventsDefinition = workflowVersion[INTERNAL4].eventsDefinition;
+    const handle = await workflowRunHandle(client, workflowRun, eventsDefinition, logger);
+    const appContext = client[INTERNAL4].createContext ? client[INTERNAL4].createContext(workflowRun) : null;
+    await workflowVersion[INTERNAL4].handler(
+      {
+        id: workflowRun.id,
+        name: workflowRun.name,
+        versionId: workflowRun.versionId,
+        options: workflowRun.options ?? {},
+        logger,
+        sleep: createSleeper(handle, logger),
+        events: createEventWaiters(handle, eventsDefinition, logger),
+        [INTERNAL4]: {
+          handle,
+          replayManifest: createReplayManifest(workflowRun),
+          options: { spinThresholdMs: options.spinThresholdMs }
+        }
+      },
+      workflowRun.input,
+      appContext instanceof Promise ? await appContext : appContext
+    );
+    return true;
+  } catch (error) {
+    if (error instanceof WorkflowRunNotExecutableError2 || error instanceof WorkflowRunSuspendedError3 || error instanceof WorkflowRunFailedError2 || error instanceof WorkflowRunRevisionConflictError4 || error instanceof NonDeterminismError) {
+      return true;
+    }
+    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
+    });
+    return false;
+  } finally {
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+    }
+  }
+}
+
 // schedule.ts
 function schedule(params) {
-  async function activateWithOpts(client, workflow2, options, ...args) {
+  async function activateWithOptions(client, workflow2, options, ...args) {
     const input = args[0];
     let scheduleSpec;
     if (params.type === "interval") {
@@ -873,52 +882,338 @@ function schedule(params) {
       }
     };
   }
-  function createBuilder(optsBuilder) {
+  function createBuilder(optionsBuilder) {
     return {
-      opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+      opt: (path, value) => createBuilder(optionsBuilder.with(path, value)),
       async activate(client, workflow2, ...args) {
-        return activateWithOpts(client, workflow2, optsBuilder.build(), ...args);
+        return activateWithOptions(client, workflow2, optionsBuilder.build(), ...args);
       }
     };
   }
   return {
     ...params,
     with() {
-      const optsOverrider = objectOverrider({});
-      return createBuilder(optsOverrider());
+      const optionsOverrider = objectOverrider({});
+      return createBuilder(optionsOverrider());
     },
     async activate(client, workflow2, ...args) {
-      return activateWithOpts(client, workflow2, {}, ...args);
+      return activateWithOptions(client, workflow2, {}, ...args);
     }
   };
 }
 
-// workflow.ts
-import { INTERNAL as INTERNAL6 } from "@aikirun/types/symbols";
+// 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}`;
 }
 
-// workflow-version.ts
+// ../../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"
+  };
+}
+
+// ../task/task.ts
 import { INTERNAL as INTERNAL5 } from "@aikirun/types/symbols";
-import { TaskFailedError } from "@aikirun/types/task";
-import { SchemaValidationError as SchemaValidationError2 } from "@aikirun/types/validator";
+import { TaskFailedError } from "@aikirun/types/task-error";
 import {
-  NonDeterminismError,
-  WorkflowRunFailedError as WorkflowRunFailedError2,
+  NonDeterminismError as NonDeterminismError2,
+  WorkflowRunFailedError as WorkflowRunFailedError3,
   WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError5,
   WorkflowRunSuspendedError as WorkflowRunSuspendedError4
-} from "@aikirun/types/workflow-run";
+} from "@aikirun/types/workflow-run-error";
+function task(params) {
+  return new TaskImpl(params);
+}
+var TaskImpl = class {
+  constructor(params) {
+    this.params = params;
+    this.name = params.name;
+  }
+  name;
+  with() {
+    const startOptions = this.params.options ?? {};
+    const startOptionsOverrider = objectOverrider(startOptions);
+    return new TaskBuilderImpl(this, startOptionsOverrider());
+  }
+  async start(run, ...args) {
+    return this.startWithOptions(run, this.params.options ?? {}, ...args);
+  }
+  async startWithOptions(run, startOptions, ...args) {
+    const handle = run[INTERNAL5].handle;
+    handle[INTERNAL5].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[INTERNAL5].replayManifest;
+    if (replayManifest.hasUnconsumedEntries()) {
+      const existingTaskInfo = replayManifest.consumeNextTask(address);
+      if (existingTaskInfo) {
+        return this.getExistingTaskResult(run, handle, startOptions, input, existingTaskInfo);
+      }
+      await this.throwNonDeterminismError(run, handle, inputHash, replayManifest.getUnconsumedEntries());
+    }
+    const attempts = 1;
+    const retryStrategy = startOptions.retry ?? { type: "never" };
+    const taskInfo = await handle[INTERNAL5].transitionTaskState({
+      type: "create",
+      taskName: this.name,
+      options: startOptions,
+      taskState: { status: "running", attempts, input }
+    });
+    const logger = run.logger.child({
+      "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[INTERNAL5].options.spinThresholdMs,
+      logger
+    );
+    await handle[INTERNAL5].transitionTaskState({
+      taskId: taskInfo.id,
+      taskState: { status: "completed", attempts: lastAttempt, output }
+    });
+    logger.info("Task complete", { "aiki.attempts": lastAttempt });
+    return output;
+  }
+  async getExistingTaskResult(run, handle, startOptions, 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 = startOptions.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, startOptions, retryStrategy, attempts);
+  }
+  async throwNonDeterminismError(run, handle, inputHash, unconsumedManifestEntries) {
+    run.logger.error("Replay divergence", {
+      "aiki.taskName": this.name,
+      "aiki.inputHash": inputHash,
+      "aiki.unconsumedManifestEntries": unconsumedManifestEntries
+    });
+    const error = new NonDeterminismError2(run.id, handle.run.attempts, unconsumedManifestEntries);
+    await handle[INTERNAL5].transitionState({
+      status: "failed",
+      cause: "self",
+      error: createSerializableError(error)
+    });
+    throw error;
+  }
+  async retryAndExecute(run, handle, input, taskId, startOptions, retryStrategy, previousAttempts) {
+    const attempts = previousAttempts + 1;
+    const taskInfo = await handle[INTERNAL5].transitionTaskState({
+      type: "retry",
+      taskId,
+      options: startOptions,
+      taskState: { status: "running", attempts, input }
+    });
+    const logger = run.logger.child({
+      "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[INTERNAL5].options.spinThresholdMs,
+      logger
+    );
+    await handle[INTERNAL5].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 WorkflowRunSuspendedError4 || error instanceof WorkflowRunFailedError3 || error instanceof WorkflowRunRevisionConflictError5) {
+          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[INTERNAL5].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[INTERNAL5].transitionTaskState({
+          taskId,
+          taskState: {
+            status: "awaiting_retry",
+            attempts,
+            error: serializableError,
+            nextAttemptInMs: retryParams.delayMs
+          }
+        });
+        throw new WorkflowRunSuspendedError4(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[INTERNAL5].transitionState({
+      status: "failed",
+      cause: "self",
+      error: {
+        name: "SchemaValidationError",
+        message: JSON.stringify(schemaValidationResult.issues)
+      }
+    });
+    throw new WorkflowRunFailedError3(handle.run.id, handle.run.attempts);
+  }
+};
+var TaskBuilderImpl = class _TaskBuilderImpl {
+  constructor(task2, startOptionsBuilder) {
+    this.task = task2;
+    this.startOptionsBuilder = startOptionsBuilder;
+  }
+  opt(path, value) {
+    return new _TaskBuilderImpl(this.task, this.startOptionsBuilder.with(path, value));
+  }
+  start(run, ...args) {
+    return this.task.startWithOptions(run, this.startOptionsBuilder.build(), ...args);
+  }
+};
+
+// workflow.ts
+import { INTERNAL as INTERNAL8 } from "@aikirun/types/symbols";
+
+// workflow-version.ts
+import { INTERNAL as INTERNAL7 } from "@aikirun/types/symbols";
+import { TaskFailedError as TaskFailedError2 } from "@aikirun/types/task-error";
+import { SchemaValidationError as SchemaValidationError2 } from "@aikirun/types/validator";
+import {
+  NonDeterminismError as NonDeterminismError3,
+  WorkflowRunFailedError as WorkflowRunFailedError4,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError7,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError6
+} from "@aikirun/types/workflow-run-error";
 
 // run/handle-child.ts
-import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
+import { INTERNAL as INTERNAL6 } from "@aikirun/types/symbols";
 import {
-  isTerminalWorkflowRunStatus,
-  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError4,
-  WorkflowRunSuspendedError as WorkflowRunSuspendedError3
+  isTerminalWorkflowRunStatus
 } from "@aikirun/types/workflow-run";
+import { WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError6, WorkflowRunSuspendedError as WorkflowRunSuspendedError5 } from "@aikirun/types/workflow-run-error";
 async function childWorkflowRunHandle(client, run, parentRun, childWorkflowRunWaitQueues, logger, eventsDefinition) {
   const handle = await workflowRunHandle(client, run, eventsDefinition, logger);
   return {
@@ -930,7 +1225,7 @@ async function childWorkflowRunHandle(client, run, parentRun, childWorkflowRunWa
     pause: handle.pause.bind(handle),
     resume: handle.resume.bind(handle),
     awake: handle.awake.bind(handle),
-    [INTERNAL4]: handle[INTERNAL4]
+    [INTERNAL6]: handle[INTERNAL6]
   };
 }
 function createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logger) {
@@ -940,7 +1235,7 @@ function createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logge
     failed: 0
   };
   async function waitForStatus(expectedStatus, options) {
-    const parentRunHandle = parentRun[INTERNAL4].handle;
+    const parentRunHandle = parentRun[INTERNAL6].handle;
     const nextIndex = nextIndexByStatus[expectedStatus];
     const { run } = handle;
     const childWorkflowRunWaits = childWorkflowRunWaitQueues[expectedStatus].childWorkflowRunWaits;
@@ -976,7 +1271,7 @@ function createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logge
     }
     const timeoutInMs = options?.timeout && toMilliseconds(options.timeout);
     try {
-      await parentRunHandle[INTERNAL4].transitionState({
+      await parentRunHandle[INTERNAL6].transitionState({
         status: "awaiting_child_workflow",
         childWorkflowRunId: run.id,
         childWorkflowRunStatus: expectedStatus,
@@ -987,12 +1282,12 @@ function createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logge
         ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
       });
     } catch (error) {
-      if (error instanceof WorkflowRunRevisionConflictError4) {
-        throw new WorkflowRunSuspendedError3(parentRun.id);
+      if (error instanceof WorkflowRunRevisionConflictError6) {
+        throw new WorkflowRunSuspendedError5(parentRun.id);
       }
       throw error;
     }
-    throw new WorkflowRunSuspendedError3(parentRun.id);
+    throw new WorkflowRunSuspendedError5(parentRun.id);
   }
   return waitForStatus;
 }
@@ -1005,22 +1300,22 @@ var WorkflowVersionImpl = class {
     this.params = params;
     const eventsDefinition = this.params.events ?? {};
     this.events = createEventMulticasters(this.name, this.versionId, eventsDefinition);
-    this[INTERNAL5] = {
+    this[INTERNAL7] = {
       eventsDefinition,
       handler: this.handler.bind(this)
     };
   }
   events;
-  [INTERNAL5];
+  [INTERNAL7];
   with() {
-    const startOpts = this.params.opts ?? {};
-    const startOptsOverrider = objectOverrider(startOpts);
-    return new WorkflowBuilderImpl(this, startOptsOverrider());
+    const startOptions = this.params.options ?? {};
+    const startOptionsOverrider = objectOverrider(startOptions);
+    return new WorkflowBuilderImpl(this, startOptionsOverrider());
   }
   async start(client, ...args) {
-    return this.startWithOpts(client, this.params.opts ?? {}, ...args);
+    return this.startWithOptions(client, this.params.options ?? {}, ...args);
   }
-  async startWithOpts(client, startOpts, ...args) {
+  async startWithOptions(client, startOptions, ...args) {
     let input = args[0];
     const schema = this.params.schema?.input;
     if (schema) {
@@ -1036,28 +1331,28 @@ var WorkflowVersionImpl = class {
       name: this.name,
       versionId: this.versionId,
       input,
-      options: startOpts
+      options: startOptions
     });
     client.logger.info("Created workflow", {
       "aiki.workflowName": this.name,
       "aiki.workflowVersionId": this.versionId,
       "aiki.workflowRunId": id
     });
-    return workflowRunHandle(client, id, this[INTERNAL5].eventsDefinition);
+    return workflowRunHandle(client, id, this[INTERNAL7].eventsDefinition);
   }
   async startAsChild(parentRun, ...args) {
-    return this.startAsChildWithOpts(parentRun, this.params.opts ?? {}, ...args);
+    return this.startAsChildWithOptions(parentRun, this.params.options ?? {}, ...args);
   }
-  async startAsChildWithOpts(parentRun, startOpts, ...args) {
-    const parentRunHandle = parentRun[INTERNAL5].handle;
-    parentRunHandle[INTERNAL5].assertExecutionAllowed();
-    const { client } = parentRunHandle[INTERNAL5];
+  async startAsChildWithOptions(parentRun, startOptions, ...args) {
+    const parentRunHandle = parentRun[INTERNAL7].handle;
+    parentRunHandle[INTERNAL7].assertExecutionAllowed();
+    const { client } = parentRunHandle[INTERNAL7];
     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 referenceId = startOptions.reference?.id;
     const address = getWorkflowRunAddress(this.name, this.versionId, referenceId ?? inputHash);
-    const replayManifest = parentRun[INTERNAL5].replayManifest;
+    const replayManifest = parentRun[INTERNAL7].replayManifest;
     if (replayManifest.hasUnconsumedEntries()) {
       const existingRunInfo = replayManifest.consumeNextChildWorkflowRun(address);
       if (existingRunInfo) {
@@ -1076,7 +1371,7 @@ var WorkflowVersionImpl = class {
           parentRun,
           existingRunInfo.childWorkflowRunWaitQueues,
           logger2,
-          this[INTERNAL5].eventsDefinition
+          this[INTERNAL7].eventsDefinition
         );
       }
       await this.throwNonDeterminismError(parentRun, parentRunHandle, inputHash, referenceId, replayManifest);
@@ -1087,7 +1382,7 @@ var WorkflowVersionImpl = class {
       versionId: this.versionId,
       input,
       parentWorkflowRunId: parentRun.id,
-      options: shard === void 0 ? startOpts : { ...startOpts, shard }
+      options: shard === void 0 ? startOptions : { ...startOptions, shard }
     });
     const { run: newRun } = await client.api.workflowRun.getByIdV1({ id: newRunId });
     const logger = parentRun.logger.child({
@@ -1106,7 +1401,7 @@ var WorkflowVersionImpl = class {
         failed: { childWorkflowRunWaits: [] }
       },
       logger,
-      this[INTERNAL5].eventsDefinition
+      this[INTERNAL7].eventsDefinition
     );
   }
   async throwNonDeterminismError(parentRun, parentRunHandle, inputHash, referenceId, manifest) {
@@ -1120,8 +1415,8 @@ var WorkflowVersionImpl = class {
       logMeta["aiki.referenceId"] = referenceId;
     }
     parentRun.logger.error("Replay divergence", logMeta);
-    const error = new NonDeterminismError(parentRun.id, parentRunHandle.run.attempts, unconsumedManifestEntries);
-    await parentRunHandle[INTERNAL5].transitionState({
+    const error = new NonDeterminismError3(parentRun.id, parentRunHandle.run.attempts, unconsumedManifestEntries);
+    await parentRunHandle[INTERNAL7].transitionState({
       status: "failed",
       cause: "self",
       error: createSerializableError(error)
@@ -1129,7 +1424,7 @@ var WorkflowVersionImpl = class {
     throw error;
   }
   async getHandleById(client, runId) {
-    return workflowRunHandle(client, runId, this[INTERNAL5].eventsDefinition);
+    return workflowRunHandle(client, runId, this[INTERNAL7].eventsDefinition);
   }
   async getHandleByReferenceId(client, referenceId) {
     const { run } = await client.api.workflowRun.getByReferenceIdV1({
@@ -1137,39 +1432,39 @@ var WorkflowVersionImpl = class {
       versionId: this.versionId,
       referenceId
     });
-    return workflowRunHandle(client, run, this[INTERNAL5].eventsDefinition);
+    return workflowRunHandle(client, run, this[INTERNAL7].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 { handle } = run[INTERNAL7];
+    handle[INTERNAL7].assertExecutionAllowed();
+    const retryStrategy = this.params.options?.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" });
+    await handle[INTERNAL7].transitionState({ status: "running" });
     const output = await this.tryExecuteWorkflow(input, run, context, retryStrategy);
-    await handle[INTERNAL5].transitionState({ status: "completed", output });
+    await handle[INTERNAL7].transitionState({ status: "completed", output });
     logger.info("Workflow complete");
   }
   async tryExecuteWorkflow(input, run, context, retryStrategy) {
-    const { handle } = run[INTERNAL5];
+    const { handle } = run[INTERNAL7];
     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 WorkflowRunFailedError2 || error instanceof WorkflowRunRevisionConflictError5 || error instanceof NonDeterminismError) {
+        if (error instanceof WorkflowRunSuspendedError6 || error instanceof WorkflowRunFailedError4 || error instanceof WorkflowRunRevisionConflictError7 || error instanceof NonDeterminismError3) {
           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);
+          await handle[INTERNAL7].transitionState(failedState);
           const logMeta2 = {};
           for (const [key, value] of Object.entries(failedState)) {
             logMeta2[`aiki.${key}`] = value;
@@ -1178,10 +1473,10 @@ var WorkflowVersionImpl = class {
             "aiki.attempts": attempts,
             ...logMeta2
           });
-          throw new WorkflowRunFailedError2(run.id, attempts);
+          throw new WorkflowRunFailedError4(run.id, attempts);
         }
         const awaitingRetryState = this.createAwaitingRetryState(error, retryParams.delayMs);
-        await handle[INTERNAL5].transitionState(awaitingRetryState);
+        await handle[INTERNAL7].transitionState(awaitingRetryState);
         const logMeta = {};
         for (const [key, value] of Object.entries(awaitingRetryState)) {
           logMeta[`aiki.${key}`] = value;
@@ -1190,7 +1485,7 @@ var WorkflowVersionImpl = class {
           "aiki.attempts": attempts,
           ...logMeta
         });
-        throw new WorkflowRunSuspendedError4(run.id);
+        throw new WorkflowRunSuspendedError6(run.id);
       }
     }
   }
@@ -1199,8 +1494,8 @@ var WorkflowVersionImpl = class {
     const retryParams = getRetryParams(attempts, retryStrategy);
     if (!retryParams.retriesLeft) {
       logger.error("Workflow retry not allowed", { "aiki.attempts": attempts });
-      const error = new WorkflowRunFailedError2(id, attempts);
-      await handle[INTERNAL5].transitionState({
+      const error = new WorkflowRunFailedError4(id, attempts);
+      await handle[INTERNAL7].transitionState({
         status: "failed",
         cause: "self",
         error: createSerializableError(error)
@@ -1218,7 +1513,7 @@ var WorkflowVersionImpl = class {
       return schemaValidationResult.value;
     }
     logger.error("Invalid workflow data", { "aiki.issues": schemaValidationResult.issues });
-    await handle[INTERNAL5].transitionState({
+    await handle[INTERNAL7].transitionState({
       status: "failed",
       cause: "self",
       error: {
@@ -1226,10 +1521,10 @@ var WorkflowVersionImpl = class {
         message: JSON.stringify(schemaValidationResult.issues)
       }
     });
-    throw new WorkflowRunFailedError2(handle.run.id, handle.run.attempts);
+    throw new WorkflowRunFailedError4(handle.run.id, handle.run.attempts);
   }
   createFailedState(error) {
-    if (error instanceof TaskFailedError) {
+    if (error instanceof TaskFailedError2) {
       return {
         status: "failed",
         cause: "task",
@@ -1243,7 +1538,7 @@ var WorkflowVersionImpl = class {
     };
   }
   createAwaitingRetryState(error, nextAttemptInMs) {
-    if (error instanceof TaskFailedError) {
+    if (error instanceof TaskFailedError2) {
       return {
         status: "awaiting_retry",
         cause: "task",
@@ -1260,18 +1555,18 @@ var WorkflowVersionImpl = class {
   }
 };
 var WorkflowBuilderImpl = class _WorkflowBuilderImpl {
-  constructor(workflow2, startOptsBuilder) {
+  constructor(workflow2, startOptionsBuilder) {
     this.workflow = workflow2;
-    this.startOptsBuilder = startOptsBuilder;
+    this.startOptionsBuilder = startOptionsBuilder;
   }
   opt(path, value) {
-    return new _WorkflowBuilderImpl(this.workflow, this.startOptsBuilder.with(path, value));
+    return new _WorkflowBuilderImpl(this.workflow, this.startOptionsBuilder.with(path, value));
   }
   start(client, ...args) {
-    return this.workflow.startWithOpts(client, this.startOptsBuilder.build(), ...args);
+    return this.workflow.startWithOptions(client, this.startOptionsBuilder.build(), ...args);
   }
   startAsChild(parentRun, ...args) {
-    return this.workflow.startAsChildWithOpts(parentRun, this.startOptsBuilder.build(), ...args);
+    return this.workflow.startAsChildWithOptions(parentRun, this.startOptionsBuilder.build(), ...args);
   }
 };
 
@@ -1281,11 +1576,11 @@ function workflow(params) {
 }
 var WorkflowImpl = class {
   name;
-  [INTERNAL6];
+  [INTERNAL8];
   workflowVersions = /* @__PURE__ */ new Map();
   constructor(params) {
     this.name = params.name;
-    this[INTERNAL6] = {
+    this[INTERNAL8] = {
       getAllVersions: this.getAllVersions.bind(this),
       getVersion: this.getVersion.bind(this)
     };
@@ -1295,10 +1590,7 @@ var WorkflowImpl = class {
       throw new Error(`Workflow "${this.name}:${versionId}" already exists`);
     }
     const workflowVersion = new WorkflowVersionImpl(this.name, versionId, params);
-    this.workflowVersions.set(
-      versionId,
-      workflowVersion
-    );
+    this.workflowVersions.set(versionId, workflowVersion);
     return workflowVersion;
   }
   getAllVersions() {
@@ -1308,13 +1600,49 @@ var WorkflowImpl = class {
     return this.workflowVersions.get(versionId);
   }
 };
+
+// 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);
+    }
+  });
+};
+
+// system/index.ts
+function getSystemWorkflows(api) {
+  return [createCancelChildRunsV1(api)];
+}
 export {
-  WorkflowVersionImpl,
   createEventSenders,
   createEventWaiters,
   createReplayManifest,
   createSleeper,
   event,
+  executeWorkflowRun,
+  getSystemWorkflows,
   schedule,
   workflow,
   workflowRegistry,