gencow 0.1.250 → 0.1.251

package/core/index.js

@@ -2085,6 +2085,7 @@ function getJobAdmissionStatus(code) {
       return 503;
     case "job_rate_limited":
     case "job_backlog_limit_exceeded":
+    case "workflow_parked_capacity_exceeded":
     case "job_queue_depth_limit_exceeded":
       return 429;
   }
@@ -2146,11 +2147,69 @@ function isJobAdmissionKillSwitchActive(env, scope) {
 }
 
 // ../core/src/workflow.ts
-import { sql as sql3 } from "drizzle-orm";
+import { sql as sql5 } from "drizzle-orm";
 
-// ../core/src/workflow-admission.ts
+// ../core/src/workflow-v2-start-schema.ts
 import { sql } from "drizzle-orm";
+function rows(result) {
+  if (Array.isArray(result)) return result;
+  const nested = result?.rows;
+  return Array.isArray(nested) ? nested : [];
+}
+function numberFrom(value) {
+  const parsed = Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+async function hasWorkflowV2StartSchema(db) {
+  const runColumns = [
+    "id",
+    "workflow_name",
+    "workflow_version",
+    "args_json",
+    "user_id",
+    "max_active_duration_ms",
+    "lifecycle_deadline_at",
+    "retry_count",
+    "max_retries",
+    "max_attempts",
+    "command_protocol",
+    // tryInsertWorkflowV2Run writes it on every start, so the capability must prove it exists.
+    "idempotency_key"
+  ];
+  const outboxColumns = ["id", "run_id", "kind", "available_at", "status"];
+  const runColumnList = sql.join(
+    runColumns.map((column) => sql`${column}`),
+    sql`, `
+  );
+  const outboxColumnList = sql.join(
+    outboxColumns.map((column) => sql`${column}`),
+    sql`, `
+  );
+  const result = await db.execute(sql`
+    SELECT
+      (
+        SELECT COUNT(*)::int
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = '_gencow_workflow_runs_v2'
+          AND column_name IN (${runColumnList})
+      ) AS run_column_count,
+      (
+        SELECT COUNT(*)::int
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = '_gencow_workflow_outbox_v2'
+          AND column_name IN (${outboxColumnList})
+      ) AS outbox_column_count
+  `);
+  const row = rows(result)[0];
+  return numberFrom(row?.run_column_count) === runColumns.length && numberFrom(row?.outbox_column_count) === outboxColumns.length;
+}
+
+// ../core/src/workflow-admission.ts
+import { sql as sql2 } from "drizzle-orm";
 var DEFAULT_WORKFLOW_PENDING_PER_APP = 1e3;
+var DEFAULT_WORKFLOW_PARKED_PER_APP = 1e4;
 var DEFAULT_WORKFLOW_RUNNING_PER_APP = 50;
 var DEFAULT_WORKFLOW_PENDING_PER_NAME = 300;
 var DEFAULT_WORKFLOW_STARTS_PER_MINUTE_PER_APP = 120;
@@ -2161,6 +2220,7 @@ var WORKFLOW_ADMISSION_ENV_KEYS = [
   "GENCOW_JOB_KILL_SWITCH",
   "GENCOW_PLATFORM_JOB_KILL_SWITCH",
   "GENCOW_WORKFLOW_PENDING_PER_APP",
+  "GENCOW_WORKFLOW_PARKED_PER_APP",
   "GENCOW_WORKFLOW_RUNNING_PER_APP",
   "GENCOW_WORKFLOW_PENDING_PER_NAME",
   "GENCOW_WORKFLOW_STARTS_PER_MINUTE_PER_APP",
@@ -2170,14 +2230,14 @@ var WORKFLOW_ADMISSION_ENV_KEYS = [
   "GENCOW_JOB_CREATES_PER_MINUTE_PER_APP",
   "GENCOW_JOB_PAYLOAD_MAX_BYTES"
 ];
-function rows(result) {
+function rows2(result) {
   if (Array.isArray(result)) return result;
   if (result && typeof result === "object" && Array.isArray(result.rows)) {
     return result.rows;
   }
   return [];
 }
-function numberFrom(value) {
+function numberFrom2(value) {
   const parsed = Number(value ?? 0);
   return Number.isFinite(parsed) ? parsed : 0;
 }
@@ -2203,6 +2263,7 @@ function isWorkflowAdmissionEnabled(env) {
 function resolveWorkflowAdmissionPolicy(env) {
   return {
     pendingPerApp: readPositiveIntegerEnv(env, "GENCOW_WORKFLOW_PENDING_PER_APP") ?? readPositiveIntegerEnv(env, "GENCOW_JOB_PENDING_PER_APP") ?? DEFAULT_WORKFLOW_PENDING_PER_APP,
+    parkedPerApp: readPositiveIntegerEnv(env, "GENCOW_WORKFLOW_PARKED_PER_APP") ?? DEFAULT_WORKFLOW_PARKED_PER_APP,
     runningPerApp: readPositiveIntegerEnv(env, "GENCOW_WORKFLOW_RUNNING_PER_APP") ?? DEFAULT_WORKFLOW_RUNNING_PER_APP,
     pendingPerName: readPositiveIntegerEnv(env, "GENCOW_WORKFLOW_PENDING_PER_NAME") ?? DEFAULT_WORKFLOW_PENDING_PER_NAME,
     startsPerMinutePerApp: readPositiveIntegerEnv(env, "GENCOW_WORKFLOW_STARTS_PER_MINUTE_PER_APP") ?? readPositiveIntegerEnv(env, "GENCOW_JOB_CREATES_PER_MINUTE_PER_APP") ?? DEFAULT_WORKFLOW_STARTS_PER_MINUTE_PER_APP,
@@ -2211,33 +2272,37 @@ function resolveWorkflowAdmissionPolicy(env) {
   };
 }
 async function countWorkflowV2Backlog(db, workflowName) {
-  const result = await db.execute(sql`
+  const result = await db.execute(sql2`
     SELECT
-      COALESCE(SUM(CASE WHEN completed_at IS NULL AND status IN ('queued', 'waiting', 'sleeping') THEN 1 ELSE 0 END), 0)::int AS pending,
-      COALESCE(SUM(CASE WHEN completed_at IS NULL AND status = 'running' THEN 1 ELSE 0 END), 0)::int AS running,
-      COALESCE(SUM(CASE WHEN completed_at IS NULL AND status IN ('queued', 'waiting', 'sleeping') AND workflow_name = ${workflowName} THEN 1 ELSE 0 END), 0)::int AS pending_by_name
+      COALESCE(SUM(CASE WHEN status IN ('queued', 'running') THEN 1 ELSE 0 END), 0)::int AS pending,
+      COALESCE(SUM(CASE WHEN status IN ('waiting', 'sleeping') THEN 1 ELSE 0 END), 0)::int AS parked,
+      COALESCE(SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END), 0)::int AS running,
+      COALESCE(SUM(CASE WHEN status IN ('queued', 'running') AND workflow_name = ${workflowName} THEN 1 ELSE 0 END), 0)::int AS pending_by_name
     FROM _gencow_workflow_runs_v2
+    WHERE completed_at IS NULL
   `);
-  const row = rows(result)[0];
+  const row = rows2(result)[0];
   return {
-    pending: numberFrom(row?.pending),
-    running: numberFrom(row?.running),
-    pendingByName: numberFrom(row?.pending_by_name)
+    pending: numberFrom2(row?.pending),
+    parked: numberFrom2(row?.parked),
+    running: numberFrom2(row?.running),
+    pendingByName: numberFrom2(row?.pending_by_name)
   };
 }
 async function countWorkflowV1Backlog(db, workflowName) {
-  const result = await db.execute(sql`
+  const result = await db.execute(sql2`
     SELECT
       COALESCE(SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END), 0)::int AS pending,
       COALESCE(SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END), 0)::int AS running,
       COALESCE(SUM(CASE WHEN status = 'pending' AND name = ${workflowName} THEN 1 ELSE 0 END), 0)::int AS pending_by_name
     FROM _gencow_workflows
   `);
-  const row = rows(result)[0];
+  const row = rows2(result)[0];
   return {
-    pending: numberFrom(row?.pending),
-    running: numberFrom(row?.running),
-    pendingByName: numberFrom(row?.pending_by_name)
+    pending: numberFrom2(row?.pending),
+    parked: 0,
+    running: numberFrom2(row?.running),
+    pendingByName: numberFrom2(row?.pending_by_name)
   };
 }
 async function countWorkflowBacklog(db, workflowName, requireV2 = false) {
@@ -2250,7 +2315,7 @@ async function countWorkflowBacklog(db, workflowName, requireV2 = false) {
 }
 async function consumeWorkflowRateBucket(db, scope, limit, now) {
   try {
-    const result = await db.execute(sql`
+    const result = await db.execute(sql2`
       INSERT INTO _gencow_job_admission_buckets (scope, bucket_start, count, updated_at)
       VALUES (${scope}, date_trunc('minute', ${now.toISOString()}::timestamptz), 1, NOW())
       ON CONFLICT (scope, bucket_start) DO UPDATE
@@ -2259,7 +2324,7 @@ async function consumeWorkflowRateBucket(db, scope, limit, now) {
         WHERE _gencow_job_admission_buckets.count < ${limit}
       RETURNING count
     `);
-    return rows(result).length > 0;
+    return rows2(result).length > 0;
   } catch (error) {
     if (!isMissingAdmissionSchemaError(error)) throw error;
     throw new JobAdmissionError(
@@ -2269,7 +2334,7 @@ async function consumeWorkflowRateBucket(db, scope, limit, now) {
   }
 }
 async function acquireWorkflowStartAdmissionLock(db) {
-  await db.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended('workflow:create', 0))`);
+  await db.execute(sql2`SELECT pg_advisory_xact_lock(hashtextextended('workflow:create', 0))`);
 }
 async function applyWorkflowStartAdmission(options) {
   const env = options.env ?? (typeof process === "undefined" ? {} : process.env);
@@ -2291,6 +2356,23 @@ async function applyWorkflowStartAdmission(options) {
       details: { limit: policy.pendingPerApp, pending: counts.pending }
     });
   }
+  if (counts.parked >= policy.parkedPerApp) {
+    throw new JobAdmissionError(
+      "workflow_parked_capacity_exceeded",
+      "workflow sleeping/waiting limit exceeded",
+      {
+        details: {
+          limit: policy.parkedPerApp,
+          parked: counts.parked,
+          stage: "admission",
+          stateChanged: false,
+          retryable: true,
+          retryCondition: "Retry after sleeping or waiting runs complete, are signalled, or are cancelled.",
+          nextAction: "Cancel or signal parked runs, or raise GENCOW_WORKFLOW_PARKED_PER_APP; no workflow was started."
+        }
+      }
+    );
+  }
   if (counts.running >= policy.runningPerApp) {
     throw new JobAdmissionError("job_backlog_limit_exceeded", "workflow running backlog limit exceeded", {
       details: { limit: policy.runningPerApp, running: counts.running }
@@ -2343,10 +2425,83 @@ async function runWorkflowAdmissionCriticalSection(db, callback) {
 }
 
 // ../core/src/workflow-json.ts
-import { sql as sql2 } from "drizzle-orm";
+import { sql as sql3 } from "drizzle-orm";
 function workflowJsonb(value) {
   const json = JSON.stringify(value ?? {});
-  return sql2`${json}::text::jsonb`;
+  return sql3`${json}::text::jsonb`;
+}
+
+// ../core/src/workflow-idempotent-start.ts
+import { sql as sql4 } from "drizzle-orm";
+var MAX_IDEMPOTENCY_KEY_LENGTH = 200;
+function normalizeWorkflowIdempotencyKey(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value !== "string") {
+    throw new GencowValidationError(`Workflow idempotencyKey: expected a string or null`);
+  }
+  if (value.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
+    throw new GencowValidationError(
+      `Workflow idempotencyKey: at most ${MAX_IDEMPOTENCY_KEY_LENGTH} characters`
+    );
+  }
+  return value;
+}
+function rows3(result) {
+  if (Array.isArray(result)) return result;
+  const nested = result?.rows;
+  return Array.isArray(nested) ? nested : [];
+}
+async function hashWorkflowIdempotencyKey(db, workflowName, userId, key) {
+  const hashed = rows3(
+    await db.execute(sql4`
+      SELECT encode(sha256(convert_to(
+        ${workflowName} || chr(31) || ${userId ?? "anon"} || chr(31) || ${key},
+        'UTF8')), 'hex') AS key_hash
+    `)
+  );
+  return String(hashed[0]?.key_hash ?? "");
+}
+function deduplicatedWorkflowStart(workflowName, existing) {
+  return {
+    id: existing.id,
+    name: workflowName,
+    status: existing.status === "running" ? "running" : "pending",
+    scheduledJobId: `start:${existing.id}`,
+    deduplicated: true
+  };
+}
+function isWorkflowIdempotencyConflict(error) {
+  const source = error?.cause ?? error;
+  const { code, constraint, message } = source ?? {};
+  return code === "23505" && `${constraint ?? ""} ${message ?? ""}`.includes("idempotency");
+}
+async function findLiveWorkflowIdempotentRun(options) {
+  const keyHash = await hashWorkflowIdempotencyKey(options.db, options.workflowName, options.userId, options.key);
+  const found = rows3(
+    await options.db.execute(sql4`
+      SELECT id, status FROM _gencow_workflow_runs_v2
+      WHERE idempotency_key = ${keyHash} AND completed_at IS NULL AND cancel_requested_at IS NULL LIMIT 1
+    `)
+  )[0];
+  return found ? { id: String(found.id), status: String(found.status) } : null;
+}
+async function lookupWorkflowIdempotentStart(options) {
+  const keyHash = await hashWorkflowIdempotencyKey(options.db, options.workflowName, options.userId, options.key);
+  await options.db.execute(sql4`SELECT pg_advisory_xact_lock(hashtextextended(${keyHash}, 0))`);
+  await options.db.execute(sql4`
+    UPDATE _gencow_workflow_runs_v2
+    SET idempotency_key = NULL
+    WHERE idempotency_key = ${keyHash} AND (completed_at IS NOT NULL OR cancel_requested_at IS NOT NULL)
+  `);
+  const found = rows3(
+    await options.db.execute(sql4`
+      SELECT id, status FROM _gencow_workflow_runs_v2 WHERE idempotency_key = ${keyHash} LIMIT 1
+    `)
+  )[0];
+  return {
+    keyHash,
+    existing: found ? { id: String(found.id), status: String(found.status) } : null
+  };
 }
 
 // ../core/src/workflow-wake-signal.ts
@@ -2505,63 +2660,15 @@ function isMissingWorkflowV2SchemaError2(error) {
   const message = error instanceof Error ? error.message : String(error);
   return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('column "max_active_duration_ms"') || message.includes('column "retry_count"') || message.includes('column "user_id"');
 }
-function rows2(result) {
-  if (Array.isArray(result)) return result;
-  if (result && typeof result === "object" && Array.isArray(result.rows)) {
-    return result.rows;
-  }
-  return [];
-}
-function numberFrom2(value) {
-  const parsed = Number(value ?? 0);
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-async function hasWorkflowV2StartSchema(db) {
-  const runColumns = [
-    "id",
-    "workflow_name",
-    "workflow_version",
-    "args_json",
-    "user_id",
-    "max_active_duration_ms",
-    "lifecycle_deadline_at",
-    "retry_count",
-    "max_retries",
-    "max_attempts"
-  ];
-  const outboxColumns = ["id", "run_id", "kind", "available_at", "status"];
-  const runColumnList = sql3.join(
-    runColumns.map((column) => sql3`${column}`),
-    sql3`, `
-  );
-  const outboxColumnList = sql3.join(
-    outboxColumns.map((column) => sql3`${column}`),
-    sql3`, `
-  );
-  const result = await db.execute(sql3`
-    SELECT
-      (
-        SELECT COUNT(*)::int
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-          AND table_name = '_gencow_workflow_runs_v2'
-          AND column_name IN (${runColumnList})
-      ) AS run_column_count,
-      (
-        SELECT COUNT(*)::int
-        FROM information_schema.columns
-        WHERE table_schema = 'public'
-          AND table_name = '_gencow_workflow_outbox_v2'
-          AND column_name IN (${outboxColumnList})
-      ) AS outbox_column_count
-  `);
-  const row = rows2(result)[0];
-  return numberFrom2(row?.run_column_count) === runColumns.length && numberFrom2(row?.outbox_column_count) === outboxColumns.length;
+var COMMAND_PROTOCOL_1_WORKFLOW_NAMES = /* @__PURE__ */ new Set(["__gencow.documents.ingest.run"]);
+function defaultWorkflowCommandProtocol(workflowName, env = typeof process !== "undefined" ? process.env : {}) {
+  if (COMMAND_PROTOCOL_1_WORKFLOW_NAMES.has(workflowName)) return 1;
+  return env.GENCOW_WORKFLOW_COMMAND_PROTOCOL_DEFAULT === "1" ? 1 : 2;
 }
 async function tryInsertWorkflowV2Run(options) {
   try {
     if (!await hasWorkflowV2StartSchema(options.db)) return false;
-    await options.db.execute(sql3`
+    await options.db.execute(sql5`
       WITH inserted_run AS (
         INSERT INTO _gencow_workflow_runs_v2 (
           id,
@@ -2573,7 +2680,9 @@ async function tryInsertWorkflowV2Run(options) {
           lifecycle_deadline_at,
           retry_count,
           max_retries,
-          max_attempts
+          max_attempts,
+          command_protocol,
+          idempotency_key
         )
         VALUES (
           ${options.workflowId},
@@ -2588,7 +2697,9 @@ async function tryInsertWorkflowV2Run(options) {
           END,
           0,
           ${options.maxRetries},
-          ${options.maxRetries + 1}
+          ${options.maxRetries + 1},
+          ${options.commandProtocol ?? defaultWorkflowCommandProtocol(options.workflowName)},
+          ${options.idempotencyKeyHash ?? null}
         )
         RETURNING id
       ),
@@ -2626,7 +2737,7 @@ async function tryInsertWorkflowV2Run(options) {
 }
 async function tryDeleteWorkflowV2Run(db, workflowId) {
   try {
-    await db.execute(sql3`
+    await db.execute(sql5`
       DELETE FROM _gencow_workflow_runs_v2
       WHERE id = ${workflowId}
     `);
@@ -2683,16 +2794,37 @@ function composeWorkflowStartMiddleware(options) {
     return await run(0, initialContext, initialInput);
   };
 }
-async function startWorkflowRun(ctx, args, def) {
+async function startWorkflowRun(ctx, args, def, conflictRetries = 2) {
   const workflowId = crypto.randomUUID();
   const resumeAction = getWorkflowResumeActionName(def.name);
   const ownerId = ctx.auth.getUserIdentity()?.id ?? null;
   const persistedArgs = serializeWorkflowValue(args ?? {});
   assertWorkflowPayloadWithinLimit({ workflowName: def.name, kind: "args", serializedValue: persistedArgs });
   const realtimeToken = createWorkflowRealtimeToken();
+  const idempotencyKey = ownerId ? normalizeWorkflowIdempotencyKey(def.idempotencyKey?.(args, ctx)) : null;
   let insertedWorkflowV2 = false;
+  let deduplicated = null;
   try {
     await runWorkflowAdmissionCriticalSection(ctx.unsafeDb, async (db) => {
+      let idempotencyKeyHash = null;
+      if (idempotencyKey !== null) {
+        if (!await hasWorkflowV2StartSchema(db)) {
+          throw new GencowValidationError(
+            `Workflow ${def.name}: idempotencyKey needs the Workflow V2 tables. Redeploy so the app schema is upgraded, then start again.`
+          );
+        }
+        const lookup = await lookupWorkflowIdempotentStart({
+          db,
+          workflowName: def.name,
+          userId: ownerId,
+          key: idempotencyKey
+        });
+        if (lookup.existing) {
+          deduplicated = deduplicatedWorkflowStart(def.name, lookup.existing);
+          return;
+        }
+        idempotencyKeyHash = lookup.keyHash;
+      }
       await applyWorkflowStartAdmission({ db, workflowName: def.name, args: persistedArgs });
       insertedWorkflowV2 = await tryInsertWorkflowV2Run({
         db,
@@ -2703,10 +2835,11 @@ async function startWorkflowRun(ctx, args, def) {
         userId: ownerId,
         maxActiveDurationMs: def.maxActiveDurationMs,
         lifecycleTimeoutMs: def.lifecycleTimeoutMs,
-        maxRetries: def.maxRetries
+        maxRetries: def.maxRetries,
+        idempotencyKeyHash
       });
       const legacyArgs = insertedWorkflowV2 ? serializeWorkflowValue(void 0) : persistedArgs;
-      await db.execute(sql3`
+      await db.execute(sql5`
         INSERT INTO _gencow_workflows (
           id, name, args, realtime_token, status, retry_count, max_retries, max_duration_ms, user_id
         ) VALUES (
@@ -2715,6 +2848,7 @@ async function startWorkflowRun(ctx, args, def) {
         )
       `);
     });
+    if (deduplicated) return deduplicated;
     return {
       id: workflowId,
       name: def.name,
@@ -2722,8 +2856,18 @@ async function startWorkflowRun(ctx, args, def) {
       scheduledJobId: insertedWorkflowV2 ? `start:${workflowId}` : ctx.scheduler.runAfter(0, resumeAction, { workflowId })
     };
   } catch (error) {
-    await ctx.unsafeDb.execute(sql3`DELETE FROM _gencow_workflows WHERE id = ${workflowId}`);
+    await ctx.unsafeDb.execute(sql5`DELETE FROM _gencow_workflows WHERE id = ${workflowId}`);
     if (insertedWorkflowV2) await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
+    if (idempotencyKey !== null && isWorkflowIdempotencyConflict(error)) {
+      const winner = await findLiveWorkflowIdempotentRun({
+        db: ctx.unsafeDb,
+        workflowName: def.name,
+        userId: ownerId,
+        key: idempotencyKey
+      });
+      if (winner) return deduplicatedWorkflowStart(def.name, winner);
+      if (conflictRetries > 0) return startWorkflowRun(ctx, args, def, conflictRetries - 1);
+    }
     throw error;
   }
 }
@@ -2810,7 +2954,7 @@ function workflow(name, options) {
   return metadata.legacyStart;
 }
 var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
-  constructor(workflowName, middlewares = [], inputSchema, inputValidationIndex = -1, anonymousAllowed = false, workflowVersion, maxDurationValue, lifecycleTimeoutValue, concurrencyValue, retriesValue) {
+  constructor(workflowName, middlewares = [], inputSchema, inputValidationIndex = -1, anonymousAllowed = false, workflowVersion, maxDurationValue, lifecycleTimeoutValue, concurrencyValue, retriesValue, idempotencyKeyValue) {
     this.workflowName = workflowName;
     this.middlewares = middlewares;
     this.inputSchema = inputSchema;
@@ -2821,6 +2965,7 @@ var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
     this.lifecycleTimeoutValue = lifecycleTimeoutValue;
     this.concurrencyValue = concurrencyValue;
     this.retriesValue = retriesValue;
+    this.idempotencyKeyValue = idempotencyKeyValue;
   }
   workflowName;
   middlewares;
@@ -2832,6 +2977,7 @@ var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
   lifecycleTimeoutValue;
   concurrencyValue;
   retriesValue;
+  idempotencyKeyValue;
   copy(changes = {}) {
     return new _GencowWorkflowBuilderImpl(
       changes.workflowName ?? this.workflowName,
@@ -2843,7 +2989,8 @@ var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
       changes.maxDurationValue ?? this.maxDurationValue,
       changes.lifecycleTimeoutValue ?? this.lifecycleTimeoutValue,
       changes.concurrencyValue ?? this.concurrencyValue,
-      changes.retriesValue ?? this.retriesValue
+      changes.retriesValue ?? this.retriesValue,
+      changes.idempotencyKeyValue ?? this.idempotencyKeyValue
     );
   }
   name(name) {
@@ -2876,6 +3023,9 @@ var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
   retries(count) {
     return this.copy({ retriesValue: count });
   }
+  idempotencyKey(derive) {
+    return this.copy({ idempotencyKeyValue: derive });
+  }
   handler(handler) {
     if (!this.workflowName)
       throw new Error("Workflow name is required. Call .name(...) before .handler(...)");
@@ -2893,6 +3043,7 @@ var GencowWorkflowBuilderImpl = class _GencowWorkflowBuilderImpl {
       ),
       concurrency: normalizeConcurrency(this.concurrencyValue),
       maxRetries: clampRetries(this.retriesValue),
+      idempotencyKey: this.idempotencyKeyValue,
       handler
     };
     return createWorkflowMetadata({
@@ -2920,8 +3071,254 @@ function deriveWorkflowStatus(status, currentStep) {
   return "queued";
 }
 
+// ../core/src/workflow-errors.ts
+var WORKFLOW_STEP_FAILED_CODE = "workflow_step_failed";
+var WORKFLOW_WAIT_TIMEOUT_CODE = "workflow_wait_timeout";
+var WorkflowStepFailedError = class extends Error {
+  constructor(stepName, attempt, message, branchIndex) {
+    super(message);
+    this.stepName = stepName;
+    this.attempt = attempt;
+    this.branchIndex = branchIndex;
+    this.name = "WorkflowStepFailedError";
+  }
+  stepName;
+  attempt;
+  branchIndex;
+  code = WORKFLOW_STEP_FAILED_CODE;
+};
+var WorkflowWaitTimeoutError = class extends Error {
+  constructor(event) {
+    super(`waitForEvent("${event}") timed out`);
+    this.event = event;
+    this.name = "WorkflowWaitTimeoutError";
+  }
+  event;
+  code = WORKFLOW_WAIT_TIMEOUT_CODE;
+};
+var WorkflowNonRetryableError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "WorkflowNonRetryableError";
+  }
+};
+var WORKFLOW_STEP_TIMEOUT_CODE = "workflow_step_timeout";
+var WORKFLOW_STEP_OPTIONS_INVALID_CODE = "workflow_step_options_invalid";
+var WorkflowStepTimeoutError = class extends Error {
+  constructor(stepName, timeoutMs) {
+    super(`workflow step "${stepName}" timed out after ${timeoutMs}ms`);
+    this.stepName = stepName;
+    this.timeoutMs = timeoutMs;
+    this.name = "WorkflowStepTimeoutError";
+  }
+  stepName;
+  timeoutMs;
+  code = WORKFLOW_STEP_TIMEOUT_CODE;
+};
+var WorkflowStepOptionsError = class extends Error {
+  code = WORKFLOW_STEP_OPTIONS_INVALID_CODE;
+  constructor(stepName, reason) {
+    super(`wf.step(${JSON.stringify(stepName)}) options: ${reason}`);
+    this.name = "WorkflowStepOptionsError";
+  }
+};
+var WorkflowNestedCommandError = class extends Error {
+  constructor(command) {
+    super(
+      `wf.${command}() cannot be called inside a step or parallel branch. Call it from the workflow handler itself; a step body is plain code.`
+    );
+    this.name = "WorkflowNestedCommandError";
+  }
+};
+var WorkflowCommandNameError = class extends Error {
+  constructor(command, name, reason) {
+    super(`wf.${command}(${JSON.stringify(name)}): ${reason}`);
+    this.name = "WorkflowCommandNameError";
+  }
+};
+var MAX_COMMAND_NAME_LENGTH = 200;
+function normalizeWorkflowCommandName(command, name, options) {
+  if (typeof name !== "string") {
+    throw new WorkflowCommandNameError(command, String(name), "name must be a string");
+  }
+  const normalized = name.normalize("NFC");
+  if (normalized.length === 0) throw new WorkflowCommandNameError(command, name, "name must not be empty");
+  if (normalized.length > MAX_COMMAND_NAME_LENGTH) {
+    throw new WorkflowCommandNameError(command, name, `name must be at most ${MAX_COMMAND_NAME_LENGTH} characters`);
+  }
+  if (/[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new WorkflowCommandNameError(command, name, "name must not contain control characters");
+  }
+  if (normalized.includes("/")) throw new WorkflowCommandNameError(command, name, 'name must not contain "/"');
+  if (!options?.allowHash && normalized.includes("#")) {
+    throw new WorkflowCommandNameError(command, name, 'name must not contain "#"');
+  }
+  return normalized;
+}
+
+// ../core/src/workflow-step-options.ts
+var MIN_BACKOFF_INITIAL_MS = 100;
+var MAX_BACKOFF_MS = 24 * 60 * 60 * 1e3;
+function validateWorkflowStepOptions(stepName, options) {
+  if (!options) return { timeoutMs: null };
+  const fail = (reason) => {
+    throw new WorkflowStepOptionsError(stepName, reason);
+  };
+  const duration = (value, label) => {
+    try {
+      return parseWorkflowDurationMs(value, label);
+    } catch (error) {
+      return fail(error instanceof Error ? error.message : `${label} is invalid`);
+    }
+  };
+  if (options.retries != null && (!Number.isInteger(options.retries) || options.retries < 0)) {
+    fail("retries must be a non-negative integer");
+  }
+  let timeoutMs = null;
+  if (options.timeout != null) {
+    timeoutMs = duration(options.timeout, "timeout");
+    if (timeoutMs <= 0) fail("timeout must be greater than 0");
+  }
+  const backoff = options.backoff;
+  if (backoff) {
+    if (backoff.initial != null && duration(backoff.initial, "backoff.initial") < MIN_BACKOFF_INITIAL_MS) {
+      fail(`backoff.initial must be at least ${MIN_BACKOFF_INITIAL_MS}ms`);
+    }
+    if (backoff.factor != null && !(backoff.factor >= 1 && backoff.factor <= 10)) {
+      fail("backoff.factor must be between 1 and 10");
+    }
+    if (backoff.max != null && duration(backoff.max, "backoff.max") > MAX_BACKOFF_MS) {
+      fail("backoff.max must be at most 24h");
+    }
+  }
+  return { timeoutMs };
+}
+
 // ../core/src/workflows-api.ts
-import { sql as sql4 } from "drizzle-orm";
+import { sql as sql8 } from "drizzle-orm";
+
+// ../core/src/workflows-signal-record.ts
+import { sql as sql6 } from "drizzle-orm";
+function rowsFromResult(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.rows)) {
+    return result.rows;
+  }
+  return [];
+}
+function isMissingWorkflowV2SignalSchemaError(error) {
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
+  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || (code === "23503" || causeCode === "23503") && message.includes("_gencow_workflow_signals_v2") || message.includes('relation "_gencow_workflow_signals_v2" does not exist') || message.includes("relation _gencow_workflow_signals_v2 does not exist") || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('relation "_gencow_workflow_steps_v2" does not exist') || message.includes("relation _gencow_workflow_steps_v2 does not exist");
+}
+var WAKES_PARKED_WAIT = sql6.raw(`(run.status = 'waiting'
+                AND (run.current_step_key IS NULL
+                  OR starts_with(run.current_step_key, 'wait:' || inserted.event_name || '#'))
+                AND NOT EXISTS (
+                  SELECT 1 FROM _gencow_workflow_timers_v2 expired
+                  WHERE expired.run_id = run.id AND expired.kind = 'wait_timeout'
+                    AND expired.status = 'pending' AND expired.fire_at <= NOW()
+                    AND (
+                      EXISTS (SELECT 1 FROM _gencow_workflow_steps_v2 parked
+                        WHERE parked.run_id = expired.run_id AND parked.step_key = expired.command_key
+                          AND parked.status = 'pending')
+                      OR (run.command_protocol = 1
+                        AND expired.dedupe_key = run.current_step_key || ':timeout')
+                    )))`);
+async function tryRecordWorkflowV2Signal(options) {
+  const eventName = options.event.normalize("NFC");
+  try {
+    const result = await options.db.execute(sql6`
+      WITH eligible_run AS (
+        SELECT id
+        FROM _gencow_workflow_runs_v2
+        WHERE id = ${options.workflowId}
+          AND status IN ('queued', 'running', 'sleeping', 'waiting')
+          AND completed_at IS NULL
+          AND cancel_requested_at IS NULL
+        FOR UPDATE
+      ), inserted AS (
+        INSERT INTO _gencow_workflow_signals_v2 (
+          id,
+          run_id,
+          event_name,
+          payload_json,
+          idempotency_key
+        )
+        SELECT
+          ${options.signalId},
+          eligible_run.id,
+          ${eventName},
+          ${workflowJsonb(options.payload)},
+          ${options.idempotencyKey ?? options.signalId}
+        FROM eligible_run
+        ON CONFLICT (run_id, event_name, idempotency_key) DO NOTHING
+        RETURNING id, run_id, event_name
+      ),
+      queued_run AS (
+            -- SET expressions run on the newest row version after any concurrent commit. A wait that parks
+            -- while this statement is blocked on the run lock is therefore still woken; a WHERE on status
+            -- would be judged against the statement snapshot and miss it.
+            UPDATE _gencow_workflow_runs_v2 run
+            SET
+                status = CASE WHEN ${WAKES_PARKED_WAIT} THEN 'queued' ELSE run.status END,
+                runnable_at = CASE WHEN ${WAKES_PARKED_WAIT} THEN NOW() ELSE run.runnable_at END,
+                lease_owner = CASE WHEN ${WAKES_PARKED_WAIT} THEN NULL ELSE run.lease_owner END,
+                lease_expires_at = CASE WHEN ${WAKES_PARKED_WAIT} THEN NULL ELSE run.lease_expires_at END,
+                heartbeat_at = CASE WHEN ${WAKES_PARKED_WAIT} THEN NULL ELSE run.heartbeat_at END,
+                updated_at = CASE WHEN ${WAKES_PARKED_WAIT} THEN NOW() ELSE run.updated_at END
+            FROM inserted
+            WHERE run.id = inserted.run_id
+              AND run.completed_at IS NULL
+              AND run.cancel_requested_at IS NULL
+            RETURNING run.id, (run.status = 'queued') AS woken
+        ),
+      wake_outbox AS (
+        INSERT INTO _gencow_workflow_outbox_v2 (
+          id,
+          run_id,
+          kind,
+          available_at,
+          status
+        )
+        SELECT
+          'signal:' || inserted.id,
+          inserted.run_id,
+          'wake_signal',
+          NOW(),
+          'pending'
+        FROM inserted
+        JOIN queued_run ON queued_run.id = inserted.run_id AND queued_run.woken
+        ON CONFLICT (id) DO NOTHING
+        RETURNING id
+      ),
+      wake_notified AS (
+        SELECT pg_notify(${WORKFLOW_WAKE_SIGNAL_CHANNEL}, ${WORKFLOW_WAKE_SIGNAL_PAYLOAD})
+        FROM wake_outbox
+      )
+      SELECT 1
+      FROM inserted
+      LEFT JOIN wake_notified ON TRUE
+    `);
+    if (rowsFromResult(result).length > 0) return "accepted";
+    if (options.idempotencyKey) {
+      const prior = await options.db.execute(sql6`
+        SELECT 1 FROM _gencow_workflow_signals_v2
+        WHERE run_id = ${options.workflowId}
+          AND event_name = ${eventName}
+          AND idempotency_key = ${options.idempotencyKey}
+        LIMIT 1
+      `);
+      if (rowsFromResult(prior).length > 0) return "duplicate";
+    }
+    return "rejected";
+  } catch (error) {
+    if (isMissingWorkflowV2SignalSchemaError(error)) return "absent";
+    throw error;
+  }
+}
 
 // ../core/src/workflow-public-read-model.ts
 function parseJsonField(value) {
@@ -2942,9 +3339,55 @@ function toOptionalIsoString(value) {
   if (typeof value === "number" && !Number.isFinite(value)) return toIsoString(value);
   return value ? toIsoString(value) : null;
 }
+function publicWorkflowErrorCode(code) {
+  if (!code) return null;
+  return code === "active_timeout" ? "workflow_active_timeout" : code;
+}
+function publicV1WorkflowStatus(status, errorCode) {
+  return status === "failed" && errorCode === "cancelled" ? "cancelled" : status;
+}
+var PUBLIC_ERROR_SUMMARIES = {
+  workflow_error: "A workflow step failed.",
+  workflow_step_timeout: "A workflow step exceeded its timeout.",
+  workflow_step_options_invalid: "A workflow step has invalid options.",
+  workflow_active_timeout: "The workflow exceeded its maximum active duration.",
+  workflow_nondeterministic: "The workflow code changed in a way that no longer matches this run's history.",
+  definition_missing: "The workflow definition is not deployed.",
+  cancelled: "The workflow was cancelled."
+};
+var ERROR_DETAIL_MAX_CHARS = 300;
+var SQLSTATE = /^[0-9A-Z]{5}$/;
+function looksLikeDriverFailure(body, message) {
+  return body?.name === "DrizzleQueryError" || (message?.startsWith("Failed query:") ?? false);
+}
+function publicStepError(errorJson) {
+  if (errorJson === null || errorJson === void 0) return null;
+  const body = errorJson && typeof errorJson === "object" ? errorJson : null;
+  const message = typeof errorJson === "string" ? errorJson : body && typeof body.message === "string" ? body.message : null;
+  const driverCode = body && typeof body.code === "string" ? body.code : null;
+  if (driverCode && SQLSTATE.test(driverCode) || looksLikeDriverFailure(body, message)) {
+    return "The step failed.";
+  }
+  return message ? message.slice(0, ERROR_DETAIL_MAX_CHARS) : null;
+}
+function summarizeWorkflowError(rawCode, errorJson) {
+  const errorCode = publicWorkflowErrorCode(rawCode);
+  if (!errorCode && (errorJson === null || errorJson === void 0)) {
+    return { error: null, errorCode: null, errorDetail: null };
+  }
+  const error = errorCode && PUBLIC_ERROR_SUMMARIES[errorCode] || "The workflow failed.";
+  const body = errorJson && typeof errorJson === "object" ? errorJson : null;
+  const message = typeof errorJson === "string" ? errorJson : body && typeof body.message === "string" ? body.message : null;
+  const driverCode = body && typeof body.code === "string" ? body.code : null;
+  const userThrown = errorCode === "workflow_error" && !(driverCode && SQLSTATE.test(driverCode)) && !looksLikeDriverFailure(body, message);
+  return {
+    error,
+    errorCode,
+    errorDetail: userThrown && message ? message.slice(0, ERROR_DETAIL_MAX_CHARS) : null
+  };
+}
 function publicV2Status(status) {
-  if (status === "completed" || status === "failed") return status;
-  if (status === "cancelled") return "failed";
+  if (status === "completed" || status === "failed" || status === "cancelled") return status;
   if (status === "running") return "running";
   return "pending";
 }
@@ -2953,15 +3396,19 @@ function publicV2DerivedStatus(status) {
   return publicV2Status(status);
 }
 function mapV2WorkflowSummary(row) {
-  const error = parseJsonField(row.error_json);
+  const summary = summarizeWorkflowError(
+    row.status === "cancelled" ? "cancelled" : row.error_code,
+    parseJsonField(row.error_json)
+  );
   return {
     id: row.id,
     name: row.workflow_name,
     status: publicV2Status(row.status),
     derivedStatus: publicV2DerivedStatus(row.status),
     currentStep: row.current_step_key,
-    error: typeof error === "string" ? error : error && typeof error === "object" && "message" in error ? String(error.message) : null,
-    errorCode: row.status === "cancelled" ? "cancelled" : row.error_code,
+    error: summary.error,
+    errorCode: summary.errorCode,
+    errorDetail: summary.errorDetail,
     retryCount: row.retry_count,
     maxRetries: row.max_retries,
     maxDurationMs: Number(row.max_active_duration_ms),
@@ -2970,23 +3417,84 @@ function mapV2WorkflowSummary(row) {
     completedAt: toOptionalIsoString(row.completed_at)
   };
 }
+var BRANCH_STEP_KEY = /^parallel#\d+\/b\d+$/;
+function publicV2StepKind(row) {
+  if (row.command_kind === "sleep" || row.command_kind === "wait") return row.command_kind;
+  if (row.command_kind !== "step") return void 0;
+  return BRANCH_STEP_KEY.test(row.step_key) ? "branch" : "step";
+}
 function mapV2WorkflowStep(row) {
   const error = parseJsonField(row.error_json);
   return {
     name: row.step_key,
-    status: row.status === "running" || row.status === "failed" || row.status === "completed" ? row.status : row.status === "skipped" ? "completed" : "pending",
-    output: parseJsonField(row.output_json),
-    error: typeof error === "string" ? error : error && typeof error === "object" && "message" in error ? String(error.message) : null,
+    kind: publicV2StepKind(row),
+    status: row.status === "running" || row.status === "failed" || row.status === "completed" || row.status === "cancelled" ? row.status : row.status === "skipped" ? "completed" : "pending",
+    output: row.output_codec === "envelope" ? deserializeWorkflowValue(parseJsonField(row.output_json)) : parseJsonField(row.output_json),
+    error: publicStepError(error),
     startedAt: toOptionalIsoString(row.started_at),
     updatedAt: toIsoString(row.updated_at),
     completedAt: toOptionalIsoString(row.completed_at)
   };
 }
 
+// ../core/src/workflows-cancel-api.ts
+import { sql as sql7 } from "drizzle-orm";
+function rowsOf(result) {
+  if (Array.isArray(result)) return result;
+  const rows4 = result?.rows;
+  return Array.isArray(rows4) ? rows4 : [];
+}
+function buildWorkflowCancelDefinition() {
+  return {
+    name: "workflows.cancel",
+    argsSchema: { id: v.string() },
+    isPublic: true,
+    handler: async (ctx, args) => {
+      const viewerId = ctx.auth.requireAuth().id;
+      const notFound = { ok: false, workflowId: args.id, status: "not_found" };
+      let run;
+      try {
+        run = rowsOf(
+          await ctx.unsafeDb.execute(
+            sql7`SELECT id, user_id, status, completed_at FROM _gencow_workflow_runs_v2 WHERE id = ${args.id} LIMIT 1`
+          )
+        )[0];
+      } catch (error) {
+        const wrapped = error;
+        if (wrapped?.code !== "42P01" && wrapped?.cause?.code !== "42P01") throw error;
+      }
+      if (!run) {
+        const legacy = await ctx.unsafeDb.execute(sql7`SELECT id, status FROM _gencow_workflows WHERE id = ${args.id} AND user_id = ${viewerId} LIMIT 1`).then((result) => rowsOf(result)[0] ?? null).catch(() => null);
+        if (!legacy) return notFound;
+        const finished = legacy.status === "completed" || legacy.status === "failed";
+        return finished ? { ok: true, workflowId: args.id, status: "already_terminal" } : { ok: false, workflowId: args.id, status: "not_cancellable" };
+      }
+      if (!run.user_id || run.user_id !== viewerId) return notFound;
+      if (run.completed_at !== null || ["completed", "failed", "cancelled"].includes(run.status)) {
+        return { ok: true, workflowId: run.id, status: "already_terminal" };
+      }
+      const updated = rowsOf(
+        await ctx.unsafeDb.execute(sql7`
+          WITH marked AS (
+            UPDATE _gencow_workflow_runs_v2
+               SET cancel_requested_at = COALESCE(cancel_requested_at, NOW()), updated_at = NOW(),
+                   idempotency_key = NULL
+             WHERE id = ${run.id} AND user_id = ${viewerId} AND completed_at IS NULL
+            RETURNING id
+          )
+          SELECT id, pg_notify(${WORKFLOW_WAKE_SIGNAL_CHANNEL}, ${WORKFLOW_WAKE_SIGNAL_PAYLOAD}) FROM marked
+        `)
+      );
+      if (updated.length === 0) return { ok: true, workflowId: run.id, status: "already_terminal" };
+      return { ok: true, workflowId: run.id, status: "cancel_requested" };
+    }
+  };
+}
+
 // ../core/src/workflows-api.ts
-var WORKFLOW_STATUSES = /* @__PURE__ */ new Set(["pending", "running", "completed", "failed"]);
+var WORKFLOW_STATUSES = /* @__PURE__ */ new Set(["pending", "running", "completed", "failed", "cancelled"]);
 var WORKFLOW_DERIVED_PENDING_STATUSES = /* @__PURE__ */ new Set(["queued", "waiting", "sleeping"]);
-function rowsFromResult(result) {
+function rowsFromResult2(result) {
   if (Array.isArray(result)) return result;
   if (result && typeof result === "object" && Array.isArray(result.rows)) {
     return result.rows;
@@ -2997,11 +3505,11 @@ function mapWorkflowSummary(row) {
   return {
     id: row.id,
     name: row.name,
-    status: row.status,
-    derivedStatus: deriveWorkflowStatus(row.status, row.current_step),
+    status: publicV1WorkflowStatus(row.status, row.error_code),
+    derivedStatus: deriveWorkflowStatus(publicV1WorkflowStatus(row.status, row.error_code), row.current_step),
     currentStep: row.current_step,
     error: row.error,
-    errorCode: row.error_code,
+    errorCode: publicWorkflowErrorCode(row.error_code),
     retryCount: row.retry_count,
     maxRetries: row.max_retries,
     maxDurationMs: Number(row.max_duration_ms),
@@ -3065,27 +3573,27 @@ function normalizeDerivedStatus(status) {
 async function ensureWorkflowRealtimeToken(db, workflowId, currentToken) {
   if (currentToken && currentToken.trim() !== "") return currentToken;
   const nextToken = createWorkflowRealtimeToken();
-  const updateResult = await db.execute(sql4`
+  const updateResult = await db.execute(sql8`
         UPDATE _gencow_workflows
         SET realtime_token = ${nextToken}
         WHERE id = ${workflowId}
           AND (realtime_token IS NULL OR realtime_token = '')
         RETURNING realtime_token
     `);
-  const updatedToken = rowsFromResult(updateResult)[0]?.realtime_token ?? null;
+  const updatedToken = rowsFromResult2(updateResult)[0]?.realtime_token ?? null;
   if (updatedToken && updatedToken.trim() !== "") return updatedToken;
-  const rereadResult = await db.execute(sql4`
+  const rereadResult = await db.execute(sql8`
         SELECT realtime_token
         FROM _gencow_workflows
         WHERE id = ${workflowId}
         LIMIT 1
     `);
-  const rereadToken = rowsFromResult(rereadResult)[0]?.realtime_token ?? null;
+  const rereadToken = rowsFromResult2(rereadResult)[0]?.realtime_token ?? null;
   return rereadToken && rereadToken.trim() !== "" ? rereadToken : null;
 }
 async function loadWorkflowSignalTarget(db, workflowId) {
   try {
-    const result = await db.execute(sql4`
+    const result = await db.execute(sql8`
         SELECT
             id,
             name,
@@ -3096,19 +3604,12 @@ async function loadWorkflowSignalTarget(db, workflowId) {
         WHERE id = ${workflowId}
         LIMIT 1
     `);
-    return rowsFromResult(result)[0] ?? null;
+    return rowsFromResult2(result)[0] ?? null;
   } catch (error) {
     if (isMissingWorkflowV1Table(error)) return null;
     throw error;
   }
 }
-function isMissingWorkflowV2SignalSchemaError(error) {
-  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
-  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
-  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
-  const message = error instanceof Error ? error.message : String(error);
-  return code === "42P01" || code === "42703" || causeCode === "42P01" || causeCode === "42703" || (code === "23503" || causeCode === "23503") && message.includes("_gencow_workflow_signals_v2") || message.includes('relation "_gencow_workflow_signals_v2" does not exist') || message.includes("relation _gencow_workflow_signals_v2 does not exist") || message.includes('relation "_gencow_workflow_runs_v2" does not exist') || message.includes("relation _gencow_workflow_runs_v2 does not exist") || message.includes('relation "_gencow_workflow_outbox_v2" does not exist') || message.includes("relation _gencow_workflow_outbox_v2 does not exist") || message.includes('relation "_gencow_workflow_steps_v2" does not exist') || message.includes("relation _gencow_workflow_steps_v2 does not exist");
-}
 function isMissingWorkflowV2PayloadSchemaError(error) {
   const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
   const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
@@ -3125,7 +3626,7 @@ function isMissingWorkflowV1Table(error) {
 }
 async function loadWorkflowV2Run(db, workflowId) {
   try {
-    const result = await db.execute(sql4`
+    const result = await db.execute(sql8`
       SELECT id, workflow_name, status, args_json, result_json, error_json, error_code,
              current_step_key, retry_count, max_retries, max_active_duration_ms,
              created_at, updated_at, completed_at, user_id
@@ -3133,106 +3634,47 @@ async function loadWorkflowV2Run(db, workflowId) {
       WHERE id = ${workflowId}
       LIMIT 1
     `);
-    return rowsFromResult(result)[0] ?? null;
+    return rowsFromResult2(result)[0] ?? null;
   } catch (error) {
     if (isMissingWorkflowV2PayloadSchemaError(error)) return null;
     throw error;
   }
 }
+function isMissingWorkflowV2JournalColumnError(error) {
+  const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+  const cause = error && typeof error === "object" && "cause" in error ? error.cause : null;
+  const causeCode = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "";
+  return code === "42703" || causeCode === "42703";
+}
 async function loadWorkflowV2Steps(db, workflowId) {
   try {
-    const stepResult = await db.execute(sql4`
-      SELECT step_key, status, output_json, error_json, started_at, updated_at, completed_at
-      FROM _gencow_workflow_steps_v2
-      WHERE run_id = ${workflowId}
-      ORDER BY step_index ASC, COALESCE(started_at, updated_at) ASC, step_key ASC
-    `);
-    return rowsFromResult(stepResult);
+    try {
+      const stepResult = await db.execute(sql8`
+        SELECT step_key, status, command_kind, output_json, output_codec, error_json, started_at, updated_at, completed_at
+        FROM _gencow_workflow_steps_v2
+        WHERE run_id = ${workflowId}
+          AND (command_kind IS NULL OR command_kind = 'step')
+        ORDER BY step_index ASC, COALESCE(started_at, updated_at) ASC, step_key ASC
+      `);
+      return rowsFromResult2(stepResult);
+    } catch (error) {
+      if (!isMissingWorkflowV2JournalColumnError(error)) throw error;
+      const stepResult = await db.execute(sql8`
+        SELECT step_key, status, output_json, error_json, started_at, updated_at, completed_at
+        FROM _gencow_workflow_steps_v2
+        WHERE run_id = ${workflowId}
+        ORDER BY step_index ASC, COALESCE(started_at, updated_at) ASC, step_key ASC
+      `);
+      return rowsFromResult2(stepResult);
+    }
   } catch (error) {
     if (isMissingWorkflowV2PayloadSchemaError(error)) return [];
     throw error;
   }
 }
-async function tryRecordWorkflowV2Signal(options) {
-  try {
-    const result = await options.db.execute(sql4`
-      WITH eligible_run AS (
-        SELECT id
-        FROM _gencow_workflow_runs_v2
-        WHERE id = ${options.workflowId}
-          AND status IN ('queued', 'running', 'sleeping', 'waiting')
-          AND completed_at IS NULL
-          AND cancel_requested_at IS NULL
-        FOR UPDATE
-      ), inserted AS (
-        INSERT INTO _gencow_workflow_signals_v2 (
-          id,
-          run_id,
-          event_name,
-          payload_json,
-          idempotency_key
-        )
-        SELECT
-          ${options.signalId},
-          eligible_run.id,
-          ${options.event},
-          ${workflowJsonb(options.payload)},
-          ${options.signalId}
-        FROM eligible_run
-        RETURNING id, run_id
-      ),
-      queued_run AS (
-        UPDATE _gencow_workflow_runs_v2 run
-        SET
-          status = 'queued',
-          runnable_at = NOW(),
-          lease_owner = NULL,
-          lease_expires_at = NULL,
-          heartbeat_at = NULL,
-          updated_at = NOW()
-        FROM inserted
-        WHERE run.id = inserted.run_id
-          AND run.status = 'waiting'
-          AND run.completed_at IS NULL
-          AND run.cancel_requested_at IS NULL
-        RETURNING run.id
-      ),
-      wake_outbox AS (
-        INSERT INTO _gencow_workflow_outbox_v2 (
-          id,
-          run_id,
-          kind,
-          available_at,
-          status
-        )
-        SELECT
-          'signal:' || inserted.id,
-          inserted.run_id,
-          'wake_signal',
-          NOW(),
-          'pending'
-        FROM inserted
-        JOIN queued_run ON queued_run.id = inserted.run_id
-        ON CONFLICT (id) DO NOTHING
-        RETURNING id
-      ),
-      wake_notified AS (
-        SELECT pg_notify(${WORKFLOW_WAKE_SIGNAL_CHANNEL}, ${WORKFLOW_WAKE_SIGNAL_PAYLOAD})
-        FROM wake_outbox
-      )
-      SELECT 1
-      FROM inserted
-      LEFT JOIN wake_notified ON TRUE
-    `);
-    return rowsFromResult(result).length > 0 ? "accepted" : "rejected";
-  } catch (error) {
-    if (isMissingWorkflowV2SignalSchemaError(error)) return "absent";
-    throw error;
-  }
-}
 async function mirrorWorkflowV2SignalToV1(options) {
   try {
-    await options.db.execute(sql4`
+    await options.db.execute(sql8`
       INSERT INTO _gencow_workflow_events (id, workflow_id, event_name, payload)
       SELECT ${options.signalId}, workflow.id, ${options.event}, NULL
       FROM _gencow_workflows workflow
@@ -3249,7 +3691,7 @@ async function loadWorkflowSnapshot(db, workflowId, options) {
   const v2Run = await loadWorkflowV2Run(db, workflowId);
   let workflowResult;
   try {
-    workflowResult = await db.execute(sql4`
+    workflowResult = await db.execute(sql8`
         SELECT
             id,
             name,
@@ -3275,7 +3717,7 @@ async function loadWorkflowSnapshot(db, workflowId, options) {
     if (!v2Run || !isMissingWorkflowV1Table(error)) throw error;
     workflowResult = [];
   }
-  const row = rowsFromResult(workflowResult)[0] ?? null;
+  const row = rowsFromResult2(workflowResult)[0] ?? null;
   if (!v2Run && !row) return null;
   const viewerUserId = options?.viewerUserId ?? null;
   const ownerId = v2Run ? v2Run.user_id : row?.user_id;
@@ -3289,7 +3731,7 @@ async function loadWorkflowSnapshot(db, workflowId, options) {
   if (steps.length === 0) {
     let stepsResult;
     try {
-      stepsResult = await db.execute(sql4`
+      stepsResult = await db.execute(sql8`
         SELECT
             step_name,
             status,
@@ -3306,7 +3748,7 @@ async function loadWorkflowSnapshot(db, workflowId, options) {
       if (!v2Run || !isMissingWorkflowV1Table(error)) throw error;
       stepsResult = [];
     }
-    steps = rowsFromResult(stepsResult).map(mapWorkflowStep);
+    steps = rowsFromResult2(stepsResult).map(mapWorkflowStep);
   }
   return {
     ...v2Run ? mapV2WorkflowSummary(v2Run) : mapWorkflowSummary(row),
@@ -3333,7 +3775,8 @@ function buildWorkflowBuiltinDefinitions() {
     argsSchema: {
       id: v.string(),
       event: v.string(),
-      payload: v.optional(v.any())
+      payload: v.optional(v.any()),
+      idempotencyKey: v.optional(v.string())
     },
     isPublic: true,
     handler: async (ctx, args) => {
@@ -3370,14 +3813,19 @@ function buildWorkflowBuiltinDefinitions() {
         serializedValue: persistedPayload
       });
       const signalId = crypto.randomUUID();
+      const idempotencyKey = normalizeWorkflowIdempotencyKey(args.idempotencyKey);
       if (v2Run) {
         const recordedV2 = await tryRecordWorkflowV2Signal({
           db: ctx.unsafeDb,
           workflowId,
           event: normalizedEvent,
           signalId,
-          payload: persistedPayload
+          payload: persistedPayload,
+          idempotencyKey
         });
+        if (recordedV2 === "duplicate") {
+          return { ok: true, workflowId, event: normalizedEvent, scheduledJobId: null, deduplicated: true };
+        }
         if (recordedV2 !== "accepted") {
           return { ok: false, workflowId, event: normalizedEvent, scheduledJobId: null };
         }
@@ -3390,7 +3838,7 @@ function buildWorkflowBuiltinDefinitions() {
           });
         }
       } else {
-        await ctx.unsafeDb.execute(sql4`
+        await ctx.unsafeDb.execute(sql8`
                 INSERT INTO _gencow_workflow_events (
                     id,
                     workflow_id,
@@ -3434,23 +3882,21 @@ function buildWorkflowBuiltinDefinitions() {
       const userId = ctx.auth.requireAuth().id;
       const limit = normalizeListLimit(args.limit);
       const requestedStatus = normalizeDerivedStatus(args.status);
-      const v1Derived = sql4`CASE WHEN w.status = 'pending' AND w.current_step LIKE 'sleep#%' THEN 'sleeping'
+      const v1Derived = sql8`CASE WHEN w.status = 'pending' AND w.current_step LIKE 'sleep#%' THEN 'sleeping'
         WHEN w.status = 'pending' AND w.current_step LIKE 'wait:%' THEN 'waiting'
-        WHEN w.status = 'pending' THEN 'queued' ELSE w.status END`;
-      const effectiveStatus = sql4`CASE WHEN v.id IS NOT NULL THEN
-        CASE WHEN v.status = 'cancelled' THEN 'failed'
-             WHEN v.status IN ('queued', 'waiting', 'sleeping') THEN 'pending'
-             ELSE v.status END
-        ELSE w.status END`;
-      const effectiveDerived = sql4`CASE WHEN v.id IS NOT NULL THEN
-        CASE WHEN v.status = 'cancelled' THEN 'failed'
-             WHEN v.status IN ('queued', 'waiting', 'sleeping') THEN v.status
+        WHEN w.status = 'pending' THEN 'queued'
+        WHEN w.status = 'failed' AND w.error_code = 'cancelled' THEN 'cancelled' ELSE w.status END`;
+      const effectiveStatus = sql8`CASE WHEN v.id IS NOT NULL THEN
+        CASE WHEN v.status IN ('queued', 'waiting', 'sleeping') THEN 'pending'
              ELSE v.status END
+        ELSE CASE WHEN w.status = 'failed' AND w.error_code = 'cancelled' THEN 'cancelled' ELSE w.status END END`;
+      const effectiveDerived = sql8`CASE WHEN v.id IS NOT NULL THEN
+        v.status
         ELSE ${v1Derived} END`;
       const statusForFilter = requestedStatus === "pending" ? effectiveStatus : effectiveDerived;
-      const v1StatusForFilter = requestedStatus === "pending" ? sql4`w.status` : v1Derived;
+      const v1StatusForFilter = requestedStatus === "pending" ? sql8`w.status` : v1Derived;
       try {
-        const result = await ctx.unsafeDb.execute(sql4`
+        const result = await ctx.unsafeDb.execute(sql8`
           SELECT w.*, v.id AS v2_id, v.workflow_name AS v2_name,
                  v.status AS v2_status, v.error_json AS v2_error_json,
                  v.error_code AS v2_error_code, v.current_step_key AS v2_current_step,
@@ -3465,12 +3911,11 @@ function buildWorkflowBuiltinDefinitions() {
           ORDER BY COALESCE(v.created_at, w.started_at) DESC, COALESCE(v.id, w.id) DESC
           LIMIT ${limit}
         `);
-        return rowsFromResult(result).map(mapJoinedWorkflowSummary);
+        return rowsFromResult2(result).map(mapJoinedWorkflowSummary);
       } catch (error) {
         if (isMissingWorkflowV1Table(error)) {
-          const v2StatusForFilter = requestedStatus === "pending" ? sql4`CASE WHEN status IN ('queued', 'waiting', 'sleeping') THEN 'pending'
-                       WHEN status = 'cancelled' THEN 'failed' ELSE status END` : sql4`CASE WHEN status = 'cancelled' THEN 'failed' ELSE status END`;
-          const result2 = await ctx.unsafeDb.execute(sql4`
+          const v2StatusForFilter = requestedStatus === "pending" ? sql8`CASE WHEN status IN ('queued', 'waiting', 'sleeping') THEN 'pending' ELSE status END` : sql8`status`;
+          const result2 = await ctx.unsafeDb.execute(sql8`
             SELECT id, workflow_name, status, args_json, result_json, error_json, error_code,
                    current_step_key, retry_count, max_retries, max_active_duration_ms,
                    created_at, updated_at, completed_at, user_id
@@ -3480,24 +3925,25 @@ function buildWorkflowBuiltinDefinitions() {
             ORDER BY created_at DESC, id DESC
             LIMIT ${limit}
           `);
-          return rowsFromResult(result2).map(mapV2WorkflowSummary);
+          return rowsFromResult2(result2).map(mapV2WorkflowSummary);
         }
         if (!isMissingWorkflowV2PayloadSchemaError(error)) throw error;
-        const result = await ctx.unsafeDb.execute(sql4`
+        const result = await ctx.unsafeDb.execute(sql8`
           SELECT w.* FROM _gencow_workflows w
           WHERE w.user_id = ${userId}
             AND (${requestedStatus ?? null}::text IS NULL OR ${v1StatusForFilter} = ${requestedStatus ?? null})
           ORDER BY w.started_at DESC, w.id DESC
           LIMIT ${limit}
         `);
-        return rowsFromResult(result).map(mapWorkflowSummary);
+        return rowsFromResult2(result).map(mapWorkflowSummary);
       }
     }
   };
   const definitions = Object.freeze({
     get: Object.freeze(get),
     list: Object.freeze(list),
-    signal: Object.freeze(signal)
+    signal: Object.freeze(signal),
+    cancel: Object.freeze(buildWorkflowCancelDefinition())
   });
   return definitions;
 }
@@ -3511,6 +3957,7 @@ function registerWorkflowsApi() {
   queryRegistry.set(definitions.get.key, definitions.get);
   queryRegistry.set(definitions.list.key, definitions.list);
   mutationRegistry.push(definitions.signal);
+  mutationRegistry.push(definitions.cancel);
   globalThis.__gencow_workflowsApiRegistered = definitions;
   return definitions;
 }
@@ -3839,11 +4286,11 @@ function defineConfig(config) {
 }
 
 // ../core/src/rls-context-key.ts
-import { sql as sql5 } from "drizzle-orm";
+import { sql as sql9 } from "drizzle-orm";
 function sessionSettingSqlForKey(sessionKey) {
   const guc = sessionKeyToGucName(sessionKey);
   const escaped = guc.replace(/'/g, "''");
-  return sql5.raw(`current_setting('${escaped}', true)`);
+  return sql9.raw(`current_setting('${escaped}', true)`);
 }
 function rlsContextKey(key) {
   return sessionSettingSqlForKey(key);
@@ -3852,11 +4299,11 @@ function rlsContextKeys() {
   return (key) => rlsContextKey(key);
 }
 function eqRlsContextColumn(column, key) {
-  return sql5`${column} = ${rlsContextKey(key)}`;
+  return sql9`${column} = ${rlsContextKey(key)}`;
 }
 
 // ../core/src/rls-define-table.ts
-import { sql as sql6 } from "drizzle-orm";
+import { sql as sql10 } from "drizzle-orm";
 import { getTableName } from "drizzle-orm";
 import { pgPolicy } from "drizzle-orm/pg-core";
 var ALL_COMMANDS = ["select", "insert", "update", "delete"];
@@ -3868,22 +4315,22 @@ function escapeSqlStringLiteral(value) {
   return value.replace(/'/g, "''");
 }
 function sqlStringLiteral(value) {
-  return sql6.raw(`'${escapeSqlStringLiteral(value)}'`);
+  return sql10.raw(`'${escapeSqlStringLiteral(value)}'`);
 }
 function andExprs(exprs) {
-  if (exprs.length === 0) return sql6`true`;
+  if (exprs.length === 0) return sql10`true`;
   if (exprs.length === 1) return exprs[0];
-  return sql6.join(
-    exprs.map((e) => sql6`(${e})`),
-    sql6` AND `
+  return sql10.join(
+    exprs.map((e) => sql10`(${e})`),
+    sql10` AND `
   );
 }
 function orExprs(exprs) {
-  if (exprs.length === 0) return sql6`false`;
+  if (exprs.length === 0) return sql10`false`;
   if (exprs.length === 1) return exprs[0];
-  return sql6.join(
-    exprs.map((e) => sql6`(${e})`),
-    sql6` OR `
+  return sql10.join(
+    exprs.map((e) => sql10`(${e})`),
+    sql10` OR `
   );
 }
 function combinedExprForCommand(constraints, command) {
@@ -3919,20 +4366,20 @@ var TableRlsBuilder = class _TableRlsBuilder {
   constraints = [];
   readPublicSelect = false;
   matchColumn(column, keySql, options) {
-    const expr = sql6`${column} = ${keySql}`;
+    const expr = sql10`${column} = ${keySql}`;
     this.constraints.push({ commands: normalizeCommands(options?.commands), expr });
     return this;
   }
   sessionEq(keySql, value, options) {
-    const expr = sql6`${keySql} = ${sqlStringLiteral(stringifySessionValue(value))}`;
+    const expr = sql10`${keySql} = ${sqlStringLiteral(stringifySessionValue(value))}`;
     this.constraints.push({ commands: normalizeCommands(options?.commands), expr });
     return this;
   }
   sessionIn(keySql, values, options) {
     const literals = values.map((v2) => stringifySessionValue(v2));
-    const expr = literals.length === 0 ? sql6`false` : sql6`${keySql} IN (${sql6.join(
+    const expr = literals.length === 0 ? sql10`false` : sql10`${keySql} IN (${sql10.join(
       literals.map((v2) => sqlStringLiteral(v2)),
-      sql6`, `
+      sql10`, `
     )})`;
     this.constraints.push({ commands: normalizeCommands(options?.commands), expr });
     return this;
@@ -3971,17 +4418,17 @@ var TableRlsBuilder = class _TableRlsBuilder {
     return this.sessionCompare(keySql, "<", n, options);
   }
   sessionCompare(keySql, op, n, options) {
-    const bound = sql6.raw(String(n));
+    const bound = sql10.raw(String(n));
     const expr = (() => {
       switch (op) {
         case ">=":
-          return sql6`(${keySql})::numeric >= ${bound}`;
+          return sql10`(${keySql})::numeric >= ${bound}`;
         case ">":
-          return sql6`(${keySql})::numeric > ${bound}`;
+          return sql10`(${keySql})::numeric > ${bound}`;
         case "<=":
-          return sql6`(${keySql})::numeric <= ${bound}`;
+          return sql10`(${keySql})::numeric <= ${bound}`;
         case "<":
-          return sql6`(${keySql})::numeric < ${bound}`;
+          return sql10`(${keySql})::numeric < ${bound}`;
       }
     })();
     this.constraints.push({ commands: normalizeCommands(options?.commands), expr });
@@ -4020,7 +4467,7 @@ var TableRlsBuilder = class _TableRlsBuilder {
         policies.push(
           pgPolicy(this.policyName(command, counters[command]++), {
             for: "select",
-            using: sql6`true`
+            using: sql10`true`
           })
         );
         continue;
@@ -4084,7 +4531,7 @@ import { pgTable } from "drizzle-orm/pg-core";
 var pgBaseTable = pgTable;
 
 // ../core/src/rls-db.ts
-import { sql as sql7 } from "drizzle-orm";
+import { sql as sql11 } from "drizzle-orm";
 
 // ../core/src/rls-db-scoped-query.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -4258,7 +4705,7 @@ function transactionConfigSql(config) {
     if (typeof value.deferrable !== "boolean") return null;
     chunks.push(value.deferrable ? "deferrable" : "not deferrable");
   }
-  return chunks.length > 0 ? sql7.raw(`SET TRANSACTION ${chunks.join(", ")}`) : null;
+  return chunks.length > 0 ? sql11.raw(`SET TRANSACTION ${chunks.join(", ")}`) : null;
 }
 async function applyTransactionConfig(tx, config) {
   const statement = transactionConfigSql(config);
@@ -4300,7 +4747,7 @@ async function applyRlsSessionVars(client, rls) {
 }
 async function injectRlsVarsOnTx(tx, rls, onTransactionContextFailure) {
   try {
-    await forEachSetConfig(rls, (name, value) => tx.execute(sql7`SELECT set_config(${name}, ${value}, true)`));
+    await forEachSetConfig(rls, (name, value) => tx.execute(sql11`SELECT set_config(${name}, ${value}, true)`));
   } catch (error) {
     try {
       onTransactionContextFailure?.(error);
@@ -5042,7 +5489,7 @@ function buildRowOutputValidator(columns) {
 }
 
 // ../core/src/createCrud.cursor.ts
-import { sql as sql8 } from "drizzle-orm";
+import { sql as sql12 } from "drizzle-orm";
 function normalizeOrderDir(raw) {
   const d = typeof raw === "string" ? raw.toLowerCase() : "";
   return d === "asc" ? "asc" : "desc";
@@ -5075,16 +5522,16 @@ function buildTupleComparePredicate(columns, values, direction) {
   if (columns.length !== values.length || columns.length === 0) {
     throw new Error("cursor column count mismatch");
   }
-  const opToken = direction === "asc" ? sql8`>` : sql8`<`;
-  const colTuple = sql8.join(
-    columns.map((c) => sql8`${c}`),
-    sql8`, `
+  const opToken = direction === "asc" ? sql12`>` : sql12`<`;
+  const colTuple = sql12.join(
+    columns.map((c) => sql12`${c}`),
+    sql12`, `
   );
-  const valTuple = sql8.join(
-    values.map((val) => sql8`${val}`),
-    sql8`, `
+  const valTuple = sql12.join(
+    values.map((val) => sql12`${val}`),
+    sql12`, `
   );
-  return sql8`(${colTuple}) ${opToken} (${valTuple})`;
+  return sql12`(${colTuple}) ${opToken} (${valTuple})`;
 }
 
 // ../core/src/createCrud.ts
@@ -5646,7 +6093,18 @@ export {
   TableRlsBuilder,
   WORKFLOW_REALTIME_KEY_PREFIX,
   WORKFLOW_RESUME_ACTION_PREFIX,
+  WORKFLOW_STEP_FAILED_CODE,
+  WORKFLOW_STEP_OPTIONS_INVALID_CODE,
+  WORKFLOW_STEP_TIMEOUT_CODE,
+  WORKFLOW_WAIT_TIMEOUT_CODE,
+  WorkflowCommandNameError,
+  WorkflowNestedCommandError,
+  WorkflowNonRetryableError,
   WorkflowPayloadPolicyError,
+  WorkflowStepFailedError,
+  WorkflowStepOptionsError,
+  WorkflowStepTimeoutError,
+  WorkflowWaitTimeoutError,
   advanceUnreadCursor,
   applyFilterOp,
   assertWorkflowPayloadWithinLimit,
@@ -5678,6 +6136,7 @@ export {
   cron,
   cronJobs,
   defaultRlsSessionContext,
+  defaultWorkflowCommandProtocol,
   defineApi,
   defineAuth,
   defineConfig,
@@ -5719,6 +6178,7 @@ export {
   normalizeRealtimeChannelEpoch,
   normalizeRealtimeQuerySubscriptionEpoch,
   normalizeUnreadCursor,
+  normalizeWorkflowCommandName,
   ownerRls,
   parseArgs,
   parseFilterNode,
@@ -5750,6 +6210,7 @@ export {
   tableRls,
   v,
   validateRlsSessionContext,
+  validateWorkflowStepOptions,
   verifyRealtimeChannelToken,
   verifyRealtimeQuerySubscriptionToken,
   verifyRealtimeTicket,