@aikirun/workflow 0.6.0 → 0.8.0

package/dist/index.js

@@ -3,15 +3,15 @@ function workflowRegistry() {
   return new WorkflowRegistryImpl();
 }
 var WorkflowRegistryImpl = class {
-  workflowsById = /* @__PURE__ */ new Map();
+  workflowsByName = /* @__PURE__ */ new Map();
   add(workflow2) {
-    const workflows = this.workflowsById.get(workflow2.id);
+    const workflows = this.workflowsByName.get(workflow2.name);
     if (!workflows) {
-      this.workflowsById.set(workflow2.id, /* @__PURE__ */ new Map([[workflow2.versionId, workflow2]]));
+      this.workflowsByName.set(workflow2.name, /* @__PURE__ */ new Map([[workflow2.versionId, workflow2]]));
       return this;
     }
     if (workflows.has(workflow2.versionId)) {
-      throw new Error(`Workflow "${workflow2.id}/${workflow2.versionId}" is already registered`);
+      throw new Error(`Workflow "${workflow2.name}/${workflow2.versionId}" is already registered`);
     }
     workflows.set(workflow2.versionId, workflow2);
     return this;
@@ -23,7 +23,7 @@ var WorkflowRegistryImpl = class {
     return this;
   }
   remove(workflow2) {
-    const workflowVersinos = this.workflowsById.get(workflow2.id);
+    const workflowVersinos = this.workflowsByName.get(workflow2.name);
     if (workflowVersinos) {
       workflowVersinos.delete(workflow2.versionId);
     }
@@ -36,20 +36,20 @@ var WorkflowRegistryImpl = class {
     return this;
   }
   removeAll() {
-    this.workflowsById.clear();
+    this.workflowsByName.clear();
     return this;
   }
   getAll() {
     const workflows = [];
-    for (const workflowVersions of this.workflowsById.values()) {
+    for (const workflowVersions of this.workflowsByName.values()) {
       for (const workflow2 of workflowVersions.values()) {
         workflows.push(workflow2);
       }
     }
     return workflows;
   }
-  get(id, versionId) {
-    return this.workflowsById.get(id)?.get(versionId);
+  get(name, versionId) {
+    return this.workflowsByName.get(name)?.get(versionId);
   }
 };
 
@@ -77,6 +77,42 @@ function delay(ms, options) {
   });
 }
 
+// ../../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;
@@ -254,6 +290,7 @@ function getRetryParams(attempts, strategy) {
 // run/event.ts
 import { INTERNAL } from "@aikirun/types/symbols";
 import {
+  WorkflowRunConflictError,
   WorkflowRunFailedError,
   WorkflowRunSuspendedError
 } from "@aikirun/types/workflow-run";
@@ -265,23 +302,24 @@ function event(params) {
 }
 function createEventWaiters(handle, eventsDefinition, logger) {
   const waiters = {};
-  for (const [eventId, eventDefinition] of Object.entries(eventsDefinition)) {
+  for (const [eventName, eventDefinition] of Object.entries(eventsDefinition)) {
     const waiter = createEventWaiter(
       handle,
-      eventId,
+      eventName,
       eventDefinition.schema,
-      logger.child({ "aiki.eventId": eventId })
+      logger.child({ "aiki.eventName": eventName })
     );
-    waiters[eventId] = waiter;
+    waiters[eventName] = waiter;
   }
   return waiters;
 }
-function createEventWaiter(handle, eventId, schema, logger) {
+function createEventWaiter(handle, eventName, schema, logger) {
   let nextEventIndex = 0;
   async function wait(options) {
-    const events = handle.run.eventsQueue[eventId]?.events ?? [];
-    if (nextEventIndex < events.length) {
-      const event2 = events[nextEventIndex];
+    await handle.refresh();
+    const events = handle.run.eventsQueue[eventName]?.events ?? [];
+    const event2 = events[nextEventIndex];
+    if (event2) {
       nextEventIndex++;
       if (event2.status === "timeout") {
         logger.debug("Timed out waiting for event");
@@ -292,11 +330,10 @@ function createEventWaiter(handle, eventId, schema, logger) {
         data = schema ? schema.parse(event2.data) : event2.data;
       } catch (error) {
         logger.error("Invalid event data", { data: event2.data, error });
-        const serializableError = createSerializableError(error);
         await handle[INTERNAL].transitionState({
           status: "failed",
           cause: "self",
-          error: serializableError
+          error: createSerializableError(error)
         });
         throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
       }
@@ -304,81 +341,160 @@ function createEventWaiter(handle, eventId, schema, logger) {
       return { timeout: false, data };
     }
     const timeoutInMs = options?.timeout && toMilliseconds(options.timeout);
-    logger.info("Waiting for event", {
-      ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
-    });
-    await handle[INTERNAL].transitionState({
-      status: "awaiting_event",
-      eventId,
-      timeoutInMs
-    });
+    try {
+      await handle[INTERNAL].transitionState({
+        status: "awaiting_event",
+        eventName,
+        timeoutInMs
+      });
+      logger.info("Waiting for event", {
+        ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
+      });
+    } catch (error) {
+      if (error instanceof WorkflowRunConflictError) {
+        throw new WorkflowRunSuspendedError(handle.run.id);
+      }
+      throw error;
+    }
     throw new WorkflowRunSuspendedError(handle.run.id);
   }
   return { wait };
 }
 function createEventSenders(api, workflowRunId, eventsDefinition, logger, onSend) {
   const senders = {};
-  for (const [eventId, eventDefinition] of Object.entries(eventsDefinition)) {
+  for (const [eventName, eventDefinition] of Object.entries(eventsDefinition)) {
     const sender = createEventSender(
       api,
       workflowRunId,
-      eventId,
+      eventName,
       eventDefinition.schema,
-      logger.child({ "aiki.eventId": eventId }),
+      logger.child({ "aiki.eventName": eventName }),
       onSend
     );
-    senders[eventId] = sender;
+    senders[eventName] = sender;
   }
   return senders;
 }
-function createEventSender(api, workflowRunId, eventId, schema, logger, onSend) {
+function createEventSender(api, workflowRunId, eventName, schema, logger, onSend, options) {
+  const optsOverrider = objectOverrider(options ?? {});
+  const createBuilder = (optsBuilder) => ({
+    opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+    send: (...args) => createEventSender(api, workflowRunId, eventName, schema, logger, onSend, optsBuilder.build()).send(...args)
+  });
+  async function send(...args) {
+    const data = isNonEmptyArray(args) ? args[0] : void 0;
+    if (schema) {
+      schema.parse(data);
+    }
+    const { run } = await api.workflowRun.sendEventV1({
+      id: workflowRunId,
+      eventName,
+      data,
+      options
+    });
+    onSend(run);
+    logger.info("Sent event to workflow", {
+      ...options?.reference ? { "aiki.referenceId": options.reference.id } : {}
+    });
+  }
   return {
-    async send(data, options) {
-      if (schema) {
-        schema.parse(data);
-      }
-      logger.debug("Sending event", {
-        ...options?.idempotencyKey ? { "aiki.idempotencyKey": options.idempotencyKey } : {}
-      });
-      const { run } = await api.workflowRun.sendEventV1({
-        id: workflowRunId,
-        eventId,
-        data,
-        options
-      });
-      onSend(run);
+    with: () => createBuilder(optsOverrider()),
+    send
+  };
+}
+function createEventMulticasters(workflowName, workflowVersionId, eventsDefinition) {
+  const senders = {};
+  for (const [eventName, eventDefinition] of Object.entries(eventsDefinition)) {
+    const sender = createEventMulticaster(
+      workflowName,
+      workflowVersionId,
+      eventName,
+      eventDefinition.schema
+    );
+    senders[eventName] = sender;
+  }
+  return senders;
+}
+function createEventMulticaster(workflowName, workflowVersionId, eventName, schema, options) {
+  const optsOverrider = objectOverrider(options ?? {});
+  const createBuilder = (optsBuilder) => ({
+    opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+    send: (client, runId, ...args) => createEventMulticaster(workflowName, workflowVersionId, eventName, schema, optsBuilder.build()).send(
+      client,
+      runId,
+      ...args
+    )
+  });
+  async function send(client, runId, ...args) {
+    const data = isNonEmptyArray(args) ? args[0] : void 0;
+    if (schema) {
+      schema.parse(data);
     }
+    const runIds = Array.isArray(runId) ? runId : [runId];
+    if (!isNonEmptyArray(runIds)) {
+      return;
+    }
+    const logger = client.logger.child({
+      "aiki.workflowName": workflowName,
+      "aiki.workflowVersionId": workflowVersionId,
+      "aiki.eventName": eventName
+    });
+    await client.api.workflowRun.multicastEventV1({
+      ids: runIds,
+      eventName,
+      data,
+      options
+    });
+    logger.info("Multicasted event to workflows", {
+      "aiki.workflowName": workflowName,
+      "aiki.workflowVersionId": workflowVersionId,
+      "aiki.workflowRunIds": runIds,
+      "aiki.eventName": eventName,
+      ...options?.reference ? { "aiki.referenceId": options.reference.id } : {}
+    });
+  }
+  return {
+    with: () => createBuilder(optsOverrider()),
+    send
   };
 }
 
 // run/handle.ts
 import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
 import {
+  isTerminalWorkflowRunStatus,
+  WorkflowRunConflictError as WorkflowRunConflictError2,
   WorkflowRunNotExecutableError
 } 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.api,
+    client,
     run,
     eventsDefinition ?? {},
-    logger ?? client.logger.child({ "aiki.workflowRunId": run.id })
+    logger ?? client.logger.child({
+      "aiki.workflowName": run.name,
+      "aiki.workflowVersionId": run.versionId,
+      "aiki.workflowRunId": run.id
+    })
   );
 }
 var WorkflowRunHandleImpl = class {
-  constructor(api, _run, eventsDefinition, logger) {
-    this.api = api;
+  constructor(client, _run, eventsDefinition, logger) {
     this._run = _run;
     this.logger = logger;
-    this.events = createEventSenders(this.api, this._run.id, eventsDefinition, this.logger, (run) => {
+    this.api = client.api;
+    this.events = createEventSenders(client.api, this._run.id, eventsDefinition, this.logger, (run) => {
       this._run = run;
     });
     this[INTERNAL2] = {
+      client,
       transitionState: this.transitionState.bind(this),
       transitionTaskState: this.transitionTaskState.bind(this),
       assertExecutionAllowed: this.assertExecutionAllowed.bind(this)
     };
   }
+  api;
   events;
   [INTERNAL2];
   get run() {
@@ -388,95 +504,119 @@ var WorkflowRunHandleImpl = class {
     const { run: currentRun } = await this.api.workflowRun.getByIdV1({ id: this.run.id });
     this._run = currentRun;
   }
-  // TODO: instead polling the current state, use the transition history
-  // because it is entirely possible for a workflow to flash though a state
+  // TODO: instead checking the current state, use the transition history
+  // because it is possible for a workflow to flash though a state
   // and the handle will never know that the workflow hit that state
-  async wait(condition, options) {
-    if (options.abortSignal?.aborted) {
-      throw new Error("Wait operation aborted");
-    }
-    const delayMs = options.pollIntervalMs ?? 1e3;
-    const maxAttempts = Math.ceil(options.maxDurationMs / delayMs);
-    switch (condition.type) {
-      case "status": {
-        if (options.abortSignal !== void 0) {
-          const maybeResult2 = await withRetry(
-            async () => {
-              await this.refresh();
-              return this.run.state;
-            },
-            { type: "fixed", maxAttempts, delayMs },
-            {
-              abortSignal: options.abortSignal,
-              shouldRetryOnResult: (state) => Promise.resolve(state.status !== condition.status)
-            }
-          ).run();
-          if (maybeResult2.state === "timeout" || maybeResult2.state === "aborted") {
-            return { success: false, cause: maybeResult2.state };
-          }
-          return {
-            success: true,
-            state: maybeResult2.result
-          };
-        }
-        const maybeResult = await withRetry(
-          async () => {
-            await this.refresh();
-            return this.run.state;
-          },
-          { type: "fixed", maxAttempts, delayMs },
-          { shouldRetryOnResult: (state) => Promise.resolve(state.status !== condition.status) }
-        ).run();
-        if (maybeResult.state === "timeout") {
-          return { success: false, cause: maybeResult.state };
-        }
+  async waitForStatus(status, options) {
+    return this.waitForStatusByPolling(status, options);
+  }
+  async waitForStatusByPolling(expectedStatus, options) {
+    if (options?.abortSignal?.aborted) {
+      return {
+        success: false,
+        cause: "aborted"
+      };
+    }
+    const delayMs = options?.interval ? toMilliseconds(options.interval) : 1e3;
+    const maxAttempts = options?.timeout ? Math.ceil(toMilliseconds(options.timeout) / delayMs) : Number.POSITIVE_INFINITY;
+    const retryStrategy = { type: "fixed", maxAttempts, delayMs };
+    const loadState = async () => {
+      await this.refresh();
+      return this.run.state;
+    };
+    const isNeitherExpectedNorTerminal = (state) => Promise.resolve(state.status !== expectedStatus && !isTerminalWorkflowRunStatus(state.status));
+    if (!Number.isFinite(maxAttempts) && !options?.abortSignal) {
+      const maybeResult2 = await withRetry(loadState, retryStrategy, {
+        shouldRetryOnResult: isNeitherExpectedNorTerminal
+      }).run();
+      if (maybeResult2.state === "timeout") {
+        throw new Error("Something's wrong, this should've never timed out");
+      }
+      if (await isNeitherExpectedNorTerminal(maybeResult2.result)) {
         return {
-          success: true,
-          state: maybeResult.result
+          success: false,
+          cause: "run_terminated"
         };
       }
-      case "event": {
-        throw new Error("Event-based waiting is not yet implemented");
+      return {
+        success: true,
+        state: maybeResult2.result
+      };
+    }
+    const maybeResult = options?.abortSignal ? await withRetry(loadState, retryStrategy, {
+      abortSignal: options.abortSignal,
+      shouldRetryOnResult: isNeitherExpectedNorTerminal
+    }).run() : await withRetry(loadState, retryStrategy, { shouldRetryOnResult: isNeitherExpectedNorTerminal }).run();
+    if (maybeResult.state === "completed") {
+      if (await isNeitherExpectedNorTerminal(maybeResult.result)) {
+        return {
+          success: false,
+          cause: "run_terminated"
+        };
       }
-      default:
-        return condition;
+      return {
+        success: true,
+        state: maybeResult.result
+      };
     }
+    return { success: false, cause: maybeResult.state };
   }
   async cancel(reason) {
-    return this.transitionState({ status: "cancelled", reason });
+    await this.transitionState({ status: "cancelled", reason });
+    this.logger.info("Workflow cancelled");
   }
   async pause() {
-    return this.transitionState({ status: "paused" });
+    await this.transitionState({ status: "paused" });
+    this.logger.info("Workflow paused");
   }
   async resume() {
-    return this.transitionState({ status: "scheduled", scheduledInMs: 0, reason: "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) {
-    if (targetState.status === "scheduled" && (targetState.reason === "new" || targetState.reason === "resume") || targetState.status === "paused" || targetState.status === "cancelled") {
-      const { run: run2 } = await this.api.workflowRun.transitionStateV1({
-        type: "pessimistic",
+    try {
+      if (targetState.status === "scheduled" && (targetState.reason === "new" || targetState.reason === "resume" || targetState.reason === "awake_early") || targetState.status === "paused" || targetState.status === "cancelled") {
+        const { run: run2 } = await this.api.workflowRun.transitionStateV1({
+          type: "pessimistic",
+          id: this.run.id,
+          state: targetState
+        });
+        this._run = run2;
+        return;
+      }
+      const { run } = await this.api.workflowRun.transitionStateV1({
+        type: "optimistic",
         id: this.run.id,
-        state: targetState
+        state: targetState,
+        expectedRevision: this.run.revision
       });
-      this._run = run2;
-      return;
+      this._run = run;
+    } catch (error) {
+      if (isConflictError(error)) {
+        throw new WorkflowRunConflictError2(this.run.id);
+      }
+      throw error;
+    }
+  }
+  async transitionTaskState(request) {
+    try {
+      const { run, taskId } = await this.api.workflowRun.transitionTaskStateV1({
+        ...request,
+        id: this.run.id,
+        expectedRevision: this.run.revision
+      });
+      this._run = run;
+      return { taskId };
+    } catch (error) {
+      if (isConflictError(error)) {
+        throw new WorkflowRunConflictError2(this.run.id);
+      }
+      throw error;
     }
-    const { run } = await this.api.workflowRun.transitionStateV1({
-      type: "optimistic",
-      id: this.run.id,
-      state: targetState,
-      expectedRevision: this.run.revision
-    });
-    this._run = run;
-  }
-  async transitionTaskState(taskPath, taskState) {
-    const { run } = await this.api.workflowRun.transitionTaskStateV1({
-      id: this.run.id,
-      taskPath,
-      taskState,
-      expectedRevision: this.run.revision
-    });
-    this._run = run;
   }
   assertExecutionAllowed() {
     const status = this.run.state.status;
@@ -485,133 +625,394 @@ var WorkflowRunHandleImpl = class {
     }
   }
 };
+function isConflictError(error) {
+  return error != null && typeof error === "object" && "code" in error && error.code === "CONFLICT";
+}
 
 // run/sleeper.ts
 import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
-import { WorkflowRunSuspendedError as WorkflowRunSuspendedError2 } from "@aikirun/types/workflow-run";
+import { WorkflowRunConflictError as WorkflowRunConflictError3, WorkflowRunSuspendedError as WorkflowRunSuspendedError2 } from "@aikirun/types/workflow-run";
 var MAX_SLEEP_YEARS = 10;
 var MAX_SLEEP_MS = MAX_SLEEP_YEARS * 365 * 24 * 60 * 60 * 1e3;
-function createSleeper(handle, logger, options) {
-  return async (params) => {
-    const { id: sleepId, ...durationFields } = params;
-    const durationMs = toMilliseconds(durationFields);
+function createSleeper(handle, logger) {
+  const nextSleepIndexByName = {};
+  return async (name, duration) => {
+    const sleepName = name;
+    let durationMs = toMilliseconds(duration);
     if (durationMs > MAX_SLEEP_MS) {
       throw new Error(`Sleep duration ${durationMs}ms exceeds maximum of ${MAX_SLEEP_YEARS} years`);
     }
-    const sleepPath = `${sleepId}/${durationMs}`;
-    const sleepState = handle.run.sleepsState[sleepPath] ?? { status: "none" };
-    if (sleepState.status === "completed") {
-      logger.debug("Sleep completed", {
-        "aiki.sleepId": sleepId,
-        "aiki.durationMs": durationMs
+    const nextSleepIndex = nextSleepIndexByName[sleepName] ?? 0;
+    const sleepQueue = handle.run.sleepsQueue[sleepName] ?? { sleeps: [] };
+    const sleepState = sleepQueue.sleeps[nextSleepIndex];
+    if (!sleepState) {
+      try {
+        await handle[INTERNAL3].transitionState({ status: "sleeping", sleepName, durationMs });
+        logger.info("Sleeping", {
+          "aiki.sleepName": sleepName,
+          "aiki.durationMs": durationMs
+        });
+      } catch (error) {
+        if (error instanceof WorkflowRunConflictError3) {
+          throw new WorkflowRunSuspendedError2(handle.run.id);
+        }
+        throw error;
+      }
+      throw new WorkflowRunSuspendedError2(handle.run.id);
+    }
+    if (sleepState.status === "sleeping") {
+      logger.debug("Already sleeping", {
+        "aiki.sleepName": sleepName,
+        "aiki.awakeAt": sleepState.awakeAt
       });
-      return { cancelled: false };
+      throw new WorkflowRunSuspendedError2(handle.run.id);
     }
+    sleepState.status;
+    nextSleepIndexByName[sleepName] = nextSleepIndex + 1;
     if (sleepState.status === "cancelled") {
       logger.debug("Sleep cancelled", {
-        "aiki.sleepId": sleepId,
-        "aiki.durationMs": durationMs
+        "aiki.sleepName": sleepName,
+        "aiki.cancelledAt": sleepState.cancelledAt
       });
       return { cancelled: true };
     }
-    if (sleepState.status === "sleeping") {
-      logger.debug("Already sleeping", {
-        "aiki.sleepId": sleepId,
-        "aiki.durationMs": durationMs
+    if (durationMs === sleepState.durationMs) {
+      logger.debug("Sleep completed", {
+        "aiki.sleepName": sleepName,
+        "aiki.durationMs": durationMs,
+        "aiki.completedAt": sleepState.completedAt
       });
-      throw new WorkflowRunSuspendedError2(handle.run.id);
+      return { cancelled: false };
     }
-    sleepState;
-    if (durationMs <= options.spinThresholdMs) {
-      logger.debug("Spinning for short sleep", {
-        "aiki.sleepId": sleepId,
-        "aiki.durationMs": durationMs
+    if (durationMs > sleepState.durationMs) {
+      logger.warn("Higher sleep duration encountered during replay. Sleeping for remaining duration", {
+        "aiki.sleepName": sleepName,
+        "aiki.historicDurationMs": sleepState.durationMs,
+        "aiki.latestDurationMs": durationMs
+      });
+      durationMs -= sleepState.durationMs;
+    } else {
+      logger.warn("Lower sleep duration encountered during replay. Already slept enough", {
+        "aiki.sleepName": sleepName,
+        "aiki.historicDurationMs": sleepState.durationMs,
+        "aiki.latestDurationMs": durationMs
       });
-      await delay(durationMs);
       return { cancelled: false };
     }
-    await handle[INTERNAL3].transitionState({ status: "sleeping", sleepPath, durationMs });
-    logger.info("Workflow going to sleep", {
-      "aiki.sleepId": sleepId,
-      "aiki.durationMs": durationMs
-    });
+    try {
+      await handle[INTERNAL3].transitionState({ status: "sleeping", sleepName, durationMs });
+      logger.info("Sleeping", {
+        "aiki.sleepName": sleepName,
+        "aiki.durationMs": durationMs
+      });
+    } catch (error) {
+      if (error instanceof WorkflowRunConflictError3) {
+        throw new WorkflowRunSuspendedError2(handle.run.id);
+      }
+      throw error;
+    }
     throw new WorkflowRunSuspendedError2(handle.run.id);
   };
 }
 
 // workflow.ts
-import { INTERNAL as INTERNAL5 } from "@aikirun/types/symbols";
+import { INTERNAL as INTERNAL6 } from "@aikirun/types/symbols";
+
+// ../../lib/path/index.ts
+function getWorkflowRunPath(name, versionId, referenceId) {
+  return `${name}/${versionId}/${referenceId}`;
+}
 
 // workflow-version.ts
-import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
+import { INTERNAL as INTERNAL5 } from "@aikirun/types/symbols";
 import { TaskFailedError } from "@aikirun/types/task";
 import {
+  WorkflowRunConflictError as WorkflowRunConflictError5,
   WorkflowRunFailedError as WorkflowRunFailedError2,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError4
+} from "@aikirun/types/workflow-run";
+
+// run/handle-child.ts
+import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
+import {
+  isTerminalWorkflowRunStatus as isTerminalWorkflowRunStatus2,
+  WorkflowRunConflictError as WorkflowRunConflictError4,
   WorkflowRunSuspendedError as WorkflowRunSuspendedError3
 } from "@aikirun/types/workflow-run";
+async function childWorkflowRunHandle(client, run, parentRun, 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, 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, logger) {
+  let nextWaitIndex = 0;
+  async function waitForStatus(expectedStatus, options) {
+    const parentRunHandle = parentRun[INTERNAL4].handle;
+    const waitResults = parentRunHandle.run.childWorkflowRuns[handle.run.path]?.statusWaitResults ?? [];
+    const waitResult = waitResults[nextWaitIndex];
+    if (waitResult) {
+      nextWaitIndex++;
+      if (waitResult.status === "timeout") {
+        logger.debug("Timed out waiting for child workflow status", {
+          "aiki.childWorkflowExpectedStatus": expectedStatus
+        });
+        return {
+          success: false,
+          cause: "timeout"
+        };
+      }
+      if (waitResult.childWorkflowRunState.status === expectedStatus) {
+        return {
+          success: true,
+          state: waitResult.childWorkflowRunState
+        };
+      }
+      if (isTerminalWorkflowRunStatus2(waitResult.childWorkflowRunState.status)) {
+        logger.debug("Child workflow run reached termnial state", {
+          "aiki.childWorkflowTerminalStatus": waitResult.childWorkflowRunState.status
+        });
+        return {
+          success: false,
+          cause: "run_terminated"
+        };
+      }
+    }
+    const { state } = handle.run;
+    if (state.status === expectedStatus) {
+      return {
+        success: true,
+        state
+      };
+    }
+    if (isTerminalWorkflowRunStatus2(state.status)) {
+      logger.debug("Child workflow run reached termnial state", {
+        "aiki.childWorkflowTerminalStatus": state.status
+      });
+      return {
+        success: false,
+        cause: "run_terminated"
+      };
+    }
+    const timeoutInMs = options?.timeout && toMilliseconds(options.timeout);
+    try {
+      await parentRunHandle[INTERNAL4].transitionState({
+        status: "awaiting_child_workflow",
+        childWorkflowRunId: handle.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 WorkflowRunConflictError4) {
+        throw new WorkflowRunSuspendedError3(parentRun.id);
+      }
+      throw error;
+    }
+    throw new WorkflowRunSuspendedError3(parentRun.id);
+  }
+  return waitForStatus;
+}
+
+// workflow-version.ts
 var WorkflowVersionImpl = class _WorkflowVersionImpl {
-  constructor(id, versionId, params) {
-    this.id = id;
+  constructor(name, versionId, params) {
+    this.name = name;
     this.versionId = versionId;
     this.params = params;
-    this[INTERNAL4] = {
-      eventsDefinition: this.params.events ?? {},
+    const eventsDefinition = this.params.events ?? {};
+    this.events = createEventMulticasters(this.name, this.versionId, eventsDefinition);
+    this[INTERNAL5] = {
+      eventsDefinition,
       handler: this.handler.bind(this)
     };
   }
-  [INTERNAL4];
+  events;
+  [INTERNAL5];
   with() {
     const optsOverrider = objectOverrider(this.params.opts ?? {});
-    const createBuilder = (optsBuilder) => ({
-      opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
-      start: (client, ...args) => new _WorkflowVersionImpl(this.id, this.versionId, { ...this.params, opts: optsBuilder.build() }).start(
-        client,
-        ...args
-      )
-    });
+    const createBuilder = (optsBuilder) => {
+      return {
+        opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+        start: (client, ...args) => new _WorkflowVersionImpl(this.name, this.versionId, {
+          ...this.params,
+          opts: optsBuilder.build()
+        }).start(client, ...args),
+        startAsChild: (parentRun, ...args) => new _WorkflowVersionImpl(this.name, this.versionId, {
+          ...this.params,
+          opts: optsBuilder.build()
+        }).startAsChild(parentRun, ...args)
+      };
+    };
     return createBuilder(optsOverrider());
   }
   async start(client, ...args) {
+    const inputRaw = isNonEmptyArray(args) ? args[0] : void 0;
+    const input = this.params.schema?.input ? this.params.schema.input.parse(inputRaw) : inputRaw;
     const { run } = await client.api.workflowRun.createV1({
-      workflowId: this.id,
-      workflowVersionId: this.versionId,
-      input: isNonEmptyArray(args) ? args[0] : null,
+      name: this.name,
+      versionId: this.versionId,
+      input,
+      options: this.params.opts
+    });
+    client.logger.info("Created workflow", {
+      "aiki.workflowName": this.name,
+      "aiki.workflowVersionId": this.versionId,
+      "aiki.workflowRunId": run.id
+    });
+    return workflowRunHandle(client, run, this[INTERNAL5].eventsDefinition);
+  }
+  async startAsChild(parentRun, ...args) {
+    const parentRunHandle = parentRun[INTERNAL5].handle;
+    parentRunHandle[INTERNAL5].assertExecutionAllowed();
+    const { client } = parentRunHandle[INTERNAL5];
+    const inputRaw = isNonEmptyArray(args) ? args[0] : void 0;
+    let input = inputRaw;
+    if (this.params.schema?.input) {
+      try {
+        input = this.params.schema.input.parse(inputRaw);
+      } catch (error) {
+        await parentRunHandle[INTERNAL5].transitionState({
+          status: "failed",
+          cause: "self",
+          error: createSerializableError(error)
+        });
+        throw new WorkflowRunFailedError2(parentRun.id, parentRunHandle.run.attempts);
+      }
+    }
+    const inputHash = await hashInput(input);
+    const reference = this.params.opts?.reference;
+    const path = getWorkflowRunPath(this.name, this.versionId, reference?.id ?? inputHash);
+    const existingRunInfo = parentRunHandle.run.childWorkflowRuns[path];
+    if (existingRunInfo) {
+      await this.assertUniqueChildRunReferenceId(
+        parentRunHandle,
+        existingRunInfo,
+        inputHash,
+        reference,
+        parentRun.logger
+      );
+      const { run: existingRun } = await client.api.workflowRun.getByIdV1({ id: existingRunInfo.id });
+      const logger2 = parentRun.logger.child({
+        "aiki.childWorkflowName": existingRun.name,
+        "aiki.childWorkflowVersionId": existingRun.versionId,
+        "aiki.childWorkflowRunId": existingRun.id
+      });
+      return childWorkflowRunHandle(
+        client,
+        existingRun,
+        parentRun,
+        logger2,
+        this[INTERNAL5].eventsDefinition
+      );
+    }
+    const { run: newRun } = await client.api.workflowRun.createV1({
+      name: this.name,
+      versionId: this.versionId,
+      input,
+      parentWorkflowRunId: parentRun.id,
       options: this.params.opts
     });
-    return workflowRunHandle(client, run, this[INTERNAL4].eventsDefinition);
+    parentRunHandle.run.childWorkflowRuns[path] = {
+      id: newRun.id,
+      inputHash,
+      statusWaitResults: []
+    };
+    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,
+      logger,
+      this[INTERNAL5].eventsDefinition
+    );
+  }
+  async assertUniqueChildRunReferenceId(parentRunHandle, existingRunInfo, inputHash, reference, logger) {
+    if (existingRunInfo.inputHash !== inputHash && reference) {
+      const onConflict = reference.onConflict ?? "error";
+      if (onConflict !== "error") {
+        return;
+      }
+      logger.error("Reference ID already used by another child workflow", {
+        "aiki.referenceId": reference.id,
+        "aiki.existingChildWorkflowRunId": existingRunInfo.id
+      });
+      const error = new WorkflowRunFailedError2(
+        parentRunHandle.run.id,
+        parentRunHandle.run.attempts,
+        `Reference ID "${reference.id}" already used by another child workflow run ${existingRunInfo.id}`
+      );
+      await parentRunHandle[INTERNAL5].transitionState({
+        status: "failed",
+        cause: "self",
+        error: createSerializableError(error)
+      });
+      throw error;
+    }
   }
   async getHandle(client, runId) {
-    return workflowRunHandle(client, runId, this[INTERNAL4].eventsDefinition);
+    return workflowRunHandle(client, runId, this[INTERNAL5].eventsDefinition);
   }
-  async handler(input, run, context) {
+  async handler(run, input, context) {
     const { logger } = run;
-    const { handle } = run[INTERNAL4];
-    handle[INTERNAL4].assertExecutionAllowed();
+    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[INTERNAL4].transitionState({ status: "running" });
+    await handle[INTERNAL5].transitionState({ status: "running" });
     const output = await this.tryExecuteWorkflow(input, run, context, retryStrategy);
-    await handle[INTERNAL4].transitionState({ status: "completed", output });
+    await handle[INTERNAL5].transitionState({ status: "completed", output });
     logger.info("Workflow complete");
   }
   async tryExecuteWorkflow(input, run, context, retryStrategy) {
     while (true) {
       try {
-        return await this.params.handler(input, run, context);
+        const outputRaw = await this.params.handler(run, input, context);
+        let output = outputRaw;
+        if (this.params.schema?.output) {
+          try {
+            output = this.params.schema.output.parse(outputRaw);
+          } catch (error) {
+            const { handle } = run[INTERNAL5];
+            await handle[INTERNAL5].transitionState({
+              status: "failed",
+              cause: "self",
+              error: createSerializableError(error)
+            });
+            throw new WorkflowRunFailedError2(run.id, handle.run.attempts);
+          }
+        }
+        return output;
       } catch (error) {
-        if (error instanceof WorkflowRunSuspendedError3) {
+        if (error instanceof WorkflowRunSuspendedError4 || error instanceof WorkflowRunFailedError2 || error instanceof WorkflowRunConflictError5) {
           throw error;
         }
-        const { handle } = run[INTERNAL4];
+        const { handle } = run[INTERNAL5];
         const attempts = handle.run.attempts;
         const retryParams = getRetryParams(attempts, retryStrategy);
         if (!retryParams.retriesLeft) {
           const failedState = this.createFailedState(error);
-          await handle[INTERNAL4].transitionState(failedState);
+          await handle[INTERNAL5].transitionState(failedState);
           const logMeta2 = {};
           for (const [key, value] of Object.entries(failedState)) {
             logMeta2[`aiki.${key}`] = value;
@@ -623,7 +1024,7 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
           throw new WorkflowRunFailedError2(run.id, attempts);
         }
         const awaitingRetryState = this.createAwaitingRetryState(error, retryParams.delayMs);
-        await handle[INTERNAL4].transitionState(awaitingRetryState);
+        await handle[INTERNAL5].transitionState(awaitingRetryState);
         const logMeta = {};
         for (const [key, value] of Object.entries(awaitingRetryState)) {
           logMeta[`aiki.${key}`] = value;
@@ -633,7 +1034,7 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
           "aiki.delayMs": retryParams.delayMs,
           ...logMeta
         });
-        throw new WorkflowRunSuspendedError3(run.id);
+        throw new WorkflowRunSuspendedError4(run.id);
       }
     }
   }
@@ -643,11 +1044,10 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
     if (!retryParams.retriesLeft) {
       logger.error("Workflow retry not allowed", { "aiki.attempts": attempts });
       const error = new WorkflowRunFailedError2(id, attempts);
-      const serializableError = createSerializableError(error);
-      await handle[INTERNAL4].transitionState({
+      await handle[INTERNAL5].transitionState({
         status: "failed",
         cause: "self",
-        error: serializableError
+        error: createSerializableError(error)
       });
       throw error;
     }
@@ -657,14 +1057,13 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
       return {
         status: "failed",
         cause: "task",
-        taskPath: error.taskPath
+        taskId: error.taskId
       };
     }
-    const serializableError = createSerializableError(error);
     return {
       status: "failed",
       cause: "self",
-      error: serializableError
+      error: createSerializableError(error)
     };
   }
   createAwaitingRetryState(error, nextAttemptInMs) {
@@ -673,15 +1072,14 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
         status: "awaiting_retry",
         cause: "task",
         nextAttemptInMs,
-        taskPath: error.taskPath
+        taskId: error.taskId
       };
     }
-    const serializableError = createSerializableError(error);
     return {
       status: "awaiting_retry",
       cause: "self",
       nextAttemptInMs,
-      error: serializableError
+      error: createSerializableError(error)
     };
   }
 };
@@ -691,21 +1089,21 @@ function workflow(params) {
   return new WorkflowImpl(params);
 }
 var WorkflowImpl = class {
-  id;
-  [INTERNAL5];
+  name;
+  [INTERNAL6];
   workflowVersions = /* @__PURE__ */ new Map();
   constructor(params) {
-    this.id = params.id;
-    this[INTERNAL5] = {
+    this.name = params.name;
+    this[INTERNAL6] = {
       getAllVersions: this.getAllVersions.bind(this),
       getVersion: this.getVersion.bind(this)
     };
   }
   v(versionId, params) {
     if (this.workflowVersions.has(versionId)) {
-      throw new Error(`Workflow "${this.id}/${versionId}" already exists`);
+      throw new Error(`Workflow "${this.name}/${versionId}" already exists`);
     }
-    const workflowVersion = new WorkflowVersionImpl(this.id, versionId, params);
+    const workflowVersion = new WorkflowVersionImpl(this.name, versionId, params);
     this.workflowVersions.set(
       versionId,
       workflowVersion