@humwick/server 0.130.1 → 0.130.2

package/node_modules/@humwick/kernel/workflow-foreach.ts

@@ -1,167 +0,0 @@
-import { z } from "zod";
-import { OpError, type ModuleCtx } from "./contract";
-import { actionKind } from "./workflow-lane";
-import { parkDecision, rootRun, valueContext } from "./workflow-composition";
-import { itemResult, settleDependents } from "./workflow-container";
-import { waitTimeoutMs } from "./workflow-definition";
-import { workflowActivationSchema, type WorkflowActivation } from "./workflow-activation";
-import { ADMIN_GRANT, SIGNAL_TOPIC, stores, requireRun, usedEffects, type WorkflowRunRecord } from "./workflow-state";
-
-async function continueAncestors(ctx: ModuleCtx, run: WorkflowRunRecord | undefined, generation: number): Promise<void> {
-  while (run) {
-    await stores(ctx).run.update(run.id, { status: "running", reason: undefined, escalation: undefined, decisionChildRunId: undefined, generation });
-    if (run.activationId) await stores(ctx).activation.update(run.activationId, { state: "waiting", error: undefined, generation });
-    run = run.parentRunId ? await requireRun(ctx, run.parentRunId) : undefined;
-  }
-}
-
-export async function resumeContainer(ctx: ModuleCtx, run: WorkflowRunRecord): Promise<boolean> {
-  if (run.status !== "escalated" || run.awaiting?.kind !== "for-each") return false;
-  const root = await rootRun(ctx, run);
-  const deadline = ctx.clock.now() + waitTimeoutMs(run.definition, run.step);
-  await stores(ctx).run.update(run.id, { awaiting: { ...run.awaiting, deadline } });
-  await stores(ctx).activation.update(run.activationId!, { deadline });
-  await continueAncestors(ctx, run, (root.generation ?? 0) + 1);
-  return true;
-}
-
-export async function retryItem(ctx: ModuleCtx, run: WorkflowRunRecord, activationId: string | undefined): Promise<void> {
-  const slot = await stores(ctx).activation.get(run.id);
-  if (!slot?.parentId || activationId !== slot.id) throw new OpError("invalid_input", 400, "select the failed activationId to explicitly retry its work");
-  const container = (await stores(ctx).activation.get(slot.parentId))!;
-  const counts = container.container!;
-  const root = await rootRun(ctx, run);
-  if (root.budget!.activations >= (root.limits?.activations ?? 4096)) throw new OpError("conflict", 409, "ACTIVATION_LIMIT: retry budget exhausted");
-  const used = await usedEffects(ctx, run);
-  await stores(ctx).activation.update(slot.id, { state: "ready", active: true, attempt: slot.attempt + 1, outcome: undefined, outputs: undefined, error: undefined, childRunId: undefined,
-    lane: { status: "running", waitSeq: used.seq, round: slot.attempt + 1 }, generation: (root.generation ?? 0) + 1 });
-  await stores(ctx).activation.update(container.id, { state: "waiting", scheduling: true, container: { ...counts, stopped: counts.failed > 1, decision: false, live: counts.live + 1, settled: counts.settled - 1, failed: counts.failed - 1 } });
-  await stores(ctx).run.update(root.id, { budget: { ...root.budget!, activations: root.budget!.activations + 1 } });
-  await continueAncestors(ctx, run.parentRunId ? await requireRun(ctx, run.parentRunId) : undefined, (root.generation ?? 0) + 1);
-  await ctx.workflows.start("run", { runId: slot.id }, { idempotencyKey: `${slot.id}:retry:${slot.attempt + 1}`, enlist: "op-commit" });
-}
-
-async function slots(ctx: ModuleCtx, id: string, where: Partial<WorkflowActivation> = {}): Promise<WorkflowActivation[]> {
-  const rows: WorkflowActivation[] = [];
-  let cursor: string | undefined;
-  do {
-    const page = await stores(ctx).activation.list({ where: { parentId: id, ...where }, limit: 200, ...(cursor ? { cursor } : {}) });
-    rows.push(...page.items); cursor = page.cursor;
-  } while (cursor);
-  return rows;
-}
-
-async function tickContainer(ctx: ModuleCtx, container: WorkflowActivation, admit: boolean): Promise<{ admitted: boolean; cancel: string[] }> {
-  const run = await requireRun(ctx, container.parentId ? container.id : container.runId);
-  const root = await rootRun(ctx, run);
-  const loop = run.definition.steps[run.step]?.forEach;
-  if (!loop || run.activationId !== container.id || !container.container) {
-    await stores(ctx).activation.update(container.id, { scheduling: false });
-    return { admitted: false, cancel: [] };
-  }
-  const counts = { ...container.container };
-  if (!run.cancel && !root.cancel && root.status === "running" && run.status === "running" && container.deadline !== undefined && ctx.clock.now() >= container.deadline) {
-    await parkDecision(ctx, run, run, `CONTAINER_TIMEOUT: ${container.path} exceeded ${container.deadline}`);
-    return { admitted: false, cancel: [] };
-  }
-  const items = await slots(ctx, container.id, { active: true });
-  const cancel: string[] = [];
-  for (const slot of items) {
-    if (!slot.lane || slot.lane.counted === true) continue;
-    const status = slot.lane.status;
-    if (status !== "done" && status !== "failed" && status !== "cancelled") continue;
-    if (status === "cancelled" && (slot.lane.cleanup as { status?: string } | undefined)?.status !== "complete") continue;
-    const failed = status === "failed";
-    if (status === "done" && loop.join === "any" && !counts.winner && slot.outcome !== "skipped") counts.winner = slot.key ?? String(slot.index);
-    slot.state = status === "done" ? slot.outcome === "skipped" ? "skipped" : "succeeded" : status;
-    slot.outcome = status === "done" ? slot.state === "skipped" ? "skipped" : "complete" : status;
-    if (failed) slot.error ??= { code: "ITEM_FAILED", message: slot.lane.reason };
-    slot.lane = { ...slot.lane, counted: true };
-    await stores(ctx).activation.update(slot.id, { active: false, state: slot.state, outcome: slot.outcome, error: slot.error, lane: slot.lane });
-    counts.live--; counts.settled++; if (failed) counts.failed++;
-    if (status === "done" && slot.state !== "skipped") await settleDependents(ctx, slot, false);
-    else if (slot.state === "skipped" || loop.onFailure === "continue") counts.settled += await settleDependents(ctx, slot, true);
-    if (failed && loop.onFailure !== "continue") counts.stopped = true;
-    if (failed && loop.onFailure === "escalate" && !counts.decision) {
-      await parkDecision(ctx, await requireRun(ctx, slot.id), run, `ITEM_FAILED: ${slot.path}; explicitly retry this slot or cancel the group`);
-      counts.decision = true;
-    }
-  }
-  if (counts.failed && loop.onFailure === "escalate" && !counts.decision && !items.some(slot => slot.attempt > 1 && slot.lane?.counted !== true)) {
-    const unresolved = (await slots(ctx, container.id, { state: "failed" }))[0];
-    if (unresolved) {
-      await parkDecision(ctx, await requireRun(ctx, unresolved.id), run, `ITEM_FAILED: ${unresolved.path}; explicitly retry this slot or cancel the group`);
-      counts.stopped = true; counts.decision = true;
-    }
-  }
-  const stopping = Boolean(counts.winner || root.cancel || run.cancel || (counts.stopped && loop.onFailure === "fail-fast"));
-  if (stopping) {
-    counts.stopped = true;
-    for (const slot of [...await slots(ctx, container.id, { state: "pending" }), ...await slots(ctx, container.id, { state: "ready" })].filter(slot => !slot.active)) { await stores(ctx).activation.update(slot.id, { state: "skipped", outcome: "skipped", ...(counts.winner ? { error: { code: "JOIN_LOST", winner: counts.winner } } : {}) }); counts.settled++; }
-    for (const slot of items) if (slot.lane?.counted !== true && slot.lane) {
-      if (counts.winner) await stores(ctx).activation.update(slot.id, { error: { code: "JOIN_LOST", winner: counts.winner } });
-      cancel.push(slot.id);
-    }
-    counts.next = counts.total;
-  }
-  let admitted = false;
-  if (admit && !counts.stopped && !root.cancel && root.status === "running" && run.status === "running" && counts.live < loop.concurrency && counts.next < counts.total) {
-    const slot = (await stores(ctx).activation.list({ where: { parentId: container.id, state: "ready", active: false }, limit: 1 })).items[0]
-      ?? (await stores(ctx).activation.list({ where: { parentId: container.id, state: "pending" }, limit: 1 })).items.find(slot => slot.remaining === undefined);
-    if (slot) {
-      await stores(ctx).activation.update(slot.id, { state: "running", active: true, lane: { status: "running" } });
-      await ctx.workflows.start("run", { runId: slot.id }, { idempotencyKey: slot.id, enlist: "op-commit" });
-      counts.next++; counts.live++; admitted = true;
-    }
-  }
-  await stores(ctx).activation.update(container.id, { container: counts });
-  if (stopping && counts.live === 0) await stores(ctx).activation.update(container.id, { scheduling: false });
-  // A parked decision retains its original wait even when every item has settled.
-  if (!counts.decision && counts.settled === counts.total && run.status === "running" && !run.cancel && run.awaiting?.kind === "for-each" && !await stores(ctx).signal.get(run.awaiting.key)) {
-    const results = (await slots(ctx, container.id)).map(itemResult);
-    const ok = loop.join === "any" ? counts.winner !== undefined : counts.failed === 0;
-    const base = { ok, ...(counts.winner ? { winner: counts.winner } : {}), resultsRef: container.id };
-    const complete = { ...base, results: loop.branches ? Object.fromEntries(results.map(result => [result.key, result])) : results };
-    const outputs = new TextEncoder().encode(JSON.stringify(complete)).length <= 65536 ? complete : base;
-    const outcome = loop.join === "any" ? ok ? "complete" : "failed" : counts.failed && loop.onFailure !== "continue" ? "failed" : "complete";
-    await stores(ctx).signal.create({ id: run.awaiting.key, runId: run.id, kind: "for-each", payload: { outcome, outputs }, createdAt: ctx.clock.now() });
-    await stores(ctx).activation.update(container.id, { scheduling: false });
-    await ctx.events.emit(SIGNAL_TOPIC, { runId: run.id, correlationId: run.awaiting.key });
-  }
-  return { admitted, cancel };
-}
-
-export const foreachOps = {
-  tickItems: {
-    kind: "mutation", idempotent: true, grant: ADMIN_GRANT, summary: "Settle item slots and fairly admit a bounded batch across containers.", expose: { http: false, mcp: false, cli: false },
-    input: z.object({}), output: z.object({ admitted: z.number(), cancel: z.array(z.string()) }),
-    handler: async (ctx: ModuleCtx) => {
-      const cursor = await stores(ctx).admission.get("foreach");
-      const page = await stores(ctx).activation.list({ where: { scheduling: true }, limit: 50, ...(cursor?.cursor ? { cursor: cursor.cursor } : {}) });
-      let admitted = 0;
-      const cancel: string[] = [];
-      for (const container of page.items) {
-        const tick = await tickContainer(ctx, container, true);
-        admitted += Number(tick.admitted); cancel.push(...tick.cancel);
-      }
-      if (cursor) await stores(ctx).admission.update(cursor.id, { cursor: page.cursor });
-      else await stores(ctx).admission.create({ id: "foreach", cursor: page.cursor });
-      return { admitted, cancel };
-    },
-  },
-  itemLanes: {
-    kind: "query", grant: ADMIN_GRANT, summary: "Page active item lanes for ordinary wait reconciliation.", expose: { http: false, mcp: false, cli: false },
-    input: z.object({ runId: z.string().optional(), containerId: z.string().optional(), cursor: z.string().optional() }), output: z.object({ items: z.array(workflowActivationSchema), cursor: z.string().optional() }),
-    handler: async (ctx: ModuleCtx, input: { runId?: string; containerId?: string; cursor?: string }) => stores(ctx).activation.list({ where: { active: true, ...(input.runId ? { runId: input.runId } : {}), ...(input.containerId ? { parentId: input.containerId } : {}) }, limit: 100, ...(input.cursor ? { cursor: input.cursor } : {}) }),
-  },
-  itemResults: {
-    kind: "query", grant: ADMIN_GRANT, summary: "Page input-ordered item results from a container reference.", expose: { http: false, mcp: false, cli: false },
-    input: z.object({ runId: z.string(), resultsRef: z.string(), cursor: z.string().optional() }), output: z.object({ items: z.array(z.record(z.string(), z.unknown())), cursor: z.string().optional() }),
-    handler: async (ctx: ModuleCtx, input: { runId: string; resultsRef: string; cursor?: string }) => {
-      const container = await stores(ctx).activation.get(input.resultsRef);
-      if (!container || container.runId !== input.runId || !container.container) throw new OpError("not_found", 404, "item collection not found");
-      const page = await stores(ctx).activation.list({ where: { parentId: container.id }, limit: 100, ...(input.cursor ? { cursor: input.cursor } : {}) });
-      return { items: page.items.map(itemResult), ...(page.cursor ? { cursor: page.cursor } : {}) };
-    },
-  },
-} as const;

package/node_modules/@humwick/kernel/workflow-journal-codec.ts

@@ -1,339 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import type { WorkflowInstanceRow, WorkflowStepJournalRow } from "./workflow-journal";
-
-/**
- * Strict durable-journal codecs + the step-journal fold, re-homed into the kernel from
- * `src/db/workflow-journal.ts` (epic #1408 / M1). These are the pure functions that validate and
- * serialize journal rows and reconstruct an instance's resume state from its immutable journal;
- * the DB-bound helpers that used the `src/` connection singleton stay in `src/` and now delegate
- * here through the strangler re-export. The kernel never imports `src/`, so the two small SDK
- * helpers this logic relied on (`isRecord`, `errMessage`) are inlined below.
- */
-
-/** True for a non-null, non-array object (inlined from `@humwick/sdk`). */
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** Human-readable message from any thrown value (inlined from `@humwick/sdk`). */
-function errMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-export const WORKFLOW_INSTANCE_STATUSES = [
-  "pending", "running", "sleeping", "waiting", "done", "failed", "canceled",
-] as const;
-export type WorkflowInstanceStatus = typeof WORKFLOW_INSTANCE_STATUSES[number];
-export type WorkflowAttemptOutcome = "completed" | "failed";
-export type WorkflowWaitCondition = Record<string, unknown>;
-
-/** The camelCase, decoded view of a `workflow_instances` row. */
-export interface WorkflowInstance {
-  id: string;
-  moduleName: string;
-  workflowName: string;
-  idempotencyKey: string;
-  input: unknown;
-  initialState: unknown;
-  startStep: string;
-  status: WorkflowInstanceStatus;
-  sleepUntil?: number;
-  waitFor?: WorkflowWaitCondition;
-  output?: unknown;
-  failure?: unknown;
-  journalCursor: number;
-  journalPrunedThrough: number;
-  executorLeaseOwner?: string;
-  executorLeaseToken?: string;
-  executorLeaseVersion: number;
-  executorLeaseAcquiredAt?: number;
-  executorLeaseExpiresAt?: number;
-  createdAt: number;
-  updatedAt: number;
-  closedAt?: number;
-  retentionUntil?: number;
-}
-
-/** The decoded shape of a memoized step result stored in `workflow_step_journal.result`. */
-export interface WorkflowStepResult {
-  state: unknown;
-  next: string;
-  output?: unknown;
-  sleepUntil?: number;
-  waitFor?: WorkflowWaitCondition;
-}
-
-/** The camelCase, decoded view of an immutable `workflow_step_journal` attempt row. */
-export interface WorkflowJournalRecord {
-  instanceId: string;
-  seq: number;
-  stepIndex: number;
-  stepName: string;
-  attempt: number;
-  outcome: WorkflowAttemptOutcome;
-  stateSnapshot: unknown;
-  result: unknown;
-  sleepUntil?: number;
-  waitFor?: WorkflowWaitCondition;
-  startedAt: number;
-  completedAt: number;
-}
-
-export type WorkflowResumeStatus = "ready" | "sleeping" | "waiting" | "done" | "failed" | "canceled";
-
-/** Where a folded journal says execution resumes, and the state it resumes with. */
-export interface WorkflowResumePoint {
-  instanceId: string;
-  status: WorkflowResumeStatus;
-  state: unknown;
-  stepIndex: number;
-  stepName?: string;
-  nextAttempt: number;
-  completedSteps: number;
-  cursor: number;
-  sleepUntil?: number;
-  waitFor?: WorkflowWaitCondition;
-  output?: unknown;
-  failure?: unknown;
-}
-
-/** Raised when durable journal state is malformed; replay must fail loudly, never invent state. */
-export class WorkflowJournalCorruptionError extends Error {
-  constructor(message: string) {
-    super(`workflow journal corruption: ${message}`);
-    this.name = "WorkflowJournalCorruptionError";
-  }
-}
-
-/** Serialize with a lossless round-trip guard; throws for non-JSON-safe values. */
-export function encodeJson(value: unknown, label: string): string {
-  try {
-    const encoded = JSON.stringify(value);
-    if (encoded === undefined) throw new TypeError("value is not JSON-serializable");
-    if (!isDeepStrictEqual(JSON.parse(encoded), value)) throw new TypeError("value changes during JSON encoding");
-    return encoded;
-  } catch (error) {
-    throw new TypeError(`${label} must be JSON-serializable: ${errMessage(error)}`);
-  }
-}
-
-/** Parse durable JSON, converting a parse failure into a loud corruption error. */
-export function decodeJson(raw: string, label: string): unknown {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new WorkflowJournalCorruptionError(`${label} is not valid JSON`);
-  }
-}
-
-function decodeWaitCondition(value: unknown, label: string): WorkflowWaitCondition {
-  if (!isRecord(value)) throw new WorkflowJournalCorruptionError(`${label} must be a JSON object`);
-  return value;
-}
-
-/** Strict decode of a memoized step result: a JSON object with state + a non-empty `next`. */
-export function decodeStepResult(value: unknown, label: string): WorkflowStepResult {
-  if (!isRecord(value) || !("state" in value) || typeof value.next !== "string" || value.next.length === 0) {
-    throw new WorkflowJournalCorruptionError(`${label} must contain a state and non-empty next step`);
-  }
-  if (value.sleepUntil !== undefined && (typeof value.sleepUntil !== "number" || !Number.isFinite(value.sleepUntil))) {
-    throw new WorkflowJournalCorruptionError(`${label}.sleepUntil must be a finite number`);
-  }
-  const waitFor = value.waitFor === undefined ? undefined : decodeWaitCondition(value.waitFor, `${label}.waitFor`);
-  if (value.sleepUntil !== undefined && waitFor !== undefined) {
-    throw new WorkflowJournalCorruptionError(`${label} cannot contain both sleepUntil and waitFor`);
-  }
-  if (value.next === "done" && (value.sleepUntil !== undefined || waitFor !== undefined)) {
-    throw new WorkflowJournalCorruptionError(`${label} cannot schedule work after next=done`);
-  }
-  return {
-    state: value.state,
-    next: value.next,
-    ...(Object.hasOwn(value, "output") ? { output: value.output } : {}),
-    ...(value.sleepUntil !== undefined ? { sleepUntil: value.sleepUntil } : {}),
-    ...(waitFor !== undefined ? { waitFor } : {}),
-  };
-}
-
-/** Strict row codec: durable replay must fail loudly rather than invent state from malformed JSON. */
-export function workflowInstanceFromRow(row: WorkflowInstanceRow): WorkflowInstance {
-  if (!WORKFLOW_INSTANCE_STATUSES.includes(row.status as WorkflowInstanceStatus)) {
-    throw new WorkflowJournalCorruptionError(`instance ${row.id} has unknown status ${row.status}`);
-  }
-  if (![row.journal_cursor, row.journal_pruned_through, row.executor_lease_version].every(Number.isSafeInteger)
-    || row.journal_cursor < 0 || row.journal_pruned_through < 0 || row.journal_pruned_through > row.journal_cursor
-    || row.executor_lease_version < 0) {
-    throw new WorkflowJournalCorruptionError(`instance ${row.id} has invalid journal/lease cursors`);
-  }
-  const waitForValue = row.wait_for === null ? undefined : decodeWaitCondition(decodeJson(row.wait_for, `instance ${row.id} wait_for`), `instance ${row.id} wait_for`);
-  return {
-    id: row.id,
-    moduleName: row.module_name,
-    workflowName: row.workflow_name,
-    idempotencyKey: row.idempotency_key,
-    input: decodeJson(row.input, `instance ${row.id} input`),
-    initialState: decodeJson(row.initial_state, `instance ${row.id} initial_state`),
-    startStep: row.start_step,
-    status: row.status as WorkflowInstanceStatus,
-    ...(row.sleep_until !== null ? { sleepUntil: row.sleep_until } : {}),
-    ...(waitForValue !== undefined ? { waitFor: waitForValue } : {}),
-    ...(row.output !== null ? { output: decodeJson(row.output, `instance ${row.id} output`) } : {}),
-    ...(row.failure !== null ? { failure: decodeJson(row.failure, `instance ${row.id} failure`) } : {}),
-    journalCursor: row.journal_cursor,
-    journalPrunedThrough: row.journal_pruned_through,
-    ...(row.executor_lease_owner !== null ? { executorLeaseOwner: row.executor_lease_owner } : {}),
-    ...(row.executor_lease_token !== null ? { executorLeaseToken: row.executor_lease_token } : {}),
-    executorLeaseVersion: row.executor_lease_version,
-    ...(row.executor_lease_acquired_at !== null ? { executorLeaseAcquiredAt: row.executor_lease_acquired_at } : {}),
-    ...(row.executor_lease_expires_at !== null ? { executorLeaseExpiresAt: row.executor_lease_expires_at } : {}),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    ...(row.closed_at !== null ? { closedAt: row.closed_at } : {}),
-    ...(row.retention_until !== null ? { retentionUntil: row.retention_until } : {}),
-  };
-}
-
-/** Strict codec for the immutable per-attempt journal row. */
-export function workflowJournalRecordFromRow(row: WorkflowStepJournalRow): WorkflowJournalRecord {
-  if (row.outcome !== "completed" && row.outcome !== "failed") {
-    throw new WorkflowJournalCorruptionError(`instance ${row.instance_id} seq ${row.seq} has unknown outcome ${row.outcome}`);
-  }
-  if (![row.seq, row.step_index, row.attempt, row.started_at, row.completed_at].every(Number.isSafeInteger)
-    || row.seq < 1 || row.step_index < 0 || row.attempt < 1 || row.completed_at < row.started_at) {
-    throw new WorkflowJournalCorruptionError(`instance ${row.instance_id} has invalid journal coordinates`);
-  }
-  const label = `instance ${row.instance_id} seq ${row.seq}`;
-  const stateSnapshot = decodeJson(row.state_snapshot, `${label} state_snapshot`);
-  const result = decodeJson(row.result, `${label} result`);
-  const waitFor = row.wait_for === null ? undefined : decodeWaitCondition(decodeJson(row.wait_for, `${label} wait_for`), `${label} wait_for`);
-  if (row.outcome === "completed") {
-    const completed = decodeStepResult(result, `${label} result`);
-    if (!isDeepStrictEqual(completed.state, stateSnapshot)) {
-      throw new WorkflowJournalCorruptionError(`${label} state_snapshot does not match result.state`);
-    }
-    if ((completed.sleepUntil ?? null) !== row.sleep_until || !isDeepStrictEqual(completed.waitFor, waitFor)) {
-      throw new WorkflowJournalCorruptionError(`${label} timer/wait columns do not match result`);
-    }
-  } else if (row.sleep_until !== null || waitFor !== undefined) {
-    throw new WorkflowJournalCorruptionError(`${label} failed attempt cannot schedule a timer or wait`);
-  }
-  return {
-    instanceId: row.instance_id,
-    seq: row.seq,
-    stepIndex: row.step_index,
-    stepName: row.step_name,
-    attempt: row.attempt,
-    outcome: row.outcome,
-    stateSnapshot,
-    result,
-    ...(row.sleep_until !== null ? { sleepUntil: row.sleep_until } : {}),
-    ...(waitFor !== undefined ? { waitFor } : {}),
-    startedAt: row.started_at,
-    completedAt: row.completed_at,
-  };
-}
-
-/** Fold a complete immutable journal into the exact step/attempt at which execution resumes. */
-export function foldWorkflowJournal(instance: WorkflowInstance, records: WorkflowJournalRecord[]): WorkflowResumePoint {
-  if (instance.journalPrunedThrough > 0) {
-    throw new WorkflowJournalCorruptionError(`instance ${instance.id} was pruned through seq ${instance.journalPrunedThrough}`);
-  }
-  let state = instance.initialState;
-  let stepName = instance.startStep;
-  let stepIndex = 0;
-  let nextAttempt = 1;
-  let status: WorkflowResumeStatus = "ready";
-  let sleepUntil: number | undefined;
-  let waitFor: WorkflowWaitCondition | undefined;
-  let output: unknown;
-  let hasOutput = false;
-
-  for (let index = 0; index < records.length; index += 1) {
-    const record = records[index]!;
-    const expectedSeq = index + 1;
-    if (record.instanceId !== instance.id || record.seq !== expectedSeq) {
-      throw new WorkflowJournalCorruptionError(`instance ${instance.id} expected seq ${expectedSeq}`);
-    }
-    if (record.stepIndex !== stepIndex || record.stepName !== stepName || record.attempt !== nextAttempt) {
-      throw new WorkflowJournalCorruptionError(
-        `instance ${instance.id} seq ${record.seq} expected step ${stepIndex}:${stepName} attempt ${nextAttempt}`,
-      );
-    }
-    // Seeing an attempt proves any timer/wait before this step was satisfied.
-    status = "ready";
-    sleepUntil = undefined;
-    waitFor = undefined;
-    if (record.outcome === "failed") {
-      if (!isDeepStrictEqual(record.stateSnapshot, state)) {
-        throw new WorkflowJournalCorruptionError(`instance ${instance.id} seq ${record.seq} failed attempt changed state`);
-      }
-      nextAttempt += 1;
-      continue;
-    }
-    const result = decodeStepResult(record.result, `instance ${instance.id} seq ${record.seq} result`);
-    if (!isDeepStrictEqual(result.state, record.stateSnapshot)) {
-      throw new WorkflowJournalCorruptionError(`instance ${instance.id} seq ${record.seq} state snapshot mismatch`);
-    }
-    state = record.stateSnapshot;
-    stepIndex += 1;
-    nextAttempt = 1;
-    if (result.next === "done") {
-      status = "done";
-      stepName = "";
-      output = result.output;
-      hasOutput = Object.hasOwn(result, "output");
-      if (index !== records.length - 1) throw new WorkflowJournalCorruptionError(`instance ${instance.id} has records after done`);
-      continue;
-    }
-    stepName = result.next;
-    if (result.sleepUntil !== undefined) {
-      status = "sleeping";
-      sleepUntil = result.sleepUntil;
-    } else if (result.waitFor !== undefined) {
-      status = "waiting";
-      waitFor = result.waitFor;
-    }
-  }
-  if (records.length !== instance.journalCursor) {
-    throw new WorkflowJournalCorruptionError(`instance ${instance.id} cursor ${instance.journalCursor} has ${records.length} records`);
-  }
-  if (instance.status === "done" && status !== "done") {
-    throw new WorkflowJournalCorruptionError(`instance ${instance.id} is done without a terminal checkpoint`);
-  }
-  if (instance.status === "failed" || instance.status === "canceled") {
-    status = instance.status;
-  } else if (instance.status === "sleeping") {
-    // The instance row is authoritative for a parked schedule. Two sources land here: a completed
-    // step whose result carried `sleepUntil` (also reconstructable from the record), AND a retry
-    // backoff parked after a FAILED attempt — which the immutable journal record cannot itself
-    // carry (a failed record's timer/wait columns must be null), so its due-time lives only on the
-    // row. Trusting the row unifies both and keeps the fold's resume schedule correct for retries.
-    if (instance.sleepUntil === undefined) {
-      throw new WorkflowJournalCorruptionError(`instance ${instance.id} is sleeping without a sleep_until`);
-    }
-    status = "sleeping";
-    sleepUntil = instance.sleepUntil;
-    waitFor = undefined;
-  } else if (instance.status === "waiting") {
-    if (instance.waitFor === undefined) {
-      throw new WorkflowJournalCorruptionError(`instance ${instance.id} is waiting without a wait_for`);
-    }
-    status = "waiting";
-    waitFor = instance.waitFor;
-    sleepUntil = undefined;
-  }
-  return {
-    instanceId: instance.id,
-    status,
-    state,
-    stepIndex,
-    ...(stepName ? { stepName } : {}),
-    nextAttempt,
-    completedSteps: stepIndex,
-    cursor: instance.journalCursor,
-    ...(sleepUntil !== undefined ? { sleepUntil } : {}),
-    ...(waitFor !== undefined ? { waitFor } : {}),
-    ...(status === "done" && hasOutput ? { output } : {}),
-    ...(instance.failure !== undefined ? { failure: instance.failure } : {}),
-  };
-}