@theokit/sdk 4.24.0 → 4.26.0

package/dist/workflow.js

@@ -1,2814 +1,10 @@
-import { randomUUID, randomBytes } from 'crypto';
-import { readFile, unlink, mkdir, open, rename, statfs, readdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import { createRequire } from 'module';
-import { mkdirSync, readdirSync } from 'fs';
-import { AsyncLocalStorage } from 'async_hooks';
-import { z, toJSONSchema } from 'zod';
-
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn2, res) => function __init() {
-  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/internal/security/redact.ts
-function readEnvOnce() {
-  const raw = process.env.THEOKIT_REDACT_SECRETS;
-  if (raw === void 0) return true;
-  return ["1", "true", "yes", "on"].includes(raw.toLowerCase());
-}
-function maskToken(token) {
-  if (token.length < 18) return "***";
-  return `${token.slice(0, 6)}...${token.slice(-4)}`;
-}
-function coerceToString(value) {
-  if (typeof value === "string") return value;
-  if (value === null || value === void 0) return null;
-  if (typeof value === "object") {
-    try {
-      const s = JSON.stringify(value);
-      return s === void 0 ? null : s;
-    } catch {
-      return "[unredactable: circular]";
-    }
-  }
-  return String(value);
-}
-function redactSecrets(text, opts) {
-  const coerced = coerceToString(text);
-  if (coerced === null) return "";
-  if (!REDACT_ENABLED) return coerced;
-  let s = coerced;
-  for (const re of BUILTIN_PATTERNS) {
-    s = s.replace(re, (m) => maskToken(m));
-  }
-  for (const re of _extraPatterns) {
-    s = s.replace(re, (m) => maskToken(m));
-  }
-  {
-    s = s.replace(BEARER_PATTERN, (_, prefix) => `${prefix}***`);
-    s = s.replace(PARAM_PATTERN, (whole, prefix, value) => {
-      if (MASK_SHAPE.test(value)) return whole;
-      return `${prefix}***`;
-    });
-  }
-  return s;
-}
-var REDACT_ENABLED, warnedOptOut, BUILTIN_PATTERNS, BEARER_PATTERN, PARAM_PATTERN, _extraPatterns, MASK_SHAPE;
-var init_redact = __esm({
-  "src/internal/security/redact.ts"() {
-    REDACT_ENABLED = readEnvOnce();
-    warnedOptOut = false;
-    if (!REDACT_ENABLED && !warnedOptOut) {
-      process.stderr.write(
-        "[theokit-sdk] Secret redaction is DISABLED via THEOKIT_REDACT_SECRETS. Credentials may leak into errors, telemetry, logs, transcripts.\n"
-      );
-      warnedOptOut = true;
-    }
-    BUILTIN_PATTERNS = [
-      // T5.4: 30+ vendor prefixes (was 12 pre-T5.4). Order matters — more
-      // specific prefixes precede generic ones (e.g., sk-ant-admin01 before
-      // sk-ant-, sk-proj- before sk-). PEM block deliberately first so its
-      // multi-line span runs before any per-line patterns can fire.
-      /-----BEGIN[ ]+(?:RSA |EC |DSA |OPENSSH |ENCRYPTED |)PRIVATE KEY-----[\s\S]+?-----END[ ]+(?:RSA |EC |DSA |OPENSSH |ENCRYPTED |)PRIVATE KEY-----/g,
-      // JWT — exact 3-segment base64url. Dotted; the body floor of 4 chars per
-      // segment matches the minimum legal payload while skipping `a.b.c` noise.
-      /eyJ[A-Za-z0-9_-]{4,}\.eyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}/g,
-      // Azure Storage SAS — match the sig= component (URL-encoded base64).
-      /(?<=[?&]sig=)[A-Za-z0-9%+/]{20,}/g,
-      // Anthropic
-      /sk-ant-admin01-[A-Za-z0-9_-]{10,}/g,
-      //   Anthropic admin keys (must precede sk-ant-)
-      /sk-ant-[A-Za-z0-9_-]{10,}/g,
-      //           Anthropic regular
-      // OpenAI family + clones (sk- generic must come AFTER all sk-foo- variants)
-      /sk-proj-[A-Za-z0-9_-]{10,}/g,
-      //  OpenAI project key (must precede sk- generic)
-      /sk-[A-Za-z0-9_-]{10,}/g,
-      //       OpenAI / OpenRouter / DeepInfra / Together / DeepSeek
-      // Provider prefixes (alphabetized for maintainability)
-      /AIza[A-Za-z0-9_-]{35}/g,
-      //       Google API key
-      /AKIA[A-Z0-9]{16}/g,
-      //            AWS access key
-      /fw_[A-Za-z0-9]{20,}/g,
-      //         Fireworks
-      /glpat-[A-Za-z0-9_-]{20}/g,
-      //     GitLab PAT
-      /ghp_[A-Za-z0-9]{36}/g,
-      //         GitHub PAT classic
-      /github_pat_[A-Za-z0-9_]{82}/g,
-      // GitHub PAT fine-grained
-      /gsk_[A-Za-z0-9]{20,}/g,
-      //        Groq
-      /hf_[A-Za-z0-9]{20,}/g,
-      //         HuggingFace
-      /\bpa-[A-Za-z0-9_-]{20,}/g,
-      //     Voyage AI (word-boundary to skip CSS / kebab IDs)
-      /pcsk_[A-Za-z0-9_-]{20,}/g,
-      //     Pinecone
-      /pplx-[A-Za-z0-9_-]{20,}/g,
-      //     Perplexity
-      /r8_[A-Za-z0-9_-]{20,}/g,
-      //       Replicate
-      /rk_live_[A-Za-z0-9]{20,}/g,
-      //    Stripe restricted
-      /sk_live_[A-Za-z0-9]{20,}/g,
-      //    Stripe secret
-      /sntrys_[A-Za-z0-9]{40,}/g,
-      //     Sentry user auth
-      /xai-[A-Za-z0-9_-]{20,}/g,
-      //      xAI (Grok)
-      /xox[bpasr]-[A-Za-z0-9-]{10,}/g,
-      //Slack tokens
-      // Additional unique-prefix tokens with low false-positive risk
-      /npm_[A-Za-z0-9]{36}/g,
-      //         npm access token
-      /SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}/g,
-      // SendGrid
-      /\bSK[A-Za-z0-9]{32}\b/g,
-      //       Twilio API SID (word-boundary to skip CSS class noise)
-      /\bkey-[a-f0-9]{32}\b/g,
-      //        Mailgun (hex-only narrows false positives)
-      /MT[A-Za-z0-9_-]{23}\.[A-Za-z0-9_-]{6}\.[A-Za-z0-9_-]{27}/g,
-      // Discord bot
-      /\b(?:sdk|mob)-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\b/g
-      // LaunchDarkly
-    ];
-    BEARER_PATTERN = /\b(Bearer\s+)([A-Za-z0-9_\-.+/=]{8,})/g;
-    PARAM_PATTERN = /(\b(?:access_token|api_key|api-key|client_secret|credential|credentials|id_token|jwt|password|private_key|refresh_token|secret|service_account|session_token|token|x-api-key)\b["']?\s*[:=]\s*["']?)([A-Za-z0-9_\-.+/]+)/gi;
-    _extraPatterns = [];
-    MASK_SHAPE = /^.{6}\.\.\..{4}$/s;
-  }
-});
-
-// src/errors.ts
-var TheokitAgentError, ConfigurationError, UnsupportedRunOperationError, InvalidTaskIdError, TaskNotFoundError;
-var init_errors = __esm({
-  "src/errors.ts"() {
-    TheokitAgentError = class extends Error {
-      name = "TheokitAgentError";
-      isRetryable;
-      code;
-      protoErrorCode;
-      metadata;
-      constructor(message, options = {}) {
-        super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
-        this.isRetryable = options.isRetryable ?? false;
-        if (options.code !== void 0) this.code = options.code;
-        if (options.protoErrorCode !== void 0) this.protoErrorCode = options.protoErrorCode;
-        if (options.metadata !== void 0) this.metadata = options.metadata;
-      }
-    };
-    ConfigurationError = class extends TheokitAgentError {
-      name = "ConfigurationError";
-      constructor(message, options = {}) {
-        super(message, { ...options, isRetryable: false });
-      }
-    };
-    UnsupportedRunOperationError = class extends TheokitAgentError {
-      name = "UnsupportedRunOperationError";
-      operation;
-      constructor(message, operation, options = {}) {
-        super(message, {
-          ...options,
-          isRetryable: false,
-          code: options.code ?? "unsupported_run_operation"
-        });
-        this.operation = operation;
-      }
-    };
-    InvalidTaskIdError = class extends TheokitAgentError {
-      name = "InvalidTaskIdError";
-      taskId;
-      constructor(message, taskId, options = {}) {
-        super(message, {
-          ...options,
-          isRetryable: false,
-          code: "invalid_task_id"
-        });
-        this.taskId = taskId;
-      }
-    };
-    TaskNotFoundError = class extends TheokitAgentError {
-      name = "TaskNotFoundError";
-      taskId;
-      constructor(taskId, options = {}) {
-        super(`Task not found: ${taskId}`, {
-          ...options,
-          isRetryable: false,
-          code: "task_not_found"
-        });
-        this.taskId = taskId;
-      }
-    };
-  }
-});
-
-// src/types/workflow.ts
-var WorkflowDuplicateStepIdError, WorkflowInputError, WorkflowOutputError, WorkflowStateError, WorkflowNestedError, WorkflowAlreadyRunningError, WorkflowSnapshotNotFoundError, WorkflowMaxIterationsExceededError, WorkflowNotSerializableError, WorkflowResumeStepNotFoundError, WorkflowParallelError, WorkflowCompensateNotImplementedError;
-var init_workflow = __esm({
-  "src/types/workflow.ts"() {
-    WorkflowDuplicateStepIdError = class extends Error {
-      constructor(stepId) {
-        super(`Duplicate step id "${stepId}" in workflow.`);
-        this.stepId = stepId;
-      }
-      stepId;
-      name = "WorkflowDuplicateStepIdError";
-    };
-    WorkflowInputError = class extends Error {
-      constructor(workflowName, detail) {
-        super(`Workflow "${workflowName}" input failed schema validation: ${detail}`);
-        this.workflowName = workflowName;
-        this.detail = detail;
-      }
-      workflowName;
-      detail;
-      name = "WorkflowInputError";
-    };
-    WorkflowOutputError = class extends Error {
-      constructor(workflowName, detail) {
-        super(`Workflow "${workflowName}" output failed schema validation: ${detail}`);
-        this.workflowName = workflowName;
-        this.detail = detail;
-      }
-      workflowName;
-      detail;
-      name = "WorkflowOutputError";
-    };
-    WorkflowStateError = class extends Error {
-      constructor(workflowName, detail) {
-        super(`Workflow "${workflowName}" state failed schema validation: ${detail}`);
-        this.workflowName = workflowName;
-        this.detail = detail;
-      }
-      workflowName;
-      detail;
-      name = "WorkflowStateError";
-    };
-    WorkflowNestedError = class extends Error {
-      constructor(stepId, childName, childStatus, childError) {
-        super(
-          `Nested workflow "${childName}" (step "${stepId}") ended with status "${childStatus}"${childStatus === "suspended" ? " \u2014 nested suspend/resume is not supported in v1 (use a top-level suspend)" : ""}${childError ? `: ${childError.name}: ${childError.message}` : ""}`,
-          // Reconstruct a synthetic Error from the serialized child-error shape so
-          // debuggers surface the nested cause chain — the original Error instance is
-          // lost at the WorkflowRun serialization boundary, so this is the best
-          // achievable without changing the run protocol.
-          childError ? { cause: Object.assign(new Error(childError.message), { name: childError.name }) } : void 0
-        );
-        this.stepId = stepId;
-        this.childName = childName;
-        this.childStatus = childStatus;
-        this.childError = childError;
-      }
-      stepId;
-      childName;
-      childStatus;
-      childError;
-      name = "WorkflowNestedError";
-    };
-    WorkflowAlreadyRunningError = class extends Error {
-      constructor(workflowName, runId) {
-        super(`Workflow "${workflowName}" run "${runId}" already in-flight.`);
-        this.workflowName = workflowName;
-        this.runId = runId;
-      }
-      workflowName;
-      runId;
-      name = "WorkflowAlreadyRunningError";
-    };
-    WorkflowSnapshotNotFoundError = class extends Error {
-      constructor(runId) {
-        super(`No snapshot found for runId "${runId}". Configure persistence to enable resume.`);
-        this.runId = runId;
-      }
-      runId;
-      name = "WorkflowSnapshotNotFoundError";
-    };
-    WorkflowMaxIterationsExceededError = class extends Error {
-      constructor(stepId, maxIterations) {
-        super(`Step "${stepId}" exceeded max iterations (${maxIterations}).`);
-        this.stepId = stepId;
-        this.maxIterations = maxIterations;
-      }
-      stepId;
-      maxIterations;
-      name = "WorkflowMaxIterationsExceededError";
-    };
-    WorkflowNotSerializableError = class extends Error {
-      constructor(stepId, underlying) {
-        super(
-          `Workflow snapshot at step "${stepId}" failed to serialize as JSON: ${underlying.message}. Persisted snapshots support only JSON-serializable values (no BigInt, no circular refs, no class instances with cycles).`
-        );
-        this.stepId = stepId;
-        this.underlying = underlying;
-      }
-      stepId;
-      underlying;
-      name = "WorkflowNotSerializableError";
-    };
-    WorkflowResumeStepNotFoundError = class extends Error {
-      constructor(stepId, workflowName) {
-        super(
-          `Cannot resume: step "${stepId}" not found in workflow "${workflowName}". The Workflow definition diverged from the snapshot.`
-        );
-        this.stepId = stepId;
-        this.workflowName = workflowName;
-      }
-      stepId;
-      workflowName;
-      name = "WorkflowResumeStepNotFoundError";
-    };
-    WorkflowParallelError = class extends AggregateError {
-      constructor(errors, stepId) {
-        super(errors, `${errors.length} branch(es) failed in parallel step "${stepId}".`);
-        this.stepId = stepId;
-      }
-      stepId;
-      name = "WorkflowParallelError";
-    };
-    WorkflowCompensateNotImplementedError = class extends Error {
-      constructor(stepId) {
-        super(
-          `Step "${stepId}" defines compensate, but saga engine is deferred to v1.2. Remove compensate or implement rollback manually.`
-        );
-        this.stepId = stepId;
-      }
-      stepId;
-      name = "WorkflowCompensateNotImplementedError";
-    };
-  }
-});
-function detectNetworkFsName(typeMagic) {
-  return NETWORK_FS_MAGIC.get(typeMagic) ?? null;
-}
-async function warnOnNetworkFsOnce(dirPath, label) {
-  const key2 = `${dirPath}\0${label}`;
-  if (warnedNfsDirs.has(key2)) return;
-  warnedNfsDirs.add(key2);
-  try {
-    const info = await statfs(dirPath);
-    const fsName = detectNetworkFsName(info.type);
-    if (fsName === null) return;
-    process.stderr.write(
-      `[theokit-sdk] ${label}: detected network fs (${fsName}) at ${dirPath} \u2014 rename() atomicity guarantees may be weaker than expected.
-`
-    );
-  } catch {
-  }
-}
-async function replaceFileAtomic(filePath, content) {
-  await warnOnNetworkFsOnce(dirname(filePath), "atomic-write");
-  const suffix = randomBytes(8).toString("hex");
-  const tmp = `${filePath}.${process.pid}.${suffix}.tmp`;
-  const handle = await open(tmp, "w", 384);
-  try {
-    await handle.writeFile(content, "utf8");
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  try {
-    await rename(tmp, filePath);
-  } catch (cause) {
-    await unlink(tmp).catch(() => void 0);
-    throw cause;
-  }
-}
-async function atomicWriteText(filePath, content) {
-  await mkdir(dirname(filePath), { recursive: true });
-  await replaceFileAtomic(filePath, content);
-}
-var NETWORK_FS_MAGIC, warnedNfsDirs;
-var init_atomic_write = __esm({
-  "src/internal/persistence/atomic-write.ts"() {
-    NETWORK_FS_MAGIC = /* @__PURE__ */ new Map([
-      [26985, "nfs"],
-      [20859, "smb"],
-      [4283649346, "cifs"],
-      [1702057286, "fuse"]
-    ]);
-    warnedNfsDirs = /* @__PURE__ */ new Set();
-  }
-});
-function getSnapshotStoreFor(options) {
-  if (options.persistence?.backend === "json") {
-    const dir = options.persistence.dir;
-    let store = jsonStores.get(dir);
-    if (store === void 0) {
-      store = new JsonFileWorkflowSnapshotStore(dir);
-      jsonStores.set(dir, store);
-    }
-    return store;
-  }
-  return memoryStore;
-}
-function __resetSnapshotStoresForTests() {
-  jsonStores.clear();
-  memoryStore.map.clear();
-}
-var InMemoryWorkflowSnapshotStore, JsonFileWorkflowSnapshotStore, memoryStore, jsonStores;
-var init_snapshot_store = __esm({
-  "src/internal/workflow/snapshot-store.ts"() {
-    init_workflow();
-    init_atomic_write();
-    InMemoryWorkflowSnapshotStore = class {
-      map = /* @__PURE__ */ new Map();
-      async save(snapshot) {
-        try {
-          JSON.stringify(snapshot);
-        } catch (err) {
-          throw new WorkflowNotSerializableError(
-            snapshot.currentStepId,
-            err instanceof Error ? err : new Error(String(err))
-          );
-        }
-        this.map.set(snapshot.runId, snapshot);
-      }
-      async load(runId) {
-        return this.map.get(runId);
-      }
-      async delete(runId) {
-        this.map.delete(runId);
-      }
-      async list(workflowName) {
-        return [...this.map.values()].filter((s) => workflowName === void 0 || s.workflowName === workflowName).map((s) => ({
-          runId: s.runId,
-          workflowName: s.workflowName,
-          suspendedAt: s.suspendedAt
-        }));
-      }
-    };
-    JsonFileWorkflowSnapshotStore = class {
-      constructor(dir) {
-        this.dir = dir;
-      }
-      dir;
-      filePath(runId) {
-        return join(this.dir, `${runId}.json`);
-      }
-      async save(snapshot) {
-        let serialized;
-        try {
-          serialized = JSON.stringify(snapshot);
-        } catch (err) {
-          throw new WorkflowNotSerializableError(
-            snapshot.currentStepId,
-            err instanceof Error ? err : new Error(String(err))
-          );
-        }
-        await mkdir(this.dir, { recursive: true });
-        await atomicWriteText(this.filePath(snapshot.runId), serialized);
-      }
-      async load(runId) {
-        try {
-          const raw = await readFile(this.filePath(runId), "utf8");
-          return JSON.parse(raw);
-        } catch (err) {
-          if (err.code === "ENOENT") return void 0;
-          throw err;
-        }
-      }
-      async delete(runId) {
-        try {
-          await (await import('fs/promises')).unlink(this.filePath(runId));
-        } catch (err) {
-          if (err.code !== "ENOENT") throw err;
-        }
-      }
-      async readEntriesOrEmpty() {
-        try {
-          return await readdir(this.dir);
-        } catch (err) {
-          if (err.code === "ENOENT") return [];
-          throw err;
-        }
-      }
-      async readSnapshotSafe(file) {
-        try {
-          const raw = await readFile(join(this.dir, file), "utf8");
-          return JSON.parse(raw);
-        } catch {
-          return void 0;
-        }
-      }
-      async list(workflowName) {
-        const entries = await this.readEntriesOrEmpty();
-        const results = [];
-        for (const file of entries) {
-          if (!file.endsWith(".json")) continue;
-          const snap = await this.readSnapshotSafe(file);
-          if (snap === void 0) continue;
-          if (workflowName !== void 0 && snap.workflowName !== workflowName) continue;
-          results.push({
-            runId: snap.runId,
-            workflowName: snap.workflowName,
-            suspendedAt: snap.suspendedAt
-          });
-        }
-        return results;
-      }
-    };
-    memoryStore = new InMemoryWorkflowSnapshotStore();
-    jsonStores = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/internal/workflow/ctx.ts
-function makeStepContext(runId, signal, state2) {
-  return {
-    runId,
-    signal,
-    log: {
-      debug: (msg, attrs) => emit("debug", runId, msg, attrs),
-      info: (msg, attrs) => emit("info", runId, msg, attrs),
-      warn: (msg, attrs) => emit("warn", runId, msg, attrs)
-    },
-    suspend: async (payload) => {
-      throw new WorkflowSuspendedSentinel(payload);
-    },
-    // SE29 — read reflects the current shared state; write goes through the
-    // controller (which validates against `stateSchema`).
-    get state() {
-      return state2.getState();
-    },
-    setState: (next) => state2.setState(next)
-  };
-}
-function emit(level, runId, msg, attrs) {
-  const tag = `[workflow ${runId}]`;
-  if (attrs !== void 0) {
-    if (level === "warn") console.warn(tag, msg, attrs);
-    else console.log(tag, msg, attrs);
-  } else {
-    if (level === "warn") console.warn(tag, msg);
-    else console.log(tag, msg);
-  }
-}
-function combineSignals(...signals) {
-  const valid = signals.filter((s) => s !== void 0);
-  if (valid.length === 0) return new AbortController().signal;
-  if (valid.length === 1) return valid[0];
-  const ctrl = new AbortController();
-  for (const s of valid) {
-    if (s.aborted) {
-      ctrl.abort(s.reason);
-      break;
-    }
-    s.addEventListener("abort", () => ctrl.abort(s.reason), { once: true });
-  }
-  return ctrl.signal;
-}
-var WorkflowSuspendedSentinel;
-var init_ctx = __esm({
-  "src/internal/workflow/ctx.ts"() {
-    WorkflowSuspendedSentinel = class extends Error {
-      constructor(payload) {
-        super("__workflow_suspended__");
-        this.payload = payload;
-      }
-      payload;
-      name = "WorkflowSuspendedSentinel";
-    };
-  }
-});
-
-// src/internal/workflow/error-shape.ts
-function errToShape(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message };
-  }
-  return { name: "Error", message: String(err) };
-}
-var init_error_shape = __esm({
-  "src/internal/workflow/error-shape.ts"() {
-  }
-});
-
-// src/internal/workflow/executor-helpers.ts
-function assembleRun(params) {
-  return {
-    id: params.runId,
-    name: params.name,
-    status: params.status,
-    startedAt: params.startedAt,
-    endedAt: Date.now(),
-    stepResults: params.stepResults,
-    ...params.output !== void 0 ? { output: params.output } : {},
-    ...params.error !== void 0 ? { error: params.error } : {}
-  };
-}
-function abortRun(name, runId, startedAt, stepResults, signal) {
-  return assembleRun({
-    runId,
-    name,
-    status: "cancelled",
-    stepResults,
-    startedAt,
-    error: { name: "AbortError", message: String(signal.reason ?? "Aborted") }
-  });
-}
-function validateWorkflowSchema(schema, value) {
-  if (schema === void 0) return void 0;
-  let parsed;
-  try {
-    parsed = schema.safeParse(value);
-  } catch {
-    return "schema uses async refinements, which whole-workflow validation does not support (use a synchronous Zod schema)";
-  }
-  if (parsed.success) return void 0;
-  return parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-}
-function makeStateController(options, initial) {
-  let current = initial;
-  return {
-    getState: () => current,
-    setState: (next) => {
-      const issues = validateWorkflowSchema(options.stateSchema, next);
-      if (issues !== void 0) throw new WorkflowStateError(options.name, issues);
-      current = next;
-    }
-  };
-}
-var init_executor_helpers = __esm({
-  "src/internal/workflow/executor-helpers.ts"() {
-    init_workflow();
-  }
-});
-
-// src/internal/workflow/run-id.ts
-function mintRunId() {
-  return `wfr-${globalThis.crypto.randomUUID().replace(/-/g, "").slice(0, 8)}`;
-}
-var init_run_id = __esm({
-  "src/internal/workflow/run-id.ts"() {
-  }
-});
-
-// src/internal/workflow/single-flight.ts
-function key(workflowId, runId) {
-  return `${workflowId}:${runId}`;
-}
-function acquireSingleFlight(workflowId, runId, workflowName) {
-  const k = key(workflowId, runId);
-  if (registry.has(k)) {
-    throw new WorkflowAlreadyRunningError(workflowName, runId);
-  }
-  const controller = new AbortController();
-  registry.set(k, { controller });
-  return {
-    signal: controller.signal,
-    release: () => {
-      registry.delete(k);
-    }
-  };
-}
-var registry;
-var init_single_flight = __esm({
-  "src/internal/workflow/single-flight.ts"() {
-    init_workflow();
-    registry = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/internal/workflow/retry-policy.ts
-function backoffConfigFromPolicy(policy) {
-  return {
-    max: policy.maxAttempts,
-    init: policy.initialBackoffMs ?? 1e3,
-    coef: policy.backoffCoefficient ?? 2,
-    cap: policy.maximumBackoffMs ?? 3e4,
-    nonRetryable: new Set(policy.nonRetryableErrors ?? DEFAULT_NON_RETRYABLE)
-  };
-}
-function throwIfAborted(signal) {
-  if (signal.aborted) {
-    throw new DOMException(String(signal.reason ?? "Aborted"), "AbortError");
-  }
-}
-function shouldRethrow(err, attempt, cfg) {
-  const errName = err instanceof Error ? err.name : "Error";
-  return cfg.nonRetryable.has(errName) || attempt === cfg.max;
-}
-async function tryOnce(fn2, attempt, cfg, signal) {
-  try {
-    const value = await fn2();
-    return { value, attempts: attempt };
-  } catch (err) {
-    if (shouldRethrow(err, attempt, cfg)) throw err;
-    await abortableSleep(Math.min(cfg.init * cfg.coef ** (attempt - 1), cfg.cap), signal);
-    return { kind: "retry" };
-  }
-}
-async function withRetry(fn2, policy, signal) {
-  const cfg = backoffConfigFromPolicy(policy);
-  for (let attempt = 1; attempt <= cfg.max; attempt += 1) {
-    throwIfAborted(signal);
-    const result = await tryOnce(fn2, attempt, cfg, signal);
-    if ("value" in result) return result;
-  }
-  throw new Error("withRetry: exhausted attempts without throwing");
-}
-async function abortableSleep(ms, signal) {
-  if (signal.aborted) {
-    throw new DOMException(String(signal.reason ?? "Aborted"), "AbortError");
-  }
-  return new Promise((resolve2, reject) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve2();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      cleanup();
-      reject(new DOMException(String(signal.reason ?? "Aborted"), "AbortError"));
-    };
-    const cleanup = () => {
-      signal.removeEventListener("abort", onAbort);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var DEFAULT_NON_RETRYABLE;
-var init_retry_policy = __esm({
-  "src/internal/workflow/retry-policy.ts"() {
-    DEFAULT_NON_RETRYABLE = ["AbortError", "WorkflowSnapshotNotFoundError", "ConfigurationError"];
-  }
-});
-
-// src/internal/workflow/step-agent.ts
-async function runAgentStep(step, input, ctx) {
-  const startedAt = Date.now();
-  const agentId = step.agent.agentId;
-  if (typeof agentId === "string" && agentId.startsWith("bc-")) {
-    return {
-      stepId: step.id,
-      kind: "agent",
-      status: "failed",
-      attempts: 0,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(
-        new UnsupportedRunOperationError(
-          `Workflow agent steps not supported on CloudAgent yet (D244). agent="${agentId}", step="${step.id}"`,
-          "workflow"
-        )
-      )
-    };
-  }
-  let prompt;
-  try {
-    prompt = typeof step.promptTemplate === "string" ? step.promptTemplate : step.promptTemplate(input);
-  } catch (err) {
-    return {
-      stepId: step.id,
-      kind: "agent",
-      status: "failed",
-      attempts: 0,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(err)
-    };
-  }
-  if (typeof prompt !== "string" || prompt.length === 0) {
-    return {
-      stepId: step.id,
-      kind: "agent",
-      status: "failed",
-      attempts: 0,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(
-        new Error(`agentStep "${step.id}": rendered prompt must be a non-empty string`)
-      )
-    };
-  }
-  const exec = async () => {
-    const run = await step.agent.send(
-      prompt,
-      step.origin !== void 0 ? { origin: step.origin } : void 0
-    );
-    const result = await run.wait();
-    if (result.status === "finished") {
-      return result.result ?? "";
-    }
-    if (result.status === "error") {
-      throw result.error ?? new Error("agent.send errored");
-    }
-    throw new Error(`Unexpected agent status: ${result.status}`);
-  };
-  try {
-    const { value, attempts } = step.retry !== void 0 ? await withRetry(exec, step.retry, ctx.signal) : { value: await exec(), attempts: 1 };
-    return {
-      stepId: step.id,
-      kind: "agent",
-      status: "completed",
-      attempts,
-      durationMs: Date.now() - startedAt,
-      output: value
-    };
-  } catch (err) {
-    if (err instanceof WorkflowSuspendedSentinel) throw err;
-    return {
-      stepId: step.id,
-      kind: "agent",
-      status: "failed",
-      attempts: 1,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(err)
-    };
-  }
-}
-var init_step_agent = __esm({
-  "src/internal/workflow/step-agent.ts"() {
-    init_errors();
-    init_ctx();
-    init_error_shape();
-    init_retry_policy();
-  }
-});
-
-// src/internal/workflow/step-branch.ts
-async function runBranchStep(step, input, ctx, options, prevStepResults, dispatch) {
-  const startedAt = Date.now();
-  for (let i = 0; i < step.predicates.length; i += 1) {
-    const pair = step.predicates[i];
-    const [predicate, branch] = pair;
-    let matched = false;
-    try {
-      matched = await Promise.resolve(predicate(input));
-    } catch (err) {
-      const errText = err instanceof Error ? err.message : String(err);
-      console.warn(
-        redactSecrets(
-          `[workflow] branch "${step.id}" predicate ${i} threw, treating as no-match: ${errText}`
-        )
-      );
-    }
-    if (matched) {
-      const r = await runInnerSequence(branch, input, ctx, options, prevStepResults, dispatch);
-      return {
-        ...r,
-        stepId: step.id,
-        kind: "branch",
-        durationMs: Date.now() - startedAt
-      };
-    }
-  }
-  if (step.fallback !== void 0) {
-    const r = await runInnerSequence(step.fallback, input, ctx, options, prevStepResults, dispatch);
-    return {
-      ...r,
-      stepId: step.id,
-      kind: "branch",
-      durationMs: Date.now() - startedAt
-    };
-  }
-  return {
-    stepId: step.id,
-    kind: "branch",
-    status: "skipped",
-    attempts: 0,
-    durationMs: Date.now() - startedAt,
-    output: input
-  };
-}
-async function runInnerSequence(branch, input, ctx, options, prevStepResults, dispatch) {
-  let acc = input;
-  let lastAttempts = 1;
-  for (const inner of branch) {
-    const r = await dispatch(inner, acc, ctx, options, prevStepResults);
-    lastAttempts = r.attempts;
-    if (r.status === "failed") {
-      return {
-        stepId: inner.id,
-        kind: "branch",
-        status: "failed",
-        attempts: r.attempts,
-        durationMs: 0,
-        error: r.error ?? errToShape(new Error("branch inner step failed"))
-      };
-    }
-    acc = r.output;
-  }
-  return {
-    stepId: "__branch-completed__",
-    kind: "branch",
-    status: "completed",
-    attempts: lastAttempts,
-    durationMs: 0,
-    output: acc
-  };
-}
-var init_step_branch = __esm({
-  "src/internal/workflow/step-branch.ts"() {
-    init_redact();
-    init_error_shape();
-  }
-});
-
-// src/internal/workflow/step-dowhile.ts
-async function runDowhileStep(step, input, ctx, options, prevStepResults, dispatch) {
-  const startedAt = Date.now();
-  const maxIter = step.maxIterations ?? 100;
-  let acc = input;
-  let i = 0;
-  while (true) {
-    if (i >= maxIter) {
-      return {
-        stepId: step.id,
-        kind: "dowhile",
-        status: "failed",
-        attempts: i,
-        durationMs: Date.now() - startedAt,
-        error: errToShape(new WorkflowMaxIterationsExceededError(step.id, maxIter))
-      };
-    }
-    const r = await dispatch(step.step, acc, ctx, options, prevStepResults);
-    if (r.status === "failed") {
-      return {
-        stepId: step.id,
-        kind: "dowhile",
-        status: "failed",
-        attempts: i + 1,
-        durationMs: Date.now() - startedAt,
-        error: r.error
-      };
-    }
-    acc = r.output;
-    i += 1;
-    let shouldContinue = false;
-    try {
-      shouldContinue = await Promise.resolve(step.condFn(acc, i));
-    } catch (err) {
-      return {
-        stepId: step.id,
-        kind: "dowhile",
-        status: "failed",
-        attempts: i,
-        durationMs: Date.now() - startedAt,
-        error: errToShape(err)
-      };
-    }
-    if (!shouldContinue) break;
-  }
-  return {
-    stepId: step.id,
-    kind: "dowhile",
-    status: "completed",
-    attempts: i,
-    durationMs: Date.now() - startedAt,
-    output: acc
-  };
-}
-var init_step_dowhile = __esm({
-  "src/internal/workflow/step-dowhile.ts"() {
-    init_workflow();
-    init_error_shape();
-  }
-});
-
-// src/internal/workflow/step-fn.ts
-function failedFnResult(stepId, attempts, startedAt, err) {
-  return {
-    stepId,
-    kind: "fn",
-    status: "failed",
-    attempts,
-    durationMs: Date.now() - startedAt,
-    error: errToShape(err)
-  };
-}
-function validate(schema, value) {
-  if (schema === void 0) return void 0;
-  schema.parse(value);
-  return void 0;
-}
-async function execWithRetry(step, input, ctx) {
-  const exec = async () => step.fn(input, ctx);
-  if (step.retry !== void 0) return withRetry(exec, step.retry, ctx.signal);
-  return { value: await exec(), attempts: 1 };
-}
-async function runFnStep(step, input, ctx) {
-  const startedAt = Date.now();
-  if (step.compensate !== void 0) {
-    return failedFnResult(
-      step.id,
-      0,
-      startedAt,
-      new WorkflowCompensateNotImplementedError(step.id)
-    );
-  }
-  try {
-    validate(step.inputSchema, input);
-  } catch (err) {
-    return failedFnResult(step.id, 0, startedAt, err);
-  }
-  try {
-    const { value, attempts } = await execWithRetry(step, input, ctx);
-    try {
-      validate(step.outputSchema, value);
-    } catch (err) {
-      return failedFnResult(step.id, attempts, startedAt, err);
-    }
-    return {
-      stepId: step.id,
-      kind: "fn",
-      status: "completed",
-      attempts,
-      durationMs: Date.now() - startedAt,
-      output: value
-    };
-  } catch (err) {
-    if (err instanceof WorkflowSuspendedSentinel) throw err;
-    return failedFnResult(step.id, 1, startedAt, err);
-  }
-}
-var init_step_fn = __esm({
-  "src/internal/workflow/step-fn.ts"() {
-    init_workflow();
-    init_ctx();
-    init_error_shape();
-    init_retry_policy();
-  }
-});
-
-// src/internal/runtime/concurrency/async-semaphore.ts
-function createSemaphore(permits) {
-  if (!Number.isInteger(permits) || permits < 1) {
-    throw new ConfigurationError(
-      `async-semaphore: permits must be a positive integer, got ${permits}`,
-      { code: "invalid_concurrency" }
-    );
-  }
-  let active = 0;
-  const queue = [];
-  function tryGrant() {
-    if (active < permits && queue.length > 0) {
-      const resolve2 = queue.shift();
-      if (resolve2 !== void 0) {
-        active += 1;
-        resolve2();
-      }
-    }
-  }
-  return {
-    inFlight: () => active,
-    pending: () => queue.length + active,
-    async acquire() {
-      await new Promise((resolve2) => {
-        queue.push(resolve2);
-        tryGrant();
-      });
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        active -= 1;
-        tryGrant();
-      };
-    }
-  };
-}
-var init_async_semaphore = __esm({
-  "src/internal/runtime/concurrency/async-semaphore.ts"() {
-    init_errors();
-  }
-});
-
-// src/internal/workflow/step-foreach.ts
-async function runForeachStep(step, _input, ctx, options, prevStepResults, dispatch) {
-  const startedAt = Date.now();
-  const sourceResult = prevStepResults.find((r) => r.stepId === step.iterableFrom);
-  if (sourceResult === void 0) {
-    return {
-      stepId: step.id,
-      kind: "foreach",
-      status: "failed",
-      attempts: 0,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(
-        new Error(
-          `foreach.iterableFrom "${step.iterableFrom}" not found in top-level steps. It must reference an earlier top-level step ID \u2014 nested step IDs inside parallel/branch/foreach blocks are not visible here.`
-        )
-      )
-    };
-  }
-  const items = sourceResult.output;
-  if (!Array.isArray(items)) {
-    return {
-      stepId: step.id,
-      kind: "foreach",
-      status: "failed",
-      attempts: 0,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(
-        new Error(
-          `foreach.iterableFrom "${step.iterableFrom}" output must be Array, got ${typeof items}.`
-        )
-      )
-    };
-  }
-  if (items.length === 0) {
-    return {
-      stepId: step.id,
-      kind: "foreach",
-      status: "completed",
-      attempts: 1,
-      durationMs: Date.now() - startedAt,
-      output: []
-    };
-  }
-  const concurrency = step.concurrency ?? 4;
-  const sem = createSemaphore(Math.max(1, Math.min(concurrency, items.length)));
-  const failures = [];
-  const outputs = new Array(items.length);
-  await Promise.all(
-    items.map(async (item, idx) => {
-      const release = await sem.acquire();
-      try {
-        const r = await dispatch(step.step, item, ctx, options, prevStepResults);
-        if (r.status === "failed") {
-          failures.push(new Error(`foreach item ${idx} failed: ${r.error?.message ?? "unknown"}`));
-        } else {
-          outputs[idx] = r.output;
-        }
-      } finally {
-        release();
-      }
-    })
-  );
-  if (failures.length > 0) {
-    return {
-      stepId: step.id,
-      kind: "foreach",
-      status: "failed",
-      attempts: 1,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(
-        new AggregateError(failures, `foreach "${step.id}" had ${failures.length} failure(s)`)
-      )
-    };
-  }
-  return {
-    stepId: step.id,
-    kind: "foreach",
-    status: "completed",
-    attempts: 1,
-    durationMs: Date.now() - startedAt,
-    output: outputs
-  };
-}
-var init_step_foreach = __esm({
-  "src/internal/workflow/step-foreach.ts"() {
-    init_async_semaphore();
-    init_error_shape();
-  }
-});
-
-// src/internal/workflow/step-parallel.ts
-async function runParallelStep(step, input, ctx, options, _prevStepResults, dispatch) {
-  const startedAt = Date.now();
-  const policy = step.errorPolicy ?? "fail-fast";
-  const branchCount = step.branches.length;
-  if (branchCount === 0) {
-    return {
-      stepId: step.id,
-      kind: "parallel",
-      status: "completed",
-      attempts: 1,
-      durationMs: Date.now() - startedAt,
-      output: []
-    };
-  }
-  const concurrency = step.concurrency ?? branchCount;
-  const sem = createSemaphore(Math.max(1, Math.min(concurrency, branchCount)));
-  const failFastCtrl = policy === "fail-fast" ? new AbortController() : void 0;
-  const branchSignal = policy === "fail-fast" ? mergeSignals(ctx.signal, failFastCtrl.signal) : ctx.signal;
-  const semBranchPromises = step.branches.map(async (branch, branchIdx) => {
-    const release = await sem.acquire();
-    try {
-      return await runBranch(
-        branch,
-        input,
-        { ...ctx, signal: branchSignal },
-        options,
-        dispatch,
-        branchIdx
-      );
-    } finally {
-      release();
-    }
-  });
-  if (policy === "fail-fast") {
-    try {
-      const outputs2 = await Promise.all(semBranchPromises);
-      return {
-        stepId: step.id,
-        kind: "parallel",
-        status: "completed",
-        attempts: 1,
-        durationMs: Date.now() - startedAt,
-        output: outputs2
-      };
-    } catch (err) {
-      failFastCtrl?.abort(err);
-      const settled2 = await Promise.allSettled(semBranchPromises);
-      const errors = settled2.filter((s) => s.status === "rejected").map((s) => s.reason instanceof Error ? s.reason : new Error(String(s.reason)));
-      return {
-        stepId: step.id,
-        kind: "parallel",
-        status: "failed",
-        attempts: 1,
-        durationMs: Date.now() - startedAt,
-        error: errToShape(new WorkflowParallelError(errors, step.id)),
-        output: void 0
-      };
-    }
-  }
-  const settled = await Promise.allSettled(semBranchPromises);
-  const outputs = settled.map(
-    (s) => s.status === "fulfilled" ? { ok: true, value: s.value } : { ok: false, error: errToShape(s.reason) }
-  );
-  return {
-    stepId: step.id,
-    kind: "parallel",
-    status: "completed",
-    attempts: 1,
-    durationMs: Date.now() - startedAt,
-    output: outputs
-  };
-}
-async function runBranch(branch, input, ctx, options, dispatch, branchIdx) {
-  let acc = input;
-  for (const inner of branch) {
-    const r = await dispatch(inner, acc, ctx, options, []);
-    if (r.status === "failed") {
-      throw new Error(
-        `parallel branch ${branchIdx} step "${inner.id}" failed: ${r.error?.message ?? "unknown"}`
-      );
-    }
-    acc = r.output;
-  }
-  return acc;
-}
-function mergeSignals(a, b) {
-  if (a.aborted) return a;
-  if (b.aborted) return b;
-  const ctrl = new AbortController();
-  const onAbortA = () => ctrl.abort(a.reason);
-  const onAbortB = () => ctrl.abort(b.reason);
-  a.addEventListener("abort", onAbortA, { once: true });
-  b.addEventListener("abort", onAbortB, { once: true });
-  return ctrl.signal;
-}
-var init_step_parallel = __esm({
-  "src/internal/workflow/step-parallel.ts"() {
-    init_workflow();
-    init_async_semaphore();
-    init_error_shape();
-  }
-});
-
-// src/internal/workflow/step-sleep.ts
-async function runSleepStep(step, input, ctx) {
-  const startedAt = Date.now();
-  try {
-    await abortableSleep(step.durationMs, ctx.signal);
-    return {
-      stepId: step.id,
-      kind: "sleep",
-      status: "completed",
-      attempts: 1,
-      durationMs: Date.now() - startedAt,
-      output: input
-      // sleep is a pass-through
-    };
-  } catch (err) {
-    return {
-      stepId: step.id,
-      kind: "sleep",
-      status: "failed",
-      attempts: 1,
-      durationMs: Date.now() - startedAt,
-      error: errToShape(err)
-    };
-  }
-}
-var init_step_sleep = __esm({
-  "src/internal/workflow/step-sleep.ts"() {
-    init_error_shape();
-    init_retry_policy();
-  }
-});
-function getTracer(name, version = "1.0.0") {
-  const cached = tracerCache.get(name);
-  if (cached !== void 0) return cached.tracer ?? void 0;
-  try {
-    const r = createRequire(import.meta.url);
-    const otel = r("@opentelemetry/api");
-    if (otel.trace?.getTracer === void 0) {
-      tracerCache.set(name, { tracer: null });
-      return void 0;
-    }
-    const tracer = otel.trace.getTracer(name, version);
-    tracerCache.set(name, { tracer });
-    return tracer;
-  } catch {
-    tracerCache.set(name, { tracer: null });
-    return void 0;
-  }
-}
-var noopSpan, tracerCache;
-var init_tracer_loader = __esm({
-  "src/internal/telemetry/tracer-loader.ts"() {
-    noopSpan = {
-      setAttribute: () => noopSpan,
-      end: () => void 0
-    };
-    tracerCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/internal/workflow/telemetry.ts
-function startWorkflowRunSpan(info) {
-  const tracer = getTracer(TRACER_NAME);
-  if (tracer === void 0) return noopSpan;
-  return tracer.startSpan("workflow.run", {
-    attributes: {
-      "workflow.name": info.workflowName,
-      "workflow.run_id": info.runId
-    }
-  });
-}
-function startWorkflowStepSpan(info) {
-  const tracer = getTracer(TRACER_NAME);
-  if (tracer === void 0) return noopSpan;
-  return tracer.startSpan(`workflow.step.${info.stepId}`, {
-    attributes: {
-      "step.id": info.stepId,
-      "step.kind": info.kind,
-      "step.attempt": info.attempt
-    }
-  });
-}
-var TRACER_NAME;
-var init_telemetry = __esm({
-  "src/internal/workflow/telemetry.ts"() {
-    init_tracer_loader();
-    TRACER_NAME = "@theokit/sdk/workflow";
-  }
-});
-
-// src/internal/workflow/executor.ts
-var executor_exports = {};
-__export(executor_exports, {
-  dispatchStep: () => dispatchStep,
-  executeWorkflow: () => executeWorkflow,
-  resumeWorkflow: () => resumeWorkflow
-});
-async function handleSuspend(err, ctx) {
-  try {
-    await saveSnapshot({
-      runId: ctx.runId,
-      workflowName: ctx.options.name,
-      currentStepId: ctx.step.id,
-      suspendedPayload: err.payload,
-      stepResults: ctx.stepResults,
-      accumulatedInput: ctx.acc,
-      state: ctx.stepCtx.state,
-      // SE29 — capture the shared state at suspend
-      options: ctx.options
-    });
-  } catch (snapErr) {
-    ctx.stepSpan.setAttribute("step.status", "failed");
-    ctx.stepSpan.end();
-    return {
-      kind: "failed",
-      run: assembleRun({
-        runId: ctx.runId,
-        name: ctx.name,
-        status: "failed",
-        stepResults: ctx.stepResults,
-        startedAt: ctx.startedAt,
-        error: errToShape(snapErr)
-      })
-    };
-  }
-  ctx.stepSpan.setAttribute("step.status", "suspended");
-  ctx.stepSpan.end();
-  return {
-    kind: "suspended",
-    run: assembleRun({
-      runId: ctx.runId,
-      name: ctx.name,
-      status: "suspended",
-      stepResults: [
-        ...ctx.stepResults,
-        {
-          stepId: ctx.step.id,
-          kind: ctx.step.kind,
-          status: "suspended",
-          attempts: 1,
-          durationMs: 0,
-          output: void 0
-        }
-      ],
-      startedAt: ctx.startedAt
-    })
-  };
-}
-async function runOneStep(args) {
-  const stepSpan = startWorkflowStepSpan({
-    stepId: args.step.id,
-    kind: args.step.kind,
-    attempt: 1
-  });
-  let result;
-  try {
-    result = await dispatchStep(args.step, args.acc, args.ctx, args.options, args.stepResults);
-  } catch (err) {
-    if (err instanceof WorkflowSuspendedSentinel) {
-      const outcome = await handleSuspend(err, { ...args, stepSpan, stepCtx: args.ctx });
-      return { kind: "terminal", run: outcome.run };
-    }
-    result = {
-      stepId: args.step.id,
-      kind: args.step.kind,
-      status: "failed",
-      attempts: 1,
-      durationMs: 0,
-      error: errToShape(err)
-    };
-  }
-  stepSpan.setAttribute("step.status", result.status);
-  stepSpan.setAttribute("step.attempts", result.attempts);
-  stepSpan.end();
-  return { kind: "ok", result };
-}
-function handleStepOutcome(outcome, step, loop, onStepEvent) {
-  if (outcome.kind === "terminal") {
-    if (outcome.run.status === "suspended") {
-      onStepEvent?.({ type: "workflow_suspended", stepId: step.id });
-    }
-    return { terminal: outcome.run };
-  }
-  loop.stepResults.push(outcome.result);
-  if (outcome.result.status === "failed") {
-    onStepEvent?.({
-      type: "step_failed",
-      stepId: step.id,
-      error: outcome.result.error ?? { name: "WorkflowStepError", message: "step failed" }
-    });
-    return {
-      terminal: assembleRun({
-        runId: loop.runId,
-        name: loop.name,
-        status: "failed",
-        stepResults: loop.stepResults,
-        startedAt: loop.startedAt,
-        error: outcome.result.error
-      })
-    };
-  }
-  onStepEvent?.({ type: "step_completed", stepId: step.id, output: outcome.result.output });
-  return { acc: outcome.result.output };
-}
-async function runStepsLoop(params) {
-  const { options, steps, ctx, runId, startedAt, signal, onStepEvent } = params;
-  const stepResults = [...params.initialStepResults ?? []];
-  const loop = { stepResults, runId, name: options.name, startedAt };
-  let acc = params.input;
-  for (const step of steps) {
-    if (signal.aborted) return abortRun(options.name, runId, startedAt, stepResults, signal);
-    onStepEvent?.({ type: "step_started", stepId: step.id });
-    const outcome = await runOneStep({
-      step,
-      acc,
-      ctx,
-      options,
-      stepResults,
-      runId,
-      name: options.name,
-      startedAt
-    });
-    const handled = handleStepOutcome(outcome, step, loop, onStepEvent);
-    if ("terminal" in handled) return handled.terminal;
-    acc = handled.acc;
-  }
-  const outputIssues = validateWorkflowSchema(options.outputSchema, acc);
-  if (outputIssues !== void 0) {
-    return assembleRun({
-      runId,
-      name: options.name,
-      status: "failed",
-      stepResults,
-      startedAt,
-      error: errToShape(new WorkflowOutputError(options.name, outputIssues))
-    });
-  }
-  onStepEvent?.({ type: "workflow_completed" });
-  return assembleRun({
-    runId,
-    name: options.name,
-    status: "completed",
-    output: acc,
-    stepResults,
-    startedAt
-  });
-}
-async function executeWorkflow(options, steps, input, runOpts) {
-  const runId = runOpts?.runId ?? mintRunId();
-  const workflowId = options.workflowId ?? `wf-anon`;
-  const flight = acquireSingleFlight(workflowId, runId, options.name);
-  const startedAt = Date.now();
-  const signal = combineSignals(runOpts?.signal, flight.signal);
-  const runSpan = startWorkflowRunSpan({ workflowName: options.name, runId });
-  if (signal.aborted) {
-    flight.release();
-    runSpan.setAttribute("workflow.status", "cancelled");
-    runSpan.end();
-    return abortRun(options.name, runId, startedAt, [], signal);
-  }
-  const internal = runOpts;
-  const seededState = internal?.restoredState !== void 0 ? internal.restoredState : options.initialState;
-  const stateController = makeStateController(options, seededState);
-  const ctx = makeStepContext(runId, signal, stateController);
-  try {
-    const inputIssues = validateWorkflowSchema(options.inputSchema, input);
-    if (inputIssues !== void 0) {
-      return assembleRun({
-        runId,
-        name: options.name,
-        status: "failed",
-        stepResults: [],
-        startedAt,
-        error: errToShape(new WorkflowInputError(options.name, inputIssues))
-      });
-    }
-    const stateIssues = seededState !== void 0 ? validateWorkflowSchema(options.stateSchema, seededState) : void 0;
-    if (stateIssues !== void 0) {
-      return assembleRun({
-        runId,
-        name: options.name,
-        status: "failed",
-        stepResults: [],
-        startedAt,
-        error: errToShape(new WorkflowStateError(options.name, stateIssues))
-      });
-    }
-    return await runStepsLoop({
-      options,
-      steps,
-      input,
-      ctx,
-      runId,
-      startedAt,
-      signal,
-      ...internal?.initialStepResults !== void 0 ? { initialStepResults: internal.initialStepResults } : {},
-      ...internal?.onStepEvent !== void 0 ? { onStepEvent: internal.onStepEvent } : {}
-    });
-  } finally {
-    runSpan.end();
-    flight.release();
-  }
-}
-async function dispatchStep(step, input, ctx, options, prevStepResults) {
-  switch (step.kind) {
-    case "fn":
-      return runFnStep(step, input, ctx);
-    case "agent":
-      return runAgentStep(step, input, ctx);
-    case "parallel":
-      return runParallelStep(step, input, ctx, options, prevStepResults, dispatchStep);
-    case "branch":
-      return runBranchStep(step, input, ctx, options, prevStepResults, dispatchStep);
-    case "foreach":
-      return runForeachStep(step, input, ctx, options, prevStepResults, dispatchStep);
-    case "dowhile":
-      return runDowhileStep(step, input, ctx, options, prevStepResults, dispatchStep);
-    case "sleep":
-      return runSleepStep(step, input, ctx);
-    case "suspend":
-      throw new WorkflowSuspendedSentinel(void 0);
-    default: {
-      const _exhaustive = step;
-      throw new Error(`Unknown step kind: ${_exhaustive.kind}`);
-    }
-  }
-}
-async function saveSnapshot(p) {
-  const snapshot = {
-    _schemaVersion: 2,
-    // SE29 — carries `state`
-    runId: p.runId,
-    workflowName: p.workflowName,
-    currentStepId: p.currentStepId,
-    suspendedPayload: p.suspendedPayload,
-    stepResults: p.stepResults,
-    accumulatedInput: p.accumulatedInput,
-    ...p.state !== void 0 ? { state: p.state } : {},
-    suspendedAt: Date.now()
-  };
-  const store = getSnapshotStoreFor(p.options);
-  await store.save(snapshot);
-}
-async function resumeWorkflow(opts) {
-  const wfInternal = opts.workflow;
-  const options = wfInternal.__options;
-  const steps = wfInternal.__steps;
-  if (options === void 0 || steps === void 0) {
-    throw new Error("Workflow.resume requires an instance from Workflow.create().commit()");
-  }
-  const store = getSnapshotStoreFor(options);
-  const snapshot = await store.load(opts.runId);
-  if (snapshot === void 0) {
-    throw new WorkflowSnapshotNotFoundError(opts.runId);
-  }
-  const stepIdx = steps.findIndex((s) => s.id === snapshot.currentStepId);
-  if (stepIdx < 0) {
-    throw new WorkflowResumeStepNotFoundError(snapshot.currentStepId, snapshot.workflowName);
-  }
-  const suspendStep = steps[stepIdx];
-  if (suspendStep !== void 0 && suspendStep.kind === "suspend" && suspendStep.payloadSchema !== void 0) {
-    suspendStep.payloadSchema.parse(opts.payload);
-  }
-  const resumeInput = opts.payload !== void 0 ? opts.payload : snapshot.accumulatedInput;
-  const remainingSteps = steps.slice(stepIdx + 1);
-  await store.delete(opts.runId);
-  return executeWorkflow(options, remainingSteps, resumeInput, {
-    signal: opts.signal,
-    runId: opts.runId,
-    // M3 #62 — restore prior step outputs so the resumed run is not lossy (internal seam).
-    initialStepResults: snapshot.stepResults,
-    // SE29 — restore shared state (v2 snapshot). A v1 snapshot has no `state` →
-    // executeWorkflow falls back to `options.initialState`.
-    ...snapshot.state !== void 0 ? { restoredState: snapshot.state } : {}
-  });
-}
-var init_executor = __esm({
-  "src/internal/workflow/executor.ts"() {
-    init_workflow();
-    init_ctx();
-    init_error_shape();
-    init_executor_helpers();
-    init_run_id();
-    init_single_flight();
-    init_snapshot_store();
-    init_step_agent();
-    init_step_branch();
-    init_step_dowhile();
-    init_step_fn();
-    init_step_foreach();
-    init_step_parallel();
-    init_step_sleep();
-    init_telemetry();
-  }
-});
-
-// src/types/run-events.ts
-function emitRunEvent(sink, event) {
-  if (sink === void 0) return;
-  try {
-    sink(event);
-  } catch {
-  }
-}
-var init_run_events = __esm({
-  "src/types/run-events.ts"() {
-  }
-});
-
-// src/types/task.ts
-function isValidTaskId(id, allowReserved) {
-  if (!TASK_ID_GRAMMAR.test(id)) return false;
-  if (allowReserved) return true;
-  for (const prefix of RESERVED_PREFIXES) {
-    if (id.startsWith(prefix)) return false;
-  }
-  return true;
-}
-var TASK_ID_GRAMMAR, RESERVED_PREFIXES;
-var init_task = __esm({
-  "src/types/task.ts"() {
-    TASK_ID_GRAMMAR = /^[a-z0-9][a-z0-9_-]*$/;
-    RESERVED_PREFIXES = ["wf-", "b-", "cron-"];
-  }
-});
-
-// src/internal/task/ring-buffer.ts
-var RingBuffer;
-var init_ring_buffer = __esm({
-  "src/internal/task/ring-buffer.ts"() {
-    RingBuffer = class {
-      constructor(cap) {
-        this.cap = cap;
-        if (!Number.isInteger(cap) || cap < 1) {
-          throw new Error(`RingBuffer capacity must be a positive integer, got ${cap}`);
-        }
-      }
-      cap;
-      buf = [];
-      truncated = false;
-      push(item) {
-        if (this.buf.length >= this.cap) {
-          this.buf.shift();
-          this.truncated = true;
-        }
-        this.buf.push(item);
-      }
-      drain() {
-        return { items: this.buf.slice(), truncated: this.truncated };
-      }
-      size() {
-        return this.buf.length;
-      }
-      wasTruncated() {
-        return this.truncated;
-      }
-    };
-  }
-});
-function assertValidIdForStore(id) {
-  if (!isValidTaskId(
-    id,
-    /* allowReserved */
-    true
-  )) {
-    throw new InvalidTaskIdError(`store rejects invalid task id: ${id}`, id);
-  }
-}
-function terminalTimestamp(h) {
-  if (h.state === "finished") return h.finishedAt;
-  if (h.state === "error") return h.erroredAt;
-  if (h.state === "cancelled") return h.cancelledAt;
-  return void 0;
-}
-function isTerminal(state2) {
-  return state2 === "finished" || state2 === "error" || state2 === "cancelled";
-}
-function matchesState(h, filter) {
-  if (filter.state === void 0) return true;
-  const states = Array.isArray(filter.state) ? filter.state : [filter.state];
-  return states.includes(h.state);
-}
-function matchesKind(h, filter) {
-  if (filter.kind === void 0) return true;
-  const kinds = Array.isArray(filter.kind) ? filter.kind : [filter.kind];
-  return kinds.includes(h.kind);
-}
-function matchesTime(h, filter) {
-  if (filter.submittedAfter !== void 0 && h.submittedAt <= filter.submittedAfter) return false;
-  if (filter.submittedBefore !== void 0 && h.submittedAt >= filter.submittedBefore) return false;
-  return true;
-}
-function matchesFilter(h, filter) {
-  return matchesState(h, filter) && matchesKind(h, filter) && matchesTime(h, filter);
-}
-function applyFilter(values, filter) {
-  const limit = filter.limit ?? DEFAULT_LIST_LIMIT;
-  const out = [];
-  for (const h of values) {
-    if (matchesFilter(h, filter)) {
-      out.push(h);
-      if (out.length >= limit) break;
-    }
-  }
-  return out;
-}
-function getTaskStoreFor(options) {
-  if (options.backend === "memory") return new InMemoryTaskStore();
-  return new JsonFileTaskStore(options.dir);
-}
-var JSON_LOAD_CAP, DEFAULT_LIST_LIMIT, InMemoryTaskStore, JsonFileTaskStore;
-var init_store = __esm({
-  "src/internal/task/store.ts"() {
-    init_errors();
-    init_task();
-    init_atomic_write();
-    JSON_LOAD_CAP = 256;
-    DEFAULT_LIST_LIMIT = 100;
-    InMemoryTaskStore = class {
-      map = /* @__PURE__ */ new Map();
-      async insert(handle) {
-        assertValidIdForStore(handle.id);
-        this.map.set(handle.id, handle);
-      }
-      async update(id, mutate) {
-        assertValidIdForStore(id);
-        const existing = this.map.get(id);
-        if (existing === void 0) return void 0;
-        const next = mutate(existing);
-        this.map.set(id, next);
-        return next;
-      }
-      async get(id) {
-        assertValidIdForStore(id);
-        return this.map.get(id);
-      }
-      async list(filter) {
-        return applyFilter(this.map.values(), filter);
-      }
-      async delete(id) {
-        assertValidIdForStore(id);
-        return this.map.delete(id);
-      }
-      async evictTerminalOlderThan(epochMs) {
-        let count = 0;
-        for (const [id, h] of this.map.entries()) {
-          if (!isTerminal(h.state)) continue;
-          const ts = terminalTimestamp(h);
-          if (ts !== void 0 && ts < epochMs) {
-            this.map.delete(id);
-            count++;
-          }
-        }
-        return count;
-      }
-    };
-    JsonFileTaskStore = class {
-      constructor(dir) {
-        this.dir = dir;
-        try {
-          mkdirSync(dir, { recursive: true });
-        } catch (err) {
-          if (err.code !== "EEXIST") throw err;
-        }
-      }
-      dir;
-      filePath(id) {
-        return join(this.dir, `${id}.json`);
-      }
-      async insert(handle) {
-        assertValidIdForStore(handle.id);
-        await atomicWriteText(this.filePath(handle.id), JSON.stringify(handle));
-      }
-      async update(id, mutate) {
-        assertValidIdForStore(id);
-        const existing = await this.get(id);
-        if (existing === void 0) return void 0;
-        const next = mutate(existing);
-        await atomicWriteText(this.filePath(id), JSON.stringify(next));
-        return next;
-      }
-      async get(id) {
-        assertValidIdForStore(id);
-        try {
-          const raw = await readFile(this.filePath(id), "utf8");
-          return JSON.parse(raw);
-        } catch (err) {
-          const code = err.code;
-          if (code === "ENOENT") return void 0;
-          process.stderr.write(`[task-store] failed to read ${id}: ${err.message}
-`);
-          return void 0;
-        }
-      }
-      async list(filter) {
-        let entries;
-        try {
-          entries = readdirSync(this.dir);
-        } catch (err) {
-          if (err.code === "ENOENT") return [];
-          throw err;
-        }
-        const candidates = entries.filter((name) => name.endsWith(".json") && !name.includes(".tmp")).slice(0, JSON_LOAD_CAP);
-        const loaded = await Promise.all(
-          candidates.map(async (name) => {
-            const id = name.slice(0, -".json".length);
-            if (!isValidTaskId(id, true)) return void 0;
-            return this.get(id);
-          })
-        );
-        const handles = loaded.filter((h) => h !== void 0);
-        return applyFilter(handles, filter);
-      }
-      async delete(id) {
-        assertValidIdForStore(id);
-        try {
-          await unlink(this.filePath(id));
-          return true;
-        } catch (err) {
-          if (err.code === "ENOENT") return false;
-          throw err;
-        }
-      }
-      async evictTerminalOlderThan(epochMs) {
-        const handles = await this.list({ state: ["finished", "error", "cancelled"], limit: 256 });
-        let count = 0;
-        for (const h of handles) {
-          const ts = terminalTimestamp(h);
-          if (ts !== void 0 && ts < epochMs) {
-            if (await this.delete(h.id)) count++;
-          }
-        }
-        return count;
-      }
-    };
-  }
-});
-
-// src/internal/task/subscribe.ts
-function isTerminalEvent(event) {
-  return event.type === "finished" || event.type === "errored" || event.type === "cancelled";
-}
-function drainBuffered(buffer) {
-  const { items, truncated } = buffer.drain();
-  const queue = items.slice();
-  if (truncated && queue.length > 0) {
-    const first = queue[0];
-    if (first !== void 0 && first.type === "submitted") {
-      queue[0] = { ...first, truncated: true };
-    }
-  }
-  return queue;
-}
-function buildSubscribe(deps) {
-  return function subscribe2(id) {
-    if (!isValidTaskId(id, true)) throw new TaskNotFoundError(id);
-    const buffer = deps.getBuffer(id);
-    if (buffer === void 0) throw new TaskNotFoundError(id);
-    return {
-      [Symbol.asyncIterator]() {
-        return new TaskIterator(buffer, id, deps);
-      }
-    };
-  };
-}
-var TaskIterator;
-var init_subscribe = __esm({
-  "src/internal/task/subscribe.ts"() {
-    init_errors();
-    init_task();
-    TaskIterator = class {
-      constructor(buffer, id, deps) {
-        this.id = id;
-        this.deps = deps;
-        this.queue = drainBuffered(buffer);
-        this.callback = (e) => this.deliver(e);
-        deps.getOrCreateSubscriberSet(id).add(this.callback);
-      }
-      id;
-      deps;
-      queue;
-      pendingResolve;
-      done = false;
-      callback;
-      deliver(e) {
-        if (this.done) return;
-        if (this.pendingResolve !== void 0) {
-          const r = this.pendingResolve;
-          this.pendingResolve = void 0;
-          r({ value: e, done: false });
-        } else {
-          this.queue.push(e);
-        }
-      }
-      cleanup() {
-        if (this.done) return;
-        this.done = true;
-        this.deps.removeSubscriber(this.id, this.callback);
-        if (this.pendingResolve !== void 0) {
-          const r = this.pendingResolve;
-          this.pendingResolve = void 0;
-          r({ value: void 0, done: true });
-        }
-      }
-      dequeue() {
-        const event = this.queue.shift();
-        if (event === void 0) return void 0;
-        if (isTerminalEvent(event)) queueMicrotask(() => this.cleanup());
-        return { value: event, done: false };
-      }
-      next() {
-        if (this.done) return Promise.resolve({ value: void 0, done: true });
-        const queued = this.dequeue();
-        if (queued !== void 0) return Promise.resolve(queued);
-        return new Promise((resolve2) => {
-          this.pendingResolve = resolve2;
-        });
-      }
-      return() {
-        this.cleanup();
-        return Promise.resolve({ value: void 0, done: true });
-      }
-    };
-  }
-});
-
-// src/internal/task/task-run-event-bridge.ts
-function taskEventToRunEvent(event, taskId, kind) {
-  switch (event.type) {
-    case "started":
-      return { type: "task_started", taskId, description: kind };
-    case "progress":
-      return { type: "task_updated", taskId, status: "progress" };
-    case "finished":
-      return { type: "task_completed", taskId, status: "completed" };
-    case "errored":
-      return { type: "task_completed", taskId, status: "failed" };
-    case "cancelled":
-      return { type: "task_completed", taskId, status: "stopped" };
-    default:
-      return void 0;
-  }
-}
-var init_task_run_event_bridge = __esm({
-  "src/internal/task/task-run-event-bridge.ts"() {
-  }
-});
-
-// src/internal/task/telemetry.ts
-function startTaskSubmitSpan(info) {
-  const tracer = getTracer(TRACER_NAME2);
-  if (tracer === void 0) return noopSpan;
-  return tracer.startSpan("task.submit", {
-    attributes: {
-      "task.id": info.taskId,
-      "task.kind": info.kind
-    }
-  });
-}
-function startTaskTransitionSpan(info) {
-  const tracer = getTracer(TRACER_NAME2);
-  if (tracer === void 0) return noopSpan;
-  return tracer.startSpan("task.transition", {
-    attributes: {
-      "task.id": info.taskId,
-      "task.state.from": info.from,
-      "task.state.to": info.to
-    }
-  });
-}
-function startTaskCancelSpan(info) {
-  const tracer = getTracer(TRACER_NAME2);
-  if (tracer === void 0) return noopSpan;
-  return tracer.startSpan("task.cancel", {
-    attributes: {
-      "task.id": info.taskId,
-      "task.cancel.via": info.via,
-      ...info.reason !== void 0 ? { "task.cancel.reason": info.reason } : {}
-    }
-  });
-}
-var TRACER_NAME2;
-var init_telemetry2 = __esm({
-  "src/internal/task/telemetry.ts"() {
-    init_tracer_loader();
-    TRACER_NAME2 = "@theokit/sdk/task";
-  }
-});
-
-// src/internal/task/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  __getSubscribersCountForTests: () => __getSubscribersCountForTests,
-  __resetTaskRegistryForTests: () => __resetTaskRegistryForTests,
-  cancel: () => cancel,
-  configure: () => configure,
-  get: () => get,
-  list: () => list,
-  submit: () => submit,
-  subscribe: () => subscribe
-});
-function buildState(opts) {
-  const store = opts.store === void 0 ? new InMemoryTaskStore() : getTaskStoreFor(opts.store);
-  return {
-    store,
-    semaphore: createSemaphore(opts.maxConcurrent ?? DEFAULT_CONCURRENCY),
-    aborters: /* @__PURE__ */ new Map(),
-    buffers: /* @__PURE__ */ new Map(),
-    subscribers: /* @__PURE__ */ new Map(),
-    retentionMs: opts.retentionMs ?? DEFAULT_RETENTION_MS,
-    firstSubmitSeen: false
-  };
-}
-function __resetTaskRegistryForTests() {
-  if (state.evictTimer !== void 0) clearInterval(state.evictTimer);
-  state = buildState({});
-}
-function __getSubscribersCountForTests(taskId) {
-  return state.subscribers.get(taskId)?.size ?? 0;
-}
-function configure(opts) {
-  if (state.firstSubmitSeen) {
-    process.stderr.write(
-      "[task] configure() ignored \u2014 registry already in use; reset via __resetTaskRegistryForTests()\n"
-    );
-    return;
-  }
-  if (state.evictTimer !== void 0) clearInterval(state.evictTimer);
-  state = buildState(opts);
-}
-function emitToSubscribers(taskId, event) {
-  const buffer = state.buffers.get(taskId);
-  if (buffer !== void 0) buffer.push(event);
-  const subs = state.subscribers.get(taskId);
-  if (subs === void 0) return;
-  for (const cb of subs) {
-    try {
-      cb(event);
-    } catch (err) {
-      process.stderr.write(`[task] subscriber threw: ${err.message}
-`);
-    }
-  }
-}
-async function safeUpdate(taskId, mutate) {
-  try {
-    return await state.store.update(taskId, mutate);
-  } catch (err) {
-    process.stderr.write(`[task] store.update failed for ${taskId}: ${err.message}
-`);
-    return void 0;
-  }
-}
-function startEvictTimerIfNeeded() {
-  if (state.evictTimer !== void 0) return;
-  state.evictTimer = setInterval(() => {
-    const cutoff = Date.now() - state.retentionMs;
-    void state.store.evictTerminalOlderThan(cutoff).then((count) => {
-      if (count === 0) return;
-      for (const id of state.buffers.keys()) {
-        void state.store.get(id).then((h) => {
-          if (h === void 0) {
-            state.buffers.delete(id);
-            state.subscribers.delete(id);
-            state.aborters.delete(id);
-          }
-        });
-      }
-    }).catch(() => {
-    });
-  }, EVICTION_INTERVAL_MS).unref();
-}
-function buildSubmittedEvent(handle) {
-  return {
-    type: "submitted",
-    taskId: handle.id,
-    kind: handle.kind,
-    submittedAt: handle.submittedAt,
-    ...handle.meta !== void 0 ? { meta: handle.meta } : {}
-  };
-}
-async function shortCircuitAborted(handle, signal) {
-  const cancelled = {
-    ...handle,
-    state: "cancelled",
-    cancelledAt: Date.now()
-  };
-  await state.store.insert(cancelled);
-  state.buffers.set(handle.id, new RingBuffer(RING_CAP));
-  emitToSubscribers(handle.id, buildSubmittedEvent(cancelled));
-  emitToSubscribers(handle.id, {
-    type: "cancelled",
-    taskId: handle.id,
-    cancelledAt: cancelled.cancelledAt ?? Date.now(),
-    reason: signal.reason instanceof Error ? signal.reason.message : "pre-aborted"
-  });
-  return cancelled;
-}
-async function transition(taskId, next, patch) {
-  const before = await state.store.get(taskId);
-  const span = startTaskTransitionSpan({
-    taskId,
-    from: before?.state ?? "unknown",
-    to: next
-  });
-  try {
-    await safeUpdate(taskId, (h) => ({ ...h, state: next, ...patch }));
-  } finally {
-    span.end();
-  }
-}
-async function buildAndInsertQueued(internal, resolvedId) {
-  const submittedAt = Date.now();
-  const handle = {
-    id: resolvedId,
-    kind: internal.kind,
-    state: "queued",
-    submittedAt,
-    ...internal.meta !== void 0 ? { meta: internal.meta } : {}
-  };
-  await state.store.insert(handle);
-  state.buffers.set(resolvedId, new RingBuffer(RING_CAP));
-  emitToSubscribers(resolvedId, buildSubmittedEvent(handle));
-  return handle;
-}
-function resolveIdInternal(internal) {
-  if (internal.id === void 0) return randomUUID();
-  if (!isValidTaskId(internal.id, internal.allowReservedPrefix ?? false)) {
-    throw new InvalidTaskIdError(`invalid task id: ${internal.id}`, internal.id);
-  }
-  return internal.id;
-}
-async function runWorkAndFinalize(taskId, aborter, work) {
-  const ctx = {
-    signal: aborter.signal,
-    emit(payload) {
-      void checkCancelRequestedAt(taskId, aborter);
-      emitToSubscribers(taskId, {
-        type: "progress",
-        taskId,
-        at: Date.now(),
-        payload
-      });
-    }
-  };
-  try {
-    const result = await reentryAls.run(true, () => Promise.resolve().then(() => work(ctx)));
-    if (aborter.signal.aborted) {
-      const cancelledAt = Date.now();
-      await transition(taskId, "cancelled", { cancelledAt });
-      emitToSubscribers(taskId, { type: "cancelled", taskId, cancelledAt });
-      return;
-    }
-    const finishedAt = Date.now();
-    await transition(taskId, "finished", { finishedAt, result });
-    emitToSubscribers(taskId, { type: "finished", taskId, finishedAt, result });
-  } catch (err) {
-    if (aborter.signal.aborted) {
-      const cancelledAt = Date.now();
-      await transition(taskId, "cancelled", { cancelledAt });
-      emitToSubscribers(taskId, { type: "cancelled", taskId, cancelledAt });
-      return;
-    }
-    const erroredAt = Date.now();
-    const error = err instanceof Error ? { code: err.code ?? "work_threw", message: err.message } : { code: "work_threw", message: String(err) };
-    await transition(taskId, "error", { erroredAt, error });
-    emitToSubscribers(taskId, { type: "errored", taskId, erroredAt, error });
-  }
-}
-async function checkCancelRequestedAt(taskId, aborter) {
-  if (aborter.signal.aborted) return;
-  try {
-    const handle = await state.store.get(taskId);
-    if (handle?.cancelRequested === true) {
-      aborter.abort("cancelRequested");
-    }
-  } catch {
-  }
-}
-async function acquireSlot() {
-  if (reentryAls.getStore() === true) {
-    return () => {
-    };
-  }
-  return state.semaphore.acquire();
-}
-async function submit(internal) {
-  state.firstSubmitSeen = true;
-  startEvictTimerIfNeeded();
-  const resolvedId = resolveIdInternal(internal);
-  if (internal.onRunEvent !== void 0) {
-    const sink = internal.onRunEvent;
-    const kind = internal.kind;
-    const subs = state.subscribers.get(resolvedId) ?? /* @__PURE__ */ new Set();
-    subs.add((e) => {
-      const runEvent = taskEventToRunEvent(e, resolvedId, kind);
-      if (runEvent !== void 0) emitRunEvent(sink, runEvent);
-    });
-    state.subscribers.set(resolvedId, subs);
-  }
-  const submitSpan = startTaskSubmitSpan({ taskId: resolvedId, kind: internal.kind });
-  const existing = await state.store.get(resolvedId);
-  if (existing !== void 0) {
-    submitSpan.end();
-    return existing;
-  }
-  const queuedHandle = await buildAndInsertQueued(internal, resolvedId);
-  submitSpan.end();
-  if (internal.signal?.aborted === true) {
-    return shortCircuitAborted(queuedHandle, internal.signal);
-  }
-  const aborter = new AbortController();
-  state.aborters.set(resolvedId, aborter);
-  if (internal.signal !== void 0) {
-    internal.signal.addEventListener("abort", () => aborter.abort(internal.signal?.reason), {
-      once: true
-    });
-  }
-  const release = await acquireSlot();
-  void (async () => {
-    try {
-      await checkCancelRequestedAt(resolvedId, aborter);
-      if (aborter.signal.aborted) {
-        const cancelledAt = Date.now();
-        await transition(resolvedId, "cancelled", { cancelledAt });
-        emitToSubscribers(resolvedId, { type: "cancelled", taskId: resolvedId, cancelledAt });
-        return;
-      }
-      const startedAt = Date.now();
-      await transition(resolvedId, "running", { startedAt });
-      emitToSubscribers(resolvedId, { type: "started", taskId: resolvedId, startedAt });
-      await runWorkAndFinalize(resolvedId, aborter, internal.work);
-    } finally {
-      release();
-      state.aborters.delete(resolvedId);
-    }
-  })();
-  return queuedHandle;
-}
-async function list(filter = {}) {
-  return state.store.list(filter);
-}
-async function get(id) {
-  if (!isValidTaskId(id, true)) return void 0;
-  return state.store.get(id);
-}
-async function cancel(id, reason) {
-  if (!isValidTaskId(id, true)) return { cancelled: false, alreadyTerminal: false };
-  const handle = await state.store.get(id);
-  if (handle === void 0) return { cancelled: false, alreadyTerminal: false };
-  if (handle.state === "finished" || handle.state === "error" || handle.state === "cancelled") {
-    return { cancelled: false, alreadyTerminal: true };
-  }
-  const span = startTaskCancelSpan({
-    taskId: id,
-    ...reason !== void 0 ? { reason } : {},
-    via: "api"
-  });
-  try {
-    return await cancelInternal(id, handle.state, reason);
-  } finally {
-    span.end();
-  }
-}
-async function cancelInternal(id, currentState, reason) {
-  if (currentState === "queued") {
-    const cancelledAt = Date.now();
-    await transition(id, "cancelled", { cancelledAt });
-    emitToSubscribers(id, {
-      type: "cancelled",
-      taskId: id,
-      cancelledAt,
-      ...reason !== void 0 ? { reason } : {}
-    });
-    state.aborters.delete(id);
-    return { cancelled: true, alreadyTerminal: false };
-  }
-  const aborter = state.aborters.get(id);
-  if (aborter !== void 0) aborter.abort(reason ?? "cancelled");
-  return { cancelled: true, alreadyTerminal: false };
-}
-var DEFAULT_CONCURRENCY, DEFAULT_RETENTION_MS, EVICTION_INTERVAL_MS, RING_CAP, reentryAls, state, subscribe;
-var init_registry = __esm({
-  "src/internal/task/registry.ts"() {
-    init_errors();
-    init_run_events();
-    init_task();
-    init_async_semaphore();
-    init_ring_buffer();
-    init_store();
-    init_subscribe();
-    init_task_run_event_bridge();
-    init_telemetry2();
-    DEFAULT_CONCURRENCY = 8;
-    DEFAULT_RETENTION_MS = 60 * 60 * 1e3;
-    EVICTION_INTERVAL_MS = 5 * 60 * 1e3;
-    RING_CAP = 64;
-    reentryAls = new AsyncLocalStorage();
-    state = buildState({});
-    subscribe = buildSubscribe({
-      getBuffer: (id) => state.buffers.get(id),
-      getOrCreateSubscriberSet: (id) => {
-        let subs = state.subscribers.get(id);
-        if (subs === void 0) {
-          subs = /* @__PURE__ */ new Set();
-          state.subscribers.set(id, subs);
-        }
-        return subs;
-      },
-      removeSubscriber: (id, cb) => {
-        const set = state.subscribers.get(id);
-        set?.delete(cb);
-        if (set !== void 0 && set.size === 0) state.subscribers.delete(id);
-      }
-    });
-  }
-});
-var PersistenceSchema = z.object({
-  backend: z.enum(["memory", "json"]),
-  dir: z.string().optional()
-}).refine((p) => p.backend !== "json" || typeof p.dir === "string" && p.dir.length > 0, {
-  message: 'persistence.dir is required when backend = "json"'
-}).optional();
-
-// src/internal/security/path-guard.ts
-init_errors();
-var PathTraversalError = class extends ConfigurationError {
-  name = "PathTraversalError";
-  constructor(input, resolvedPath) {
-    super(`Path traversal attempt: ${input} \u2192 ${resolvedPath}`, {
-      code: "path_traversal"
-    });
-  }
-};
-function rejectNulAndControlChars(input, role) {
-  for (let i = 0; i < input.length; i++) {
-    const code = input.charCodeAt(i);
-    if (code === 0 || code >= 1 && code <= 31 || code === 127) {
-      const label = code === 0 ? "<nul-byte>" : `<control-char-0x${code.toString(16)}>`;
-      throw new PathTraversalError(`${role}: ${input}`, label);
-    }
-  }
-}
-var IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9\-_]*$/i;
-function sanitizeIdentifier(input, options) {
-  const maxLen = options?.maxLen;
-  if (input.length === 0 || input.length > maxLen) {
-    throw new ConfigurationError(`Identifier length out of range (1-${maxLen}): "${input}"`, {
-      code: "invalid_identifier"
-    });
-  }
-  rejectNulAndControlChars(input, "identifier");
-  if (!IDENTIFIER_PATTERN.test(input)) {
-    throw new ConfigurationError(`Identifier contains invalid characters: "${input}"`, {
-      code: "invalid_identifier"
-    });
-  }
-  return input.toLowerCase();
-}
-
-// src/internal/workflow/event-stream.ts
-function createEventStream() {
-  const buffer = [];
-  const waiters = [];
-  let ended = false;
-  const stream = {
-    push(event) {
-      if (ended) return;
-      const waiter = waiters.shift();
-      if (waiter !== void 0) waiter({ value: event, done: false });
-      else buffer.push(event);
-    },
-    end() {
-      if (ended) return;
-      ended = true;
-      for (const waiter of waiters.splice(0)) waiter({ value: void 0, done: true });
-    },
-    next() {
-      const buffered = buffer.shift();
-      if (buffered !== void 0) return Promise.resolve({ value: buffered, done: false });
-      if (ended) return Promise.resolve({ value: void 0, done: true });
-      return new Promise((resolve2) => waiters.push(resolve2));
-    },
-    // `for await` calls return() on break/throw — close early so events stop
-    // buffering in memory for a consumer that stopped iterating.
-    return() {
-      stream.end();
-      buffer.length = 0;
-      return Promise.resolve({ value: void 0, done: true });
-    },
-    [Symbol.asyncIterator]() {
-      return stream;
-    }
-  };
-  return stream;
-}
-function toJsonSchema(schema, options = { unrepresentable: "any" }) {
-  return toJSONSchema(schema, options);
-}
-
-// src/workflow.ts
-init_workflow();
-init_snapshot_store();
-init_workflow();
-var RetryPolicySchema = z.object({
-  // EC-3 absorbed: maxAttempts MUST be a finite int in [1, 20].
-  maxAttempts: z.number().int("retry.maxAttempts must be integer").min(1, "retry.maxAttempts must be >= 1").max(20, "retry.maxAttempts must be <= 20"),
-  initialBackoffMs: z.number().int().min(0).optional(),
-  backoffCoefficient: z.number().min(1).optional(),
-  maximumBackoffMs: z.number().int().min(0).optional(),
-  nonRetryableErrors: z.array(z.string()).optional()
-});
-var WorkflowOptionsSchema = z.object({
-  name: z.string().min(1).max(128),
-  persistence: PersistenceSchema,
-  // SE27 — declared so a future `new WorkflowBuilder(parsed)` refactor cannot
-  // silently drop them (create() passes the ORIGINAL options today, but the
-  // schema is also the documentation of the shape).
-  inputSchema: z.custom().optional(),
-  outputSchema: z.custom().optional()
-});
-var WorkflowBuilder = class {
-  /** @internal */
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  _steps = [];
-  _committed = false;
-  /** @internal — only the executor reads this. */
-  get __steps() {
-    return this._steps;
-  }
-  // biome-ignore lint/suspicious/noThenProperty: D233 locks the a peer framework-style `.then(step)` builder DSL. The method is fluent, never awaited.
-  then(step) {
-    this.assertNotCommitted();
-    validateStepId(step.id);
-    this._steps.push(step);
-    return this;
-  }
-  parallel(branches, opts) {
-    this.assertNotCommitted();
-    const id = opts?.id ?? `parallel_${this._steps.length}`;
-    validateStepId(id);
-    for (const branch of branches) {
-      for (const inner of branch) validateStepId(inner.id);
-    }
-    const step = {
-      kind: "parallel",
-      id,
-      branches,
-      ...opts?.concurrency !== void 0 ? { concurrency: opts.concurrency } : {},
-      ...opts?.errorPolicy !== void 0 ? { errorPolicy: opts.errorPolicy } : {}
-    };
-    this._steps.push(step);
-    return this;
-  }
-  branch(predicates, opts) {
-    this.assertNotCommitted();
-    const id = opts?.id ?? `branch_${this._steps.length}`;
-    validateStepId(id);
-    const step = {
-      kind: "branch",
-      id,
-      predicates,
-      ...opts?.fallback !== void 0 ? { fallback: opts.fallback } : {}
-    };
-    this._steps.push(step);
-    return this;
-  }
-  foreach(iterableFrom, step, opts) {
-    this.assertNotCommitted();
-    const id = opts?.id ?? `foreach_${this._steps.length}`;
-    validateStepId(id);
-    validateStepId(iterableFrom);
-    validateStepId(step.id);
-    const node = {
-      kind: "foreach",
-      id,
-      iterableFrom,
-      step,
-      ...opts?.concurrency !== void 0 ? { concurrency: opts.concurrency } : {}
-    };
-    this._steps.push(node);
-    return this;
-  }
-  dowhile(step, condFn, opts) {
-    this.assertNotCommitted();
-    const id = opts?.id ?? `dowhile_${this._steps.length}`;
-    validateStepId(id);
-    validateStepId(step.id);
-    const node = {
-      kind: "dowhile",
-      id,
-      step,
-      condFn,
-      ...opts?.maxIterations !== void 0 ? { maxIterations: opts.maxIterations } : {}
-    };
-    this._steps.push(node);
-    return this;
-  }
-  sleep(durationMs, id) {
-    this.assertNotCommitted();
-    const stepId = id ?? `sleep_${this._steps.length}`;
-    validateStepId(stepId);
-    if (!Number.isFinite(durationMs) || durationMs < 0) {
-      throw new Error(`sleep durationMs must be finite non-negative: ${durationMs}`);
-    }
-    const step = { kind: "sleep", id: stepId, durationMs };
-    this._steps.push(step);
-    return this;
-  }
-  suspend(opts) {
-    this.assertNotCommitted();
-    const id = opts?.id ?? `suspend_${this._steps.length}`;
-    validateStepId(id);
-    const step = {
-      kind: "suspend",
-      id,
-      ...opts?.payloadSchema !== void 0 ? { payloadSchema: opts.payloadSchema } : {}
-    };
-    this._steps.push(step);
-    return this;
-  }
-  commit() {
-    this.assertNotCommitted();
-    this.validateUniqueIds();
-    this._committed = true;
-    const workflowId = `wf-${mintShortId()}`;
-    return new Workflow({ ...this.options, workflowId }, [...this._steps]);
-  }
-  validateUniqueIds() {
-    const seen = /* @__PURE__ */ new Set();
-    walkStepsValidating(this._steps, seen);
-  }
-  assertNotCommitted() {
-    if (this._committed) {
-      throw new Error("Workflow already committed; create a fresh Workflow.create(...) call.");
-    }
-  }
-};
-var Workflow = class {
-  /** @internal */
-  constructor(_options, _steps) {
-    this._options = _options;
-    this._steps = _steps;
-  }
-  _options;
-  _steps;
-  /** @internal — only the executor reads these. */
-  get __options() {
-    return this._options;
-  }
-  /** @internal */
-  get __steps() {
-    return this._steps;
-  }
-  /**
-   * Construct a workflow builder. Validate options via Zod and return a
-   * `WorkflowBuilder` for fluent chaining. Call `.commit()` to obtain the
-   * immutable `Workflow`.
-   */
-  static create(options) {
-    WorkflowOptionsSchema.parse(options);
-    return new WorkflowBuilder(options);
-  }
-  /**
-   * Run this workflow with the given input. Returns a populated
-   * `WorkflowRun`. Errors inside a step DO NOT throw — they propagate via
-   * `run.status === "failed"`.
-   */
-  async run(input, opts) {
-    const { executeWorkflow: executeWorkflow2 } = await Promise.resolve().then(() => (init_executor(), executor_exports));
-    const result = await executeWorkflow2(this._options, this._steps, input, opts);
-    if (opts?.task !== void 0) {
-      const { submit: taskSubmit } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-      const taskOpts = opts.task === true ? {} : opts.task;
-      const id = taskOpts.id ?? `wf-${result.id}`;
-      await taskSubmit({
-        kind: "workflow",
-        work: async (ctx) => {
-          ctx.emit({ status: result.status, runId: result.id });
-          return { status: result.status, runId: result.id, output: result.output };
-        },
-        id,
-        meta: {
-          workflowName: this._options.name,
-          runId: result.id,
-          status: result.status,
-          ...taskOpts.meta ?? {}
-        },
-        allowReservedPrefix: true
-      });
-    }
-    return result;
-  }
-  /**
-   * SE28 — run the workflow and STREAM step-level events as they happen. Returns
-   * an async iterator of {@link WorkflowEvent}s (`step_started` / `step_completed`
-   * / `step_failed` / `workflow_suspended` / `workflow_completed`, top-level
-   * steps) plus a `result` promise resolving to the same terminal
-   * {@link WorkflowRun} `run()` returns. Iterate for progress; await `result` for
-   * the outcome. The stream ends when the run terminates.
-   *
-   * `result` is the AUTHORITATIVE terminal status. Not every terminal state has a
-   * closing event: a step failure emits `step_failed`, but an `outputSchema`
-   * rejection (SE27) or an abort ends the stream WITHOUT `workflow_completed` —
-   * always `await result` to read the final `status`. Consuming order is free:
-   * awaiting `result` without draining, or draining without awaiting `result`,
-   * both work (breaking out of `for await` stops the buffering early).
-   */
-  stream(input, opts) {
-    const queue = createEventStream();
-    const result = (async () => {
-      const { executeWorkflow: executeWorkflow2 } = await Promise.resolve().then(() => (init_executor(), executor_exports));
-      try {
-        return await executeWorkflow2(this._options, this._steps, input, {
-          ...opts,
-          onStepEvent: (event) => queue.push(event)
-        });
-      } finally {
-        queue.end();
-      }
-    })();
-    return Object.assign(queue, { result });
-  }
-  /**
-   * Resume a suspended workflow from its snapshot. Throws
-   * `WorkflowSnapshotNotFoundError` if `runId` is unknown.
-   */
-  static async resume(opts) {
-    const { resumeWorkflow: resumeWorkflow2 } = await Promise.resolve().then(() => (init_executor(), executor_exports));
-    return resumeWorkflow2(opts);
-  }
-};
-function fn(id, step, opts) {
-  validateStepId(id);
-  if (opts?.retry !== void 0) RetryPolicySchema.parse(opts.retry);
-  return {
-    kind: "fn",
-    id,
-    fn: step,
-    ...opts?.inputSchema !== void 0 ? { inputSchema: opts.inputSchema } : {},
-    ...opts?.outputSchema !== void 0 ? { outputSchema: opts.outputSchema } : {},
-    ...opts?.retry !== void 0 ? { retry: opts.retry } : {}
-  };
-}
-function agentStep(id, agent, promptTemplate, opts) {
-  validateStepId(id);
-  if (opts?.retry !== void 0) RetryPolicySchema.parse(opts.retry);
-  return {
-    kind: "agent",
-    id,
-    agent,
-    promptTemplate,
-    ...opts?.retry !== void 0 ? { retry: opts.retry } : {},
-    // SE3 — carry the turn's provenance down to `agent.send()` (metadata-only).
-    ...opts?.origin !== void 0 ? { origin: opts.origin } : {}
-  };
-}
-function workflowStep(child, opts) {
-  const id = opts?.id ?? `workflow_${child.__options.name}`;
-  validateStepId(id);
-  return {
-    kind: "fn",
-    id,
-    fn: async (input, ctx) => {
-      const run = await child.run(input, { signal: ctx.signal });
-      if (run.status === "completed") return run.output;
-      throw new WorkflowNestedError(id, child.__options.name, run.status, run.error);
-    }
-  };
-}
-function cloneWorkflow(wf, opts) {
-  return new Workflow(
-    { ...wf.__options, name: opts.id, workflowId: `wf-${mintShortId()}` },
-    [...wf.__steps]
-  );
-}
-var WorkflowToolError = class extends Error {
-  constructor(toolName, workflowStatus, workflowError) {
-    super(
-      `workflowAsTool("${toolName}"): workflow ${workflowStatus}${workflowError ? `: ${workflowError.message}` : ""}`
-    );
-    this.toolName = toolName;
-    this.workflowStatus = workflowStatus;
-    this.workflowError = workflowError;
-    this.name = "WorkflowToolError";
-  }
-  toolName;
-  workflowStatus;
-  workflowError;
-  code = "workflow_tool_failed";
-};
-function workflowAsTool(workflow, spec) {
-  const inputSchema = toJsonSchema(spec.inputSchema, { unrepresentable: "any" });
-  return {
-    name: spec.name,
-    description: spec.description,
-    inputSchema,
-    handler: async (rawInput) => {
-      const parsed = spec.inputSchema.parse(rawInput);
-      const run = await workflow.run(parsed);
-      if (run.status !== "completed") {
-        throw new WorkflowToolError(spec.name, run.status, run.error);
-      }
-      const output = run.output;
-      return typeof output === "string" ? output : JSON.stringify(output ?? null);
-    }
-  };
-}
-function validateStepId(id) {
-  sanitizeIdentifier(id, { maxLen: 64 });
-}
-function mintShortId() {
-  return globalThis.crypto.randomUUID().replace(/-/g, "").slice(0, 8);
-}
-function nestedStepsOf(s) {
-  if (s.kind === "parallel") return s.branches;
-  if (s.kind === "branch") {
-    const groups = s.predicates.map(([, branch]) => branch);
-    return s.fallback !== void 0 ? [...groups, s.fallback] : groups;
-  }
-  if (s.kind === "foreach" || s.kind === "dowhile") return [[s.step]];
-  return [];
-}
-function walkStepsValidating(steps, seen) {
-  for (const s of steps) {
-    if (seen.has(s.id)) throw new WorkflowDuplicateStepIdError(s.id);
-    seen.add(s.id);
-    for (const nested of nestedStepsOf(s)) {
-      walkStepsValidating(nested, seen);
-    }
-  }
-}
-
-export { Workflow, WorkflowAlreadyRunningError, WorkflowBuilder, WorkflowCompensateNotImplementedError, WorkflowDuplicateStepIdError, WorkflowInputError, WorkflowMaxIterationsExceededError, WorkflowNestedError, WorkflowNotSerializableError, WorkflowOutputError, WorkflowParallelError, WorkflowResumeStepNotFoundError, WorkflowSnapshotNotFoundError, WorkflowStateError, WorkflowToolError, __resetSnapshotStoresForTests, agentStep, cloneWorkflow, fn, workflowAsTool, workflowStep };
+export { Workflow, WorkflowBuilder, WorkflowToolError, agentStep, cloneWorkflow, fn, workflowAsTool, workflowStep } from './chunk-BFWPZMG7.js';
+export { WorkflowAlreadyRunningError, WorkflowCompensateNotImplementedError, WorkflowDuplicateStepIdError, WorkflowInputError, WorkflowMaxIterationsExceededError, WorkflowNestedError, WorkflowNotSerializableError, WorkflowOutputError, WorkflowParallelError, WorkflowResumeStepNotFoundError, WorkflowSnapshotNotFoundError, WorkflowStateError, __resetSnapshotStoresForTests } from './chunk-UVNG67DG.js';
+import './chunk-CAH3G4IS.js';
+import './chunk-4VPXM6UU.js';
+import './chunk-POQT2OIF.js';
+import './chunk-S2BBRVQX.js';
+import './chunk-WLKFWQSJ.js';
+import './chunk-JTFYYKDT.js';
 //# sourceMappingURL=workflow.js.map
 //# sourceMappingURL=workflow.js.map