@usehelical/workflows 0.0.1-alpha.17 → 0.0.1-alpha.19

package/dist/chunk-7I6XZ2V3.js

@@ -0,0 +1,1039 @@
+import { serializeError as serializeError$1, deserializeError as deserializeError$1 } from 'serialize-error';
+import { AsyncLocalStorage } from 'async_hooks';
+import crypto from 'crypto';
+import { sql } from 'kysely';
+
+// src/internal/errors.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["INVALID_WORKFLOW_TRANSITION"] = "INVALID_WORKFLOW_TRANSITION";
+  ErrorType2["RUN_CANCELLED"] = "RUN_CANCELLED";
+  ErrorType2["RUN_NOT_FOUND"] = "RUN_NOT_FOUND";
+  ErrorType2["RUN_OUTSIDE_OF_WORKFLOW"] = "RUN_OUTSIDE_OF_WORKFLOW";
+  ErrorType2["FATAL_ERROR"] = "FATAL_ERROR";
+  ErrorType2["NO_MESSAGE_AVAILABLE"] = "NO_MESSAGE_AVAILABLE";
+  ErrorType2["MAX_RETRIES_EXCEEDED"] = "MAX_RETRIES_EXCEEDED";
+  ErrorType2["ERROR_THAT_SHOULD_NEVER_HAPPEN"] = "ERROR_THAT_SHOULD_NEVER_HAPPEN";
+  ErrorType2["SERIALIZATION_ERROR"] = "SERIALIZATION_ERROR";
+  ErrorType2["MAX_RECOVERY_ATTEMPTS_EXCEEDED"] = "MAX_RECOVERY_ATTEMPTS_EXCEEDED";
+  ErrorType2["WORKFLOW_NOT_FOUND"] = "WORKFLOW_NOT_FOUND";
+  ErrorType2["TIMEOUT"] = "TIMEOUT";
+  ErrorType2["CANCEL"] = "CANCEL";
+  ErrorType2["DEADLINE"] = "DEADLINE";
+  ErrorType2["RUN_NOT_CANCELLABLE"] = "RUN_NOT_CANCELLABLE";
+  ErrorType2["QUEUE_NOT_FOUND"] = "QUEUE_NOT_FOUND";
+  return ErrorType2;
+})(ErrorType || {});
+var BaseError = class extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+  }
+};
+var RunTimedOutError = class extends BaseError {
+  constructor() {
+    super("This workflow run has timed out", "timeout");
+  }
+};
+var UnknownError = class extends BaseError {
+  constructor(message) {
+    super(message || "An unknown error occurred", "unknown");
+  }
+};
+var RunDeadlineExceededError = class extends BaseError {
+  constructor() {
+    super("This workflow run has exceeded its deadline", "deadline");
+  }
+};
+var RunCancelledError = class extends BaseError {
+  constructor() {
+    super("This workflow run has been cancelled", "cancel");
+  }
+};
+var MaxRecoveryAttemptsExceededError = class extends BaseError {
+  constructor(runId, attempts) {
+    super(
+      `Max recovery attempts exceeded for run "${runId}" after ${attempts + 1} attempts`,
+      "max_recovery_attempts_exceeded"
+    );
+  }
+};
+var OperationTimedOutError = class extends BaseError {
+  constructor(operationName) {
+    super(`This operation "${operationName}" has timed out`, "timeout");
+  }
+};
+var RunNotFoundError = class extends BaseError {
+  constructor(runId) {
+    super(`Workflow run "${runId}" not found`, "run_not_found");
+  }
+};
+var RunOutsideOfWorkflowError = class extends BaseError {
+  constructor() {
+    super("This function must be called within a workflow", "outside_workflow_context");
+  }
+};
+var FatalError = class extends BaseError {
+  constructor(message) {
+    super(message, "fatal_error");
+  }
+};
+var MaxRetriesExceededError = class extends BaseError {
+  attemptErrors;
+  stepName;
+  maxAttempts;
+  constructor(stepName, maxAttempts, errors) {
+    const formattedErrors = errors.map((error, index) => `Attempt ${index + 1}: ${error.message}`).join(". ");
+    super(
+      `Step "${stepName}" failed after ${maxAttempts + 1} attempts. ${formattedErrors}`,
+      "max_retries_exceeded"
+    );
+    this.attemptErrors = errors;
+    this.stepName = stepName;
+    this.maxAttempts = maxAttempts;
+  }
+};
+var SerializationError = class extends BaseError {
+  constructor(message) {
+    super(message, "serialization_error");
+  }
+};
+var WorkflowNotFoundError = class extends BaseError {
+  constructor(workflowName) {
+    super(`Workflow "${workflowName}" not found`, "workflow_not_found");
+  }
+};
+
+// src/api/workflow.ts
+var TERMINAL_STATES = [
+  "success",
+  "error",
+  "cancelled",
+  "max_recovery_attempts_exceeded"
+];
+function defineWorkflow(name, fn, options = {}) {
+  return {
+    name,
+    fn,
+    maxRecoveryAttempts: options.maxRecoveryAttempts
+  };
+}
+
+// src/internal/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/internal/db/retry.ts
+var RETRY_SQLSTATE_PREFIXES = /* @__PURE__ */ new Set([
+  "08",
+  // Connection Exception
+  "40",
+  // Transaction Rollback (deadlock_detected, serialization_failure)
+  "53",
+  // Insufficient Resources
+  "55",
+  // Object Not In Prerequisite State (lock_not_available)
+  "57"
+  // Operator Intervention (admin_shutdown, cannot_connect_now)
+]);
+var RETRY_SQLSTATE_CODES = /* @__PURE__ */ new Set([
+  "40003",
+  // statement_completion_unknown
+  "40001",
+  // serialization_failure
+  "40P01",
+  // deadlock_detected
+  "55P03"
+  // lock_not_available
+]);
+var RETRY_NODE_ERRNOS = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ETIMEDOUT",
+  "ECONNABORTED",
+  "EPIPE"
+]);
+function isPgDatabaseError(e) {
+  return !!e && typeof e === "object" && typeof e.code === "string" && e.code.length === 5;
+}
+function sqlStateLooksRetryable(sqlstate) {
+  if (!sqlstate) return false;
+  if (RETRY_SQLSTATE_CODES.has(sqlstate)) return true;
+  const prefix = sqlstate.toString().slice(0, 2);
+  return RETRY_SQLSTATE_PREFIXES.has(prefix);
+}
+function nodeErrnoLooksRetryable(e) {
+  const code = e.code;
+  return !!code && RETRY_NODE_ERRNOS.has(code);
+}
+function messageLooksRetryable(msg) {
+  const m = msg.toLowerCase();
+  return msg.includes("ECONNREFUSED") || msg.includes("ECONNRESET") || m.includes("connection timeout") || m.includes("server closed the connection") || m.includes("connection terminated unexpectedly") || m.includes("client has encountered a connection error") || m.includes("timeout exceeded when trying to connect") || m.includes("could not connect to server") || m.includes("connection pool exhausted") || m.includes("too many clients");
+}
+function* unwrapErrors(e) {
+  const queue = [e];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length) {
+    const cur = queue.shift();
+    if (cur && typeof cur === "object") {
+      if (seen.has(cur)) continue;
+      seen.add(cur);
+      const ae = cur;
+      if (Array.isArray(ae.errors)) queue.push(...ae.errors);
+      const withCause = cur;
+      if (withCause.cause) queue.push(withCause.cause);
+      const wrapped = cur;
+      if (wrapped.error) queue.push(wrapped.error);
+    }
+    yield cur;
+  }
+}
+function isRetriableDBError(err) {
+  for (const e of unwrapErrors(err)) {
+    const anyErr = e;
+    if (isPgDatabaseError(anyErr) && sqlStateLooksRetryable(anyErr.code)) {
+      return true;
+    }
+    if (nodeErrnoLooksRetryable(anyErr)) {
+      return true;
+    }
+    if (e instanceof Error) {
+      if (e.stack && messageLooksRetryable(e.stack)) return true;
+      if (e.message && messageLooksRetryable(e.message)) return true;
+    }
+    if (messageLooksRetryable(String(e))) return true;
+  }
+  return false;
+}
+async function withDbRetry(fn, options = {}) {
+  const { initialBackoffMs = 1e3, maxBackoffMs = 6e4, onRetry } = options;
+  let attempt = 0;
+  let backoffMs = initialBackoffMs;
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (!isRetriableDBError(error)) {
+        throw error;
+      }
+      attempt++;
+      const jitter = 0.5 + Math.random();
+      const delayMs = Math.min(backoffMs * jitter, maxBackoffMs);
+      if (onRetry) {
+        onRetry(error, attempt, delayMs);
+      } else {
+        console.warn(
+          `Database connection failed: ${error instanceof Error ? error.message : String(error)}. Retrying in ${(delayMs / 1e3).toFixed(2)}s (attempt ${attempt})`
+        );
+      }
+      await sleep(delayMs);
+      backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+    }
+  }
+}
+function serialize(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    throw new SerializationError(error.message);
+  }
+}
+function deserialize(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new SerializationError(error.message);
+  }
+}
+function serializeError(error) {
+  try {
+    return JSON.stringify(serializeError$1(error));
+  } catch (error2) {
+    throw new SerializationError(error2.message);
+  }
+}
+function deserializeError(serialized) {
+  try {
+    return deserializeError$1(JSON.parse(serialized));
+  } catch (error) {
+    throw new SerializationError(error.message);
+  }
+}
+function getExecutionContext() {
+  const store = asyncLocalStorage.getStore();
+  if (!store) {
+    throw new RunOutsideOfWorkflowError();
+  }
+  return store;
+}
+var asyncLocalStorage = new AsyncLocalStorage();
+function runWithExecutionContext(store, callback) {
+  return asyncLocalStorage.run(store, callback);
+}
+function createExecutionContext({
+  ctx,
+  abortSignal,
+  runId,
+  runPath,
+  operations
+}) {
+  return {
+    type: "execution",
+    runId,
+    runPath,
+    executorId: ctx.executorId,
+    abortSignal,
+    operationManager: new OperationManager(ctx.db, runId, operations || []),
+    messageEventBus: ctx.messageEventBus,
+    stateEventBus: ctx.stateEventBus,
+    workflowsMap: ctx.workflowsMap,
+    runEventBus: ctx.runEventBus,
+    runRegistry: ctx.runRegistry,
+    queueRegistry: ctx.queueRegistry,
+    db: ctx.db
+  };
+}
+
+// src/internal/db/queries/get-run.ts
+async function getRun(db, runId) {
+  const result = await db.selectFrom("runs").select([
+    "id",
+    "inputs",
+    "output",
+    "error",
+    "status",
+    "change_id",
+    "recovery_attempts",
+    "workflow_name"
+  ]).where("id", "=", runId).executeTakeFirst();
+  if (!result) {
+    return void 0;
+  }
+  return {
+    id: result.id,
+    input: result.inputs ?? void 0,
+    name: result.workflow_name,
+    output: result.output ?? void 0,
+    error: result.error ?? void 0,
+    status: result.status,
+    changeId: result.change_id,
+    recoveryAttempts: Number(result.recovery_attempts ?? 0)
+  };
+}
+
+// src/internal/db/commands/insert-operation.ts
+async function insertOperation(tx, runId, operationName, sequenceId, result, error) {
+  await tx.insertInto("operations").values({
+    run_id: runId,
+    name: operationName,
+    sequence_id: sequenceId,
+    output: result,
+    error
+  }).execute();
+}
+
+// src/internal/context/operation-manager.ts
+var OperationManager = class {
+  constructor(db, runId, operations = []) {
+    this.db = db;
+    this.runId = runId;
+    this.operations = operations;
+  }
+  sequenceId = 0;
+  lastReservedSequenceId = null;
+  getOperationResult() {
+    const operation = this.operations.pop();
+    if (operation) {
+      this.sequenceId++;
+      return operation;
+    }
+    return null;
+  }
+  reserveSequenceId() {
+    const reserved = this.sequenceId++;
+    this.lastReservedSequenceId = reserved;
+    return reserved;
+  }
+  getCurrentSequenceId() {
+    return this.sequenceId;
+  }
+  /**
+   * Gets the sequence ID that was most recently reserved for the current operation.
+   * This is the ID that will be (or was) recorded in the database for this operation.
+   * Returns null if no sequence ID has been reserved yet.
+   */
+  getActiveSequenceId() {
+    return this.lastReservedSequenceId;
+  }
+  async recordResult(operationName, sequenceId, result, tx) {
+    if (tx) {
+      await insertOperation(tx, this.runId, operationName, sequenceId, result ?? void 0);
+    } else {
+      await withDbRetry(async () => {
+        await insertOperation(this.db, this.runId, operationName, sequenceId, result ?? void 0);
+      });
+    }
+  }
+  async recordError(operationName, sequenceId, error, tx) {
+    if (tx) {
+      await insertOperation(
+        tx,
+        this.runId,
+        operationName,
+        sequenceId,
+        void 0,
+        error ?? void 0
+      );
+    } else {
+      await withDbRetry(async () => {
+        await insertOperation(
+          this.db,
+          this.runId,
+          operationName,
+          sequenceId,
+          void 0,
+          error ?? void 0
+        );
+      });
+    }
+  }
+};
+function returnOrThrowOperationResult(op) {
+  if (op.error) {
+    throw deserializeError(op.error);
+  }
+  if (op.result === null || op.result === void 0) {
+    return void 0;
+  }
+  return deserialize(op.result);
+}
+async function executeAndRecordOperation(operationManager, operationName, callback) {
+  const seqId = operationManager.reserveSequenceId();
+  try {
+    const result = await callback();
+    const serializedResult = serialize(result);
+    await checkCancellation();
+    await operationManager.recordResult(operationName, seqId, serializedResult);
+    return result;
+  } catch (error) {
+    if (error instanceof RunCancelledError) {
+      throw error;
+    }
+    const err = error instanceof Error ? error : new Error(String(error));
+    await operationManager.recordError(operationName, seqId, serializeError(err));
+    throw error;
+  }
+}
+async function checkCancellation() {
+  const { abortSignal, runId, db } = getExecutionContext();
+  if (abortSignal.aborted) {
+    throw new RunCancelledError();
+  }
+  const run = await withDbRetry(async () => getRun(db, runId));
+  if (run?.status === "cancelled") {
+    throw new RunCancelledError();
+  }
+}
+
+// src/internal/db/queries/get-run-status.ts
+async function getRunStatus(db, runId) {
+  const run = await db.selectFrom("runs").select("status").where("id", "=", runId).executeTakeFirst();
+  if (!run) {
+    throw new RunNotFoundError(runId);
+  }
+  return run.status;
+}
+
+// src/internal/get-run-status.ts
+async function getRunStatus2(ctx, runId) {
+  const { db } = ctx;
+  if (ctx.type === "runtime") {
+    const { runRegistry } = ctx;
+    const run = runRegistry.getRun(runId);
+    if (run) {
+      return deriveRunStatus(run);
+    }
+    return getRunStatus(db, runId);
+  }
+  if (ctx.type === "execution") {
+    const { operationManager, runRegistry } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      returnOrThrowOperationResult(op);
+    }
+    const status = await executeAndRecordOperation(operationManager, "getRunStatus", async () => {
+      const run = runRegistry.getRun(runId);
+      if (run) {
+        return deriveRunStatus(run);
+      }
+      return await getRunStatus(db, runId);
+    });
+    return status;
+  }
+  return await getRunStatus(db, runId);
+}
+async function deriveRunStatus(runEntry) {
+  if (runEntry.store.abortSignal.aborted) {
+    return "cancelled";
+  }
+  const promiseState = runEntry.getPromiseState();
+  if (promiseState === "pending") {
+    return "pending";
+  }
+  if (promiseState === "fulfilled") {
+    return "success";
+  }
+  return "error";
+}
+
+// src/internal/wait-for-run-result.ts
+async function waitForRunResult(ctx, runId) {
+  if (ctx.type === "execution") {
+    const { operationManager } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      returnOrThrowOperationResult(op);
+    }
+    const result = await executeAndRecordOperation(
+      operationManager,
+      "waitForRunResult",
+      async () => {
+        return await getOrSubscribeToRunResult(ctx, runId);
+      }
+    );
+    return result;
+  }
+  return await getOrSubscribeToRunResult(ctx, runId);
+}
+async function getOrSubscribeToRunResult(ctx, runId) {
+  const { db, runEventBus } = ctx;
+  const run = await getRun(db, runId);
+  if (!run) {
+    return {
+      error: new RunNotFoundError(runId),
+      success: false
+    };
+  }
+  switch (run.status) {
+    case "success":
+      return {
+        data: run.output ? deserialize(run.output) : void 0,
+        success: true
+      };
+    case "error":
+      return {
+        error: run.error ? deserializeError(run.error) : new UnknownError(),
+        success: false
+      };
+    case "cancelled":
+      return {
+        error: new RunCancelledError(),
+        success: false
+      };
+    case "max_recovery_attempts_exceeded":
+      return {
+        error: run.error ? deserializeError(run.error) : new MaxRecoveryAttemptsExceededError(runId, run.recoveryAttempts),
+        success: false
+      };
+  }
+  return new Promise((resolve, reject) => {
+    const unsubscribe = runEventBus.subscribe(runId, "*", async (e) => {
+      if (TERMINAL_STATES.includes(e.status)) {
+        unsubscribe();
+        try {
+          const run2 = await getRun(db, runId);
+          if (!run2) {
+            reject(new RunNotFoundError(runId));
+            return;
+          }
+          switch (run2.status) {
+            case "success":
+              resolve({
+                data: run2.output ? deserialize(run2.output) : void 0,
+                success: true
+              });
+              return;
+            case "error":
+              resolve({
+                error: run2.error ? deserializeError(run2.error) : new UnknownError(),
+                success: false
+              });
+              return;
+            case "cancelled":
+              resolve({
+                error: new RunCancelledError(),
+                success: false
+              });
+              return;
+            case "max_recovery_attempts_exceeded":
+              resolve({
+                error: run2.error ? deserializeError(run2.error) : new MaxRecoveryAttemptsExceededError(runId, run2.recoveryAttempts),
+                success: false
+              });
+              return;
+          }
+        } catch (error) {
+          if (error instanceof RunNotFoundError) {
+            reject(error);
+            return;
+          }
+          resolve({
+            error,
+            success: false
+          });
+        }
+      }
+    });
+  });
+}
+
+// src/internal/run.ts
+function createRunHandle(runtimeContext, id) {
+  return {
+    id,
+    getStatus: () => getRunStatus2(runtimeContext, id),
+    waitForResult: () => waitForRunResult(runtimeContext, id)
+  };
+}
+async function recordRunResult(db, runId, result, cancelled) {
+  const [{ change_id }] = await db.updateTable("runs").set({
+    output: result.result,
+    error: result.error,
+    status: cancelled ? "cancelled" : result.error ? "error" : "success",
+    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+  }).where("id", "=", runId).returning(["change_id"]).execute();
+  return change_id;
+}
+
+// src/internal/execute-workflow.ts
+async function executeWorkflow(ctx, params) {
+  const { db, runRegistry } = ctx;
+  const { options, runId, runPath, fn, args, operations } = params;
+  const abortController = new AbortController();
+  const [deadline, deadlineReason] = getDeadlineAndReason({
+    timeout: options?.timeout,
+    deadline: options?.deadline
+  });
+  const runStore = createExecutionContext({
+    ctx,
+    abortSignal: AbortSignal.any(
+      [abortController.signal].concat(deadline ? [AbortSignal.timeout(deadline - Date.now())] : [])
+    ),
+    runId,
+    runPath,
+    operations
+  });
+  const executionPromise = (async () => {
+    try {
+      const result = await runWithExecutionContext(runStore, async () => {
+        return await runWithTimeout(async () => {
+          return await fn(...args);
+        }, deadlineReason);
+      });
+      await recordRunResult(db, runId, { result: result ? serialize(result) : void 0 });
+      return result;
+    } catch (error) {
+      if (error instanceof RunCancelledError) {
+        await recordRunResult(db, runId, { error: serializeError(error) }, true);
+      } else {
+        await recordRunResult(db, runId, { error: serializeError(error) });
+      }
+      throw error;
+    } finally {
+      runRegistry.unregisterRun(runId);
+    }
+  })();
+  runRegistry.registerRun(runId, {
+    store: runStore,
+    promise: executionPromise,
+    abortController
+  });
+}
+function getDeadlineAndReason({
+  timeout,
+  deadline
+}) {
+  const now = Date.now();
+  const timeoutDeadline = timeout ? now + timeout : void 0;
+  if (timeoutDeadline && deadline) {
+    return [
+      Math.min(timeoutDeadline, deadline),
+      timeoutDeadline < deadline ? "timeout" : "deadline"
+    ];
+  } else if (timeoutDeadline) {
+    return [timeoutDeadline, "timeout"];
+  } else if (deadline) {
+    return [deadline, "deadline"];
+  }
+  return [void 0, void 0];
+}
+async function runWithTimeout(fn, deadlineReason) {
+  const { abortSignal } = getExecutionContext();
+  const abortPromise = new Promise((_, reject) => {
+    abortSignal.throwIfAborted();
+    abortSignal.addEventListener(
+      "abort",
+      () => {
+        if (abortSignal.reason?.name === "TimeoutError") {
+          reject(new RunTimedOutError());
+          return;
+        }
+        reject(new RunCancelledError());
+      },
+      { once: true }
+    );
+  });
+  const callPromise = fn();
+  try {
+    return await Promise.race([callPromise, abortPromise]);
+  } catch (error) {
+    if (error instanceof RunTimedOutError) {
+      if (deadlineReason === "timeout") {
+        throw new RunTimedOutError();
+      } else if (deadlineReason === "deadline") {
+        throw new RunDeadlineExceededError();
+      }
+      throw error;
+    }
+    await callPromise.catch(() => {
+    });
+    throw error;
+  }
+}
+async function insertPendingRun(db, options) {
+  const result = await db.insertInto("runs").values({
+    id: options.runId,
+    path: options.path,
+    inputs: options.inputs,
+    executor_id: options.executorId,
+    workflow_name: options.workflowName,
+    status: "pending",
+    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
+    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
+    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+  }).returning(["id", "path", "change_id"]).executeTakeFirst();
+  return {
+    runId: result.id,
+    path: result.path,
+    changeId: result.change_id
+  };
+}
+
+// src/internal/run-workflow.ts
+async function runWorkflow(ctx, workflowName, args = [], options = {}) {
+  const { db, executorId, workflowsMap, type } = ctx;
+  const workflow = workflowsMap[workflowName];
+  if (!workflow) {
+    throw new WorkflowNotFoundError(workflowName);
+  }
+  const newRunId = options.id ?? crypto.randomUUID();
+  let newRunPath = [];
+  if (type === "execution") {
+    const { operationManager, runPath } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      if (op.error) {
+        throw deserializeError(op.error);
+      }
+      const newRun2 = deserialize(op.result);
+      return createRunHandle(ctx, newRun2.runId);
+    }
+    const newRun = await executeAndRecordOperation(operationManager, "runWorkflow", async () => {
+      const newRun2 = {
+        runId: newRunId,
+        runPath: [...runPath, newRunId],
+        workflowName
+      };
+      withDbRetry(async () => {
+        return await insertPendingRun(db, {
+          ...newRun2,
+          path: newRun2.runPath,
+          inputs: serialize(args),
+          executorId
+        });
+      });
+      return newRun2;
+    });
+    newRunPath = newRun.runPath;
+  }
+  if (type === "runtime") {
+    const { path } = await insertPendingRun(db, {
+      runId: newRunId,
+      path: [newRunId],
+      inputs: serialize(args),
+      executorId,
+      workflowName
+    });
+    newRunPath = path;
+  }
+  await executeWorkflow(ctx, {
+    runId: newRunId,
+    runPath: newRunPath,
+    fn: workflow.fn,
+    args,
+    options
+  });
+  return createRunHandle(ctx, newRunId);
+}
+async function cancelRun(runId, db, options = {}) {
+  if (options.cascade) {
+    return db.transaction().execute(async (tx) => {
+      const result = await tx.updateTable("runs").set({
+        status: "cancelled",
+        updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+      }).where((eb) => eb.and([eb("id", "=", runId), eb("status", "not in", TERMINAL_STATES)])).returning(["change_id", "path"]).executeTakeFirst();
+      if (!result) {
+        const exists = await tx.selectFrom("runs").select([]).where("id", "=", runId).executeTakeFirst();
+        if (exists) {
+          return void 0;
+        }
+        throw new RunNotFoundError(runId);
+      }
+      await sql`
+          UPDATE runs
+          SET 
+              status = ${"cancelled"},
+              updated_at = (extract(epoch from now()) * 1000)::bigint
+          WHERE path @> ARRAY[${runId}]::text[]
+          AND id != ${runId}
+          AND status NOT IN (${"cancelled"}, ${"success"}, ${"error"})
+      `.execute(tx);
+      return {
+        path: result.path,
+        changeId: result.change_id
+      };
+    });
+  } else {
+    const result = await db.updateTable("runs").set({
+      status: "cancelled",
+      updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+    }).where((eb) => eb.and([eb("id", "=", runId), eb("status", "not in", TERMINAL_STATES)])).returning(["path", "change_id"]).executeTakeFirst();
+    if (!result) {
+      throw new RunNotFoundError(runId);
+    }
+    return {
+      path: result.path,
+      changeId: result.change_id
+    };
+  }
+}
+
+// src/internal/cancel-run.ts
+async function cancelRun2(ctx, runId, options = {}) {
+  if (ctx.type === "execution" || ctx.type === "runtime") {
+    const { db, runRegistry } = ctx;
+    const run = await cancelRun(runId, db, options);
+    if (!run) {
+      return;
+    }
+    if (options.cascade) {
+      for (const pathPart of run.path) {
+        const run2 = runRegistry.getRun(pathPart);
+        if (run2) {
+          run2.abortController.abort();
+        }
+      }
+      return;
+    }
+    runRegistry.getRun(runId)?.abortController.abort();
+  } else {
+    const { db } = ctx;
+    const run = await cancelRun(runId, db, options);
+    if (!run) {
+      return;
+    }
+  }
+}
+async function enqueueRun(db, options) {
+  const result = await db.insertInto("runs").values({
+    id: options.runId,
+    path: options.path,
+    inputs: options.inputs,
+    queue_name: options.queueName,
+    queue_partition_key: options.queuePartitionKey,
+    queue_deduplication_id: options.deduplicationId,
+    workflow_name: options.workflowName,
+    status: "queued",
+    recovery_attempts: options.recoveryAttempts,
+    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
+    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+  }).onConflict((oc) => oc.columns(["queue_name", "queue_deduplication_id"]).doNothing()).returning(["id", "change_id"]).executeTakeFirst();
+  return {
+    runId: result?.id,
+    changeId: result?.change_id
+  };
+}
+
+// src/internal/queue-workflow.ts
+async function queueWorkflow(ctx, queueName, workflowName, args, options) {
+  const { db } = ctx;
+  const newRunId = options?.id ?? crypto.randomUUID();
+  if (ctx.type === "execution") {
+    const { operationManager, runPath } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      if (op.error) {
+        throw deserializeError(op.error);
+      }
+      const newRunId2 = deserialize(op.result);
+      return createRunHandle(ctx, newRunId2);
+    }
+    await executeAndRecordOperation(operationManager, "queueWorkflow", async () => {
+      const { runId } = await enqueueRun(db, {
+        runId: newRunId,
+        path: [...runPath, newRunId],
+        inputs: serialize(args),
+        workflowName,
+        queueName,
+        timeout: options?.timeout,
+        deadline: options?.deadline
+      });
+      return runId;
+    });
+    return createRunHandle(ctx, newRunId);
+  }
+  await withDbRetry(
+    async () => await enqueueRun(db, {
+      runId: newRunId,
+      path: [newRunId],
+      inputs: serialize(args),
+      workflowName,
+      queueName,
+      timeout: options?.timeout,
+      deadline: options?.deadline
+    })
+  );
+  return createRunHandle(ctx, newRunId);
+}
+var INTERNAL_QUEUE_NAME = "_helical_internal_queue";
+async function resumeRun(db, runId) {
+  const result = await db.updateTable("runs").set({
+    status: "queued",
+    queue_name: INTERNAL_QUEUE_NAME,
+    deadline_epoch_ms: null,
+    timeout_ms: null,
+    recovery_attempts: 0,
+    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
+    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+  }).where("id", "=", runId).where("status", "=", "pending").execute();
+  if (!result) {
+    throw new RunNotFoundError(runId);
+  }
+}
+
+// src/internal/resume-run.ts
+async function resumeRun2(ctx, runId) {
+  const { db } = ctx;
+  if (ctx.type === "execution") {
+    const { operationManager } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      returnOrThrowOperationResult(op);
+    }
+    await executeAndRecordOperation(operationManager, "resumeRun", async () => {
+      await withDbRetry(async () => await resumeRun(db, runId));
+    });
+  } else {
+    await withDbRetry(async () => await resumeRun(db, runId));
+  }
+}
+
+// src/internal/db/commands/insert-message.ts
+async function insertMessage(db, options) {
+  return await db.insertInto("messages").values({
+    destination_run_id: options.destinationWorkflowId,
+    type: options.messageType,
+    payload: options.data
+  }).execute();
+}
+
+// src/internal/send-message.ts
+async function sendMessage(ctx, target, name, data) {
+  const { db } = ctx;
+  const destinationWorkflowId = typeof target === "string" ? target : target.id;
+  const messageType = typeof name === "string" ? name : name.name;
+  const serializedData = serialize(data);
+  if (ctx.type === "execution") {
+    const { operationManager } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      return returnOrThrowOperationResult(op);
+    }
+    await executeAndRecordOperation(operationManager, "sendMessage", async () => {
+      await insertMessage(db, {
+        destinationWorkflowId,
+        messageType,
+        data: serializedData
+      });
+    });
+  } else {
+    await insertMessage(db, {
+      destinationWorkflowId,
+      messageType,
+      data: serializedData
+    });
+  }
+}
+
+// src/internal/db/queries/get-state.ts
+async function getState(db, runId, key) {
+  const result = await db.selectFrom("state").select(["key", "value", "change_id"]).where("run_id", "=", runId).where("key", "=", key).executeTakeFirst();
+  if (!result) {
+    return void 0;
+  }
+  return result.value;
+}
+
+// src/internal/get-state.ts
+var StateNotAvailableError = class extends Error {
+};
+async function getState2(ctx, target, key) {
+  const { db, stateEventBus } = ctx;
+  const destinationWorkflowId = typeof target === "string" ? target : target.id;
+  const stateKey = typeof key === "string" ? key : key.name;
+  if (ctx.type === "execution") {
+    const { operationManager } = ctx;
+    const op = operationManager.getOperationResult();
+    if (op) {
+      return returnOrThrowOperationResult(op);
+    }
+  }
+  while (true) {
+    try {
+      return await withDbRetry(async () => {
+        const state = await getState(db, destinationWorkflowId, stateKey);
+        if (!state) {
+          throw new StateNotAvailableError();
+        }
+        if (ctx.type === "execution") {
+          const { operationManager } = ctx;
+          await executeAndRecordOperation(operationManager, "getState", async () => {
+            return state;
+          });
+        }
+        return deserialize(state);
+      });
+    } catch (error) {
+      if (error instanceof StateNotAvailableError) {
+        await waitForStateNotification(stateEventBus, destinationWorkflowId, stateKey);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+async function waitForStateNotification(stateEventBus, runId, key) {
+  return new Promise((resolve) => {
+    const unsubscribe = stateEventBus.subscribe(runId, key, (state) => {
+      unsubscribe();
+      resolve(state);
+    });
+  });
+}
+
+export { BaseError, ErrorType, FatalError, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, OperationTimedOutError, RunCancelledError, RunDeadlineExceededError, RunNotFoundError, RunOutsideOfWorkflowError, RunTimedOutError, SerializationError, TERMINAL_STATES, UnknownError, WorkflowNotFoundError, cancelRun2 as cancelRun, createRunHandle, defineWorkflow, deserialize, executeAndRecordOperation, executeWorkflow, getExecutionContext, getRun, getRunStatus2 as getRunStatus, getState, getState2, queueWorkflow, resumeRun2 as resumeRun, returnOrThrowOperationResult, runWorkflow, sendMessage, serialize, serializeError, sleep, waitForRunResult, withDbRetry };
+//# sourceMappingURL=chunk-7I6XZ2V3.js.map
+//# sourceMappingURL=chunk-7I6XZ2V3.js.map