@ai-digital-factory/state-flow-runtime 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,4405 @@
+// src/durable/definition.ts
+import { z } from "zod";
+import { createHash } from "node:crypto";
+
+// src/durable/errors.ts
+var RuntimeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var OwnershipError = class extends RuntimeError {
+};
+var RuntimeClosedError = class extends RuntimeError {
+};
+var ShutdownTimeoutError = class extends RuntimeError {
+};
+var DefinitionError = class extends RuntimeError {
+  problems;
+  constructor(flowName, problems) {
+    super(`Durable flow "${flowName}" is invalid:
+- ${problems.join("\n- ")}`);
+    this.problems = problems;
+  }
+};
+var InputError = class extends RuntimeError {
+};
+var SchemaError = class extends RuntimeError {
+};
+var DefinitionMismatchError = class extends RuntimeError {
+  constructor(context) {
+    super(context.message);
+    this.context = context;
+  }
+  context;
+};
+
+// src/durable/json.ts
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function findNonJsonValue(value, path = "$") {
+  return findNonJson(value, path, /* @__PURE__ */ new Set());
+}
+function findNonJson(value, path, ancestors) {
+  if (value === null) {
+    return null;
+  }
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return null;
+    case "number":
+      return Number.isFinite(value) ? null : `${path} is not a finite number`;
+    case "object": {
+      if (ancestors.has(value)) {
+        return `${path} is a circular reference`;
+      }
+      ancestors.add(value);
+      try {
+        if (Array.isArray(value)) {
+          for (let index = 0; index < value.length; index += 1) {
+            if (!(index in value)) {
+              return `${path}[${index}] is an empty array slot`;
+            }
+            const found = findNonJson(
+              value[index],
+              `${path}[${index}]`,
+              ancestors
+            );
+            if (found) {
+              return found;
+            }
+          }
+          return null;
+        }
+        if (!isPlainObject(value)) {
+          return `${path} is not a plain object`;
+        }
+        for (const key of Object.keys(value)) {
+          const entry = value[key];
+          if (entry === void 0) {
+            continue;
+          }
+          const found = findNonJson(
+            entry,
+            `${path}[${JSON.stringify(key)}]`,
+            ancestors
+          );
+          if (found) {
+            return found;
+          }
+        }
+        return null;
+      } finally {
+        ancestors.delete(value);
+      }
+    }
+    default:
+      return `${path} is ${typeof value}`;
+  }
+}
+function canonicalJson(value) {
+  return writeCanonical(value, /* @__PURE__ */ new Set());
+}
+function writeCanonical(value, ancestors) {
+  if (value === null || typeof value !== "object") {
+    const text = JSON.stringify(value);
+    if (text === void 0) {
+      throw new TypeError(`Cannot serialize ${typeof value} as JSON`);
+    }
+    return text;
+  }
+  if (ancestors.has(value)) {
+    throw new TypeError("Cannot serialize a circular reference as JSON");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return `[${value.map((entry) => writeCanonical(entry ?? null, ancestors)).join(",")}]`;
+    }
+    const parts = [];
+    for (const key of Object.keys(value).sort()) {
+      const entry = value[key];
+      if (entry !== void 0) {
+        parts.push(
+          `${JSON.stringify(key)}:${writeCanonical(entry, ancestors)}`
+        );
+      }
+    }
+    return `{${parts.join(",")}}`;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function parseJson(text) {
+  return text === null ? null : JSON.parse(text);
+}
+
+// src/durable/definition.ts
+function isBranching(transition) {
+  return transition.destinations.length > 1;
+}
+var STRATEGIES = /* @__PURE__ */ new Set([
+  "safe-replay",
+  "reconcile",
+  "manual"
+]);
+var SLOT_EXPORTS = {
+  state: { onEnter: "on-enter", onExit: "on-exit", children: "children" },
+  transition: { guard: "guard", onTransition: "on-transition" },
+  creation: { resolveStartState: "resolve-start-state" }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readCallback(label, kind, value, problems) {
+  if (typeof value === "function") {
+    problems.push(
+      `${label} is a plain function; durable callbacks must declare { run, recovery }`
+    );
+    return null;
+  }
+  if (!isRecord(value) || typeof value.run !== "function") {
+    problems.push(`${label} must be an object with a run function`);
+    return null;
+  }
+  const recovery = value.recovery;
+  if (!isRecord(recovery) || typeof recovery.strategy !== "string") {
+    problems.push(`${label} must declare recovery.strategy`);
+    return null;
+  }
+  if (!STRATEGIES.has(recovery.strategy)) {
+    problems.push(
+      `${label} has unknown recovery strategy ${JSON.stringify(recovery.strategy)}`
+    );
+    return null;
+  }
+  const strategy = recovery.strategy;
+  const hasReconcile = recovery.reconcile !== void 0;
+  if (strategy === "reconcile" && typeof recovery.reconcile !== "function") {
+    problems.push(
+      `${label} uses the reconcile strategy without a reconcile function`
+    );
+    return null;
+  }
+  if (strategy !== "reconcile" && hasReconcile) {
+    problems.push(
+      `${label} declares a reconcile function with the ${strategy} strategy`
+    );
+    return null;
+  }
+  return {
+    kind,
+    strategy,
+    run: value.run,
+    reconcile: strategy === "reconcile" ? recovery.reconcile : null
+  };
+}
+function readSlot(slotKind, label, value, problems) {
+  if (value === null || value === void 0) {
+    return {};
+  }
+  if (!isRecord(value)) {
+    problems.push(`${label} must be a handler module object`);
+    return {};
+  }
+  const exportsForKind = SLOT_EXPORTS[slotKind];
+  const result = {};
+  for (const key of Object.keys(value)) {
+    if (slotKind === "transition" && key === "payloadSchema") continue;
+    const callbackKind = exportsForKind[key];
+    if (!callbackKind) {
+      problems.push(`${label} exports unexpected member "${key}"`);
+      continue;
+    }
+    const callback = readCallback(
+      `${label}.${key}`,
+      callbackKind,
+      value[key],
+      problems
+    );
+    if (callback) {
+      result[key] = callback;
+    }
+  }
+  return result;
+}
+function groupKey(parentId, region) {
+  return parentId === null ? "" : `${parentId}\0${region ?? ""}`;
+}
+function loadFlowDefinition(module, loading = /* @__PURE__ */ new Set()) {
+  const problems = [];
+  if (module.execution !== "durable") {
+    problems.push(
+      "compiled module is not durable; rebuild its handlers package with the current State Flow compiler"
+    );
+  }
+  if (loading.has(module.flowName)) {
+    throw new DefinitionError(module.flowName, [
+      `flow "${module.flowName}" places itself through ${[...loading].join(" \u2192 ")}`
+    ]);
+  }
+  const statesById = /* @__PURE__ */ new Map();
+  const statesByName = /* @__PURE__ */ new Map();
+  const childrenSlots = /* @__PURE__ */ new Map();
+  for (const state of module.states) {
+    const slot = readSlot(
+      "state",
+      `state "${state.name}"`,
+      module.handlers.states[state.id],
+      problems
+    );
+    const final = state.kind === "final";
+    if (final && (slot.onEnter || slot.onExit || slot.children)) {
+      problems.push(`final state "${state.name}" cannot declare callbacks`);
+    }
+    if (slot.children) childrenSlots.set(state.id, slot.children);
+    const parentId = typeof state.parentId === "string" ? state.parentId : null;
+    const definition = {
+      id: state.id,
+      name: state.name,
+      final,
+      onEnter: slot.onEnter ?? null,
+      onExit: slot.onExit ?? null,
+      composition: null,
+      parentId,
+      region: parentId === null ? null : typeof state.region === "string" ? state.region : ""
+    };
+    if (statesByName.has(state.name)) {
+      problems.push(`state name "${state.name}" is declared more than once`);
+    }
+    statesById.set(state.id, definition);
+    statesByName.set(state.name, definition);
+  }
+  for (const state of statesById.values()) {
+    if (state.parentId !== null && !statesById.has(state.parentId)) {
+      problems.push(`state "${state.name}" has an unknown parent`);
+    }
+  }
+  const transitionsByName = /* @__PURE__ */ new Map();
+  const transitionGroups = /* @__PURE__ */ new Map();
+  for (const transition of module.transitions) {
+    const from = statesById.get(transition.fromId);
+    const destinations = (transition.destinations ?? []).map(
+      (destination) => statesById.get(destination.toId)
+    );
+    if (!from || destinations.length === 0 || destinations.some((destination) => destination === void 0)) {
+      problems.push(
+        destinations.length === 0 ? `transition "${transition.name}" declares no destinations; rebuild its handlers package with the current State Flow compiler` : `transition "${transition.name}" references an unknown state`
+      );
+      continue;
+    }
+    if (from.final) {
+      problems.push(
+        `final state "${from.name}" cannot have outgoing transition "${transition.name}"`
+      );
+    }
+    if (new Set(destinations).size !== destinations.length) {
+      problems.push(
+        `transition "${transition.name}" declares a destination more than once`
+      );
+    }
+    const fromGroup = groupKey(from.parentId, from.region);
+    if (destinations.some(
+      (destination) => groupKey(destination.parentId, destination.region) !== fromGroup
+    )) {
+      problems.push(
+        `transition "${transition.name}" must target States of its own region`
+      );
+    }
+    if (transitionsByName.has(transition.name)) {
+      problems.push(
+        `transition name "${transition.name}" is declared more than once`
+      );
+    }
+    const slot = readSlot(
+      "transition",
+      `transition "${transition.name}"`,
+      module.handlers.transitions[transition.name],
+      problems
+    );
+    const payloadSchema = module.payloadSchemas?.[transition.name];
+    if (!(payloadSchema instanceof z.ZodType)) {
+      problems.push(
+        `transition "${transition.name}" must declare a Zod payloadSchema`
+      );
+    }
+    if (destinations.length > 1 && !slot.onTransition) {
+      problems.push(
+        `transition "${transition.name}" has several destinations and must implement onTransition to select one`
+      );
+    }
+    const trigger = transition.trigger === "done" ? "done" : "dispatch";
+    if (transition.trigger !== void 0 && transition.trigger !== "done" && transition.trigger !== "dispatch") {
+      problems.push(`transition "${transition.name}" has an unknown trigger`);
+    }
+    if (transition.childWork !== void 0 && transition.childWork !== "block" && transition.childWork !== "interrupt") {
+      problems.push(
+        `transition "${transition.name}" has an unknown childWork policy`
+      );
+    }
+    const definition = {
+      name: transition.name,
+      payloadSchema: payloadSchema instanceof z.ZodType ? payloadSchema : z.never(),
+      from,
+      destinations,
+      guard: slot.guard ?? null,
+      onTransition: slot.onTransition ?? null,
+      childWork: transition.childWork === "interrupt" ? "interrupt" : "block",
+      trigger
+    };
+    transitionsByName.set(transition.name, definition);
+    const group = transitionGroups.get(fromGroup) ?? [];
+    group.push(definition);
+    transitionGroups.set(fromGroup, group);
+  }
+  const creation = readSlot(
+    "creation",
+    "creation handler",
+    module.handlers.creation,
+    problems
+  );
+  const initialState = statesById.get(module.initialStateId);
+  if (!initialState || initialState.parentId !== null) {
+    problems.push(`initial state id "${module.initialStateId}" is unknown`);
+  }
+  const inputSchema = module.inputSchema === void 0 || module.inputSchema === null ? null : module.inputSchema instanceof z.ZodType ? module.inputSchema : (problems.push("inputSchema must be a Zod schema"), null);
+  const placed = /* @__PURE__ */ new Map();
+  const placedModules = module.placedFlows ?? {};
+  const loadPlaced = (flow) => {
+    const cached = placed.get(flow);
+    if (cached) return cached;
+    const placedModule = placedModules[flow];
+    if (!isRecord(placedModule)) {
+      problems.push(
+        `placed flow "${flow}" is missing from the compiled module`
+      );
+      return null;
+    }
+    try {
+      const loaded = loadFlowDefinition(
+        placedModule,
+        /* @__PURE__ */ new Set([...loading, module.flowName])
+      );
+      placed.set(flow, loaded);
+      return loaded;
+    } catch (error) {
+      problems.push(
+        error instanceof DefinitionError ? `placed flow "${flow}": ${error.problems.join("; ")}` : `placed flow "${flow}" failed to load: ${String(error)}`
+      );
+      return null;
+    }
+  };
+  const groups = /* @__PURE__ */ new Map();
+  for (const state of statesById.values()) {
+    const key = groupKey(state.parentId, state.region);
+    const group = groups.get(key) ?? [];
+    group.push(state);
+    groups.set(key, group);
+  }
+  const graphs = /* @__PURE__ */ new Map();
+  const buildGraph = (key, groupId, initial, resolveStartState) => {
+    const graph = {
+      key,
+      flowName: module.flowName,
+      initialState: initial,
+      statesByName: new Map(
+        (groups.get(groupId) ?? []).map((state) => [state.name, state])
+      ),
+      transitionsByName: new Map(
+        (transitionGroups.get(groupId) ?? []).map((transition) => [
+          transition.name,
+          transition
+        ])
+      ),
+      resolveStartState,
+      inputSchema
+    };
+    graphs.set(key, graph);
+    return graph;
+  };
+  const compositionIdentity = [];
+  const composite = (module.compositions ?? []).length > 0;
+  for (const entry of module.compositions ?? []) {
+    const state = statesById.get(entry.stateId);
+    if (!state) {
+      problems.push(
+        `composition references unknown state id "${entry.stateId}"`
+      );
+      continue;
+    }
+    if (state.final) {
+      problems.push(`final state "${state.name}" cannot be composite`);
+    }
+    if (entry.kind !== "compound" && entry.kind !== "parallel") {
+      problems.push(`state "${state.name}" has an unknown composition kind`);
+      continue;
+    }
+    const kind = entry.kind;
+    if (entry.regions.length === 0 || kind === "compound" && entry.regions.length !== 1) {
+      problems.push(
+        `state "${state.name}" must declare ${kind === "compound" ? "exactly one" : "at least one"} region`
+      );
+    }
+    const regions = [];
+    const regionIdentity = [];
+    let needsChildren = false;
+    for (const region of entry.regions) {
+      const segment = kind === "compound" ? state.name : `${state.name}:${region.name}`;
+      if (region.kind === "inline") {
+        const groupId = groupKey(state.id, region.name);
+        const initial = typeof region.defaultId === "string" ? statesById.get(region.defaultId) : void 0;
+        if (!initial || groupKey(initial.parentId, initial.region) !== groupId) {
+          problems.push(
+            `region "${region.name}" of state "${state.name}" must default to one of its own States`
+          );
+          continue;
+        }
+        const graph = buildGraph(
+          `${module.flowName}#${segment}`,
+          groupId,
+          initial,
+          null
+        );
+        regions.push({
+          name: region.name,
+          kind: "inline",
+          segment,
+          graph,
+          flowName: null
+        });
+        regionIdentity.push({
+          name: region.name,
+          kind: "inline",
+          default: initial.id
+        });
+      } else if ((region.kind === "flow" || region.kind === "list") && typeof region.flow === "string") {
+        const child = loadPlaced(region.flow);
+        if (!child) continue;
+        for (const [key, graph] of child.graphs) {
+          graphs.set(key, graph);
+        }
+        if (region.kind === "list" || child.inputSchema !== null) {
+          needsChildren = true;
+        }
+        regions.push({
+          name: region.name,
+          kind: region.kind,
+          segment,
+          graph: child.graphs.get(child.flowName),
+          flowName: child.flowName
+        });
+        regionIdentity.push({
+          name: region.name,
+          kind: region.kind,
+          flow: child.definitionId
+        });
+      } else {
+        problems.push(
+          `region "${region.name}" of state "${state.name}" has an unknown kind`
+        );
+      }
+    }
+    const children = childrenSlots.get(state.id) ?? null;
+    if (needsChildren && !children) {
+      problems.push(
+        `state "${state.name}" must implement children to supply its children's input and FlowList members`
+      );
+    }
+    const done = [...transitionsByName.values()].find(
+      (transition) => transition.from === state && transition.trigger === "done"
+    ) ?? null;
+    state.composition = { kind, regions, children, done };
+    compositionIdentity.push({
+      state: state.id,
+      kind,
+      regions: regionIdentity,
+      children: children === null ? null : children.strategy
+    });
+  }
+  for (const [stateId, slot] of childrenSlots) {
+    if (statesById.get(stateId)?.composition === null) {
+      problems.push(
+        `state "${statesById.get(stateId)?.name}" implements children but has no nested regions`
+      );
+    }
+    void slot;
+  }
+  for (const transition of transitionsByName.values()) {
+    if (transition.trigger === "done" && transition.from.composition === null) {
+      problems.push(
+        `transition "${transition.name}" fires on completion but "${transition.from.name}" has no nested regions`
+      );
+    }
+    if (transition.childWork === "interrupt" && transition.from.composition === null) {
+      problems.push(
+        `transition "${transition.name}" interrupts child work but "${transition.from.name}" has no nested regions`
+      );
+    }
+  }
+  if (problems.length > 0 || !initialState) {
+    throw new DefinitionError(module.flowName, problems);
+  }
+  const rootGraph = buildGraph(
+    module.flowName,
+    "",
+    initialState,
+    creation.resolveStartState ?? null
+  );
+  const strategyOf = (callback) => callback === null ? null : callback.strategy;
+  const identitySource = {
+    // Persisted identity key: renaming it would change every stored definition identity.
+    chartName: module.flowName,
+    initialStateId: module.initialStateId,
+    // Fields are added only for new graph features, so flows without them keep their identity.
+    states: [...statesById.values()].map((state) => ({
+      id: state.id,
+      name: state.name,
+      onEnter: strategyOf(state.onEnter),
+      onExit: strategyOf(state.onExit),
+      ...state.final ? { final: true } : {},
+      ...state.parentId !== null ? { parent: state.parentId, region: state.region } : {}
+    })),
+    transitions: [...transitionsByName.values()].map((transition) => ({
+      name: transition.name,
+      from: transition.from.id,
+      ...isBranching(transition) ? { destinations: transition.destinations.map((state) => state.id) } : { to: transition.destinations[0].id },
+      guard: strategyOf(transition.guard),
+      onTransition: strategyOf(transition.onTransition),
+      ...transition.childWork === "interrupt" ? { childWork: "interrupt" } : {},
+      ...transition.trigger === "done" ? { trigger: "done" } : {}
+    })),
+    resolveStartState: strategyOf(creation.resolveStartState ?? null),
+    ...composite ? { compositions: compositionIdentity } : {}
+  };
+  const definitionId = `def_${createHash("sha256").update(canonicalJson(identitySource)).digest("hex").slice(0, 32)}`;
+  return {
+    ...rootGraph,
+    definitionId,
+    graphs,
+    composite,
+    placed,
+    handlerRevision: typeof module.handlerRevision === "string" ? module.handlerRevision : null
+  };
+}
+
+// src/durable/engine.ts
+import { z as z2 } from "zod";
+
+// src/durable/deployment.ts
+import { existsSync } from "node:fs";
+
+// src/durable/store.ts
+import { DatabaseSync } from "node:sqlite";
+var SCHEMA_VERSION = 3;
+var MIGRATIONS = {
+  // v1 (first durable runtime) lacked per-execution handler revisions (ADR 0076).
+  1: "ALTER TABLE executions ADD COLUMN handler_revision TEXT;",
+  // v2 → v3: nested scopes and the late-outcome outbox (ADR 0095, 0096). Existing rows are roots.
+  2: `
+ALTER TABLE instances ADD COLUMN root_instance_id TEXT;
+ALTER TABLE instances ADD COLUMN parent_instance_id TEXT;
+ALTER TABLE instances ADD COLUMN scope_path TEXT;
+ALTER TABLE instances ADD COLUMN segment TEXT;
+ALTER TABLE instances ADD COLUMN graph TEXT;
+ALTER TABLE instances ADD COLUMN activation_id TEXT;
+ALTER TABLE instances ADD COLUMN member_key TEXT;
+ALTER TABLE instances ADD COLUMN input_json TEXT;
+ALTER TABLE instances ADD COLUMN position INTEGER;
+ALTER TABLE instances ADD COLUMN active INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE instances ADD COLUMN exit_reason TEXT;
+ALTER TABLE instances ADD COLUMN children_activation_id TEXT;
+CREATE INDEX instances_by_root ON instances (root_instance_id);
+CREATE INDEX instances_by_parent ON instances (parent_instance_id);
+CREATE TABLE late_outcomes (
+  sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+  root_instance_id TEXT NOT NULL,
+  scope_instance_id TEXT NOT NULL,
+  scope_path TEXT NOT NULL,
+  activation_id TEXT NOT NULL,
+  member_key TEXT,
+  operation_id TEXT NOT NULL,
+  callback_kind TEXT NOT NULL,
+  callback_target TEXT,
+  source TEXT NOT NULL,
+  result_json TEXT NOT NULL,
+  recorded_at TEXT NOT NULL,
+  acknowledged_at TEXT
+);
+CREATE INDEX late_outcomes_pending ON late_outcomes (acknowledged_at, sequence);
+`
+};
+var SCHEMA = `
+CREATE TABLE instances (
+  instance_id TEXT PRIMARY KEY,
+  chart_name TEXT NOT NULL,
+  definition_id TEXT NOT NULL,
+  state TEXT NOT NULL,
+  status TEXT NOT NULL,
+  status_reason TEXT,
+  current_execution_id TEXT,
+  revision INTEGER NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE TABLE executions (
+  execution_id TEXT PRIMARY KEY,
+  instance_id TEXT NOT NULL REFERENCES instances(instance_id),
+  kind TEXT NOT NULL,
+  request_id TEXT,
+  input_json TEXT NOT NULL,
+  from_state TEXT,
+  transition TEXT,
+  to_state TEXT,
+  step TEXT NOT NULL,
+  status TEXT NOT NULL,
+  handler_revision TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (instance_id, request_id)
+);
+CREATE TABLE operations (
+  operation_id TEXT PRIMARY KEY,
+  execution_id TEXT NOT NULL REFERENCES executions(execution_id),
+  instance_id TEXT NOT NULL REFERENCES instances(instance_id),
+  callback_kind TEXT NOT NULL,
+  callback_target TEXT,
+  strategy TEXT NOT NULL,
+  status TEXT NOT NULL,
+  result_json TEXT,
+  attempts INTEGER NOT NULL,
+  attempt_limit INTEGER NOT NULL,
+  last_error TEXT,
+  last_cause TEXT,
+  next_attempt_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (execution_id, callback_kind)
+);
+CREATE TABLE attempts (
+  attempt_id TEXT PRIMARY KEY,
+  operation_id TEXT NOT NULL REFERENCES operations(operation_id),
+  mode TEXT NOT NULL,
+  number INTEGER NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  outcome TEXT,
+  error TEXT
+);
+CREATE TABLE history (
+  sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+  instance_id TEXT NOT NULL REFERENCES instances(instance_id),
+  at TEXT NOT NULL,
+  type TEXT NOT NULL,
+  request_id TEXT,
+  operation_id TEXT,
+  attempt_id TEXT,
+  data_json TEXT NOT NULL
+);
+CREATE INDEX history_by_instance ON history (instance_id, sequence);
+`;
+var BLOCKING_STATUSES = [
+  "running",
+  "recovering",
+  "needs-attention"
+];
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var SqliteStore = class {
+  db;
+  transactionDepth = 0;
+  pendingEffects = [];
+  open = true;
+  /**
+   * `inspect` opens an existing database without creating or upgrading its schema, for
+   * read-only checks that still need ownership (the deployment check).
+   */
+  constructor(databasePath, options = {}) {
+    this.db = new DatabaseSync(databasePath, { timeout: 0 });
+    try {
+      this.db.exec("PRAGMA locking_mode = EXCLUSIVE;");
+      this.db.exec("PRAGMA synchronous = FULL;");
+      this.db.exec("PRAGMA foreign_keys = ON;");
+      this.db.exec("BEGIN EXCLUSIVE; COMMIT;");
+    } catch (cause) {
+      this.db.close();
+      throw new OwnershipError(
+        `Another State Flow runtime owns ${databasePath}`,
+        { cause }
+      );
+    }
+    if (options.mode === "inspect") {
+      this.requireCurrentSchema(databasePath);
+    } else {
+      this.migrate();
+    }
+  }
+  schemaVersion() {
+    const { user_version: version } = this.db.prepare("PRAGMA user_version").get();
+    return version;
+  }
+  requireCurrentSchema(databasePath) {
+    const version = this.schemaVersion();
+    if (version === 0 || version > SCHEMA_VERSION) {
+      this.close();
+      throw new SchemaError(
+        version === 0 ? `${databasePath} is not a State Flow database` : `Database schema version ${version} is newer than supported version ${SCHEMA_VERSION}`
+      );
+    }
+  }
+  migrate() {
+    const version = this.schemaVersion();
+    if (version > SCHEMA_VERSION) {
+      this.db.close();
+      throw new SchemaError(
+        `Database schema version ${version} is newer than supported version ${SCHEMA_VERSION}`
+      );
+    }
+    if (version > 0 && version < SCHEMA_VERSION) {
+      this.transaction(() => {
+        for (let from = version; from < SCHEMA_VERSION; from += 1) {
+          const migration = MIGRATIONS[from];
+          if (migration === void 0) {
+            throw new SchemaError(`No migration from schema version ${from}`);
+          }
+          this.db.exec(migration);
+        }
+        this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+      });
+    }
+    if (version === 0) {
+      this.transaction(() => {
+        this.db.exec(SCHEMA);
+        for (let from = 2; from < SCHEMA_VERSION; from += 1) {
+          this.db.exec(MIGRATIONS[from]);
+        }
+        this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+      });
+    }
+  }
+  get isOpen() {
+    return this.open;
+  }
+  close() {
+    if (this.open) {
+      this.open = false;
+      this.db.close();
+    }
+  }
+  /** Runs `work` atomically. Nested calls join the outer transaction. */
+  transaction(work) {
+    if (this.transactionDepth > 0) {
+      return work();
+    }
+    this.db.exec("BEGIN IMMEDIATE");
+    this.transactionDepth += 1;
+    let committed = false;
+    try {
+      const result = work();
+      this.db.exec("COMMIT");
+      committed = true;
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    } finally {
+      this.transactionDepth -= 1;
+      const effects = this.pendingEffects.splice(0);
+      if (committed) {
+        for (const effect of effects) {
+          effect();
+        }
+      }
+    }
+  }
+  /**
+   * Runs `effect` once the current transaction commits (immediately outside one), and drops it
+   * on rollback. Used for notifications and timers, which must reflect committed state only.
+   */
+  afterCommit(effect) {
+    if (this.transactionDepth > 0) {
+      this.pendingEffects.push(effect);
+    } else {
+      effect();
+    }
+  }
+  // --- instances -----------------------------------------------------------
+  getInstance(instanceId2) {
+    return this.db.prepare("SELECT * FROM instances WHERE instance_id = ?").get(instanceId2);
+  }
+  insertInstance(row) {
+    const at = nowIso();
+    this.db.prepare(
+      `INSERT INTO instances (instance_id, chart_name, definition_id, state, status, status_reason,
+           current_execution_id, revision, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`
+    ).run(
+      row.instance_id,
+      row.chart_name,
+      row.definition_id,
+      row.state,
+      row.status,
+      row.status_reason,
+      row.current_execution_id,
+      at,
+      at
+    );
+  }
+  /** Inserts a nested scope row (ADR 0096). */
+  insertScope(row) {
+    const at = nowIso();
+    this.db.prepare(
+      `INSERT INTO instances (instance_id, chart_name, definition_id, state, status, status_reason,
+           current_execution_id, revision, created_at, updated_at, root_instance_id, parent_instance_id,
+           scope_path, segment, graph, activation_id, member_key, input_json, position, active)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)`
+    ).run(
+      row.instance_id,
+      row.chart_name,
+      row.definition_id,
+      row.state,
+      row.status,
+      row.status_reason,
+      row.current_execution_id,
+      at,
+      at,
+      row.root_instance_id,
+      row.parent_instance_id,
+      row.scope_path,
+      row.segment,
+      row.graph,
+      row.activation_id,
+      row.member_key,
+      row.input_json,
+      row.position
+    );
+  }
+  getScope(instanceId2) {
+    return this.getInstance(instanceId2);
+  }
+  /** Every scope of a root, parents before children (by path depth, then authored position). */
+  listScopes(rootInstanceId) {
+    return this.db.prepare(
+      `SELECT * FROM instances WHERE root_instance_id = ?
+         ORDER BY length(scope_path) - length(replace(scope_path, '/', '')) ASC, created_at ASC, position ASC`
+    ).all(rootInstanceId);
+  }
+  /** Direct child scopes of one scope (or root). */
+  listChildScopes(parentInstanceId) {
+    return this.db.prepare(
+      "SELECT * FROM instances WHERE parent_instance_id = ? ORDER BY position ASC"
+    ).all(parentInstanceId);
+  }
+  updateScope(instanceId2, changes) {
+    this.update("instances", "instance_id", instanceId2, changes, {
+      bumpRevision: true
+    });
+  }
+  /** Latest execution with this request ID in any scope of a root at this path and member key. */
+  findScopedExecutionByRequest(rootInstanceId, scopePath, memberKey, requestId2) {
+    return this.db.prepare(
+      `SELECT executions.* FROM executions JOIN instances ON instances.instance_id = executions.instance_id
+         WHERE instances.root_instance_id = ? AND instances.scope_path = ?
+           AND instances.member_key IS ? AND executions.request_id = ?
+         ORDER BY executions.created_at DESC LIMIT 1`
+    ).get(rootInstanceId, scopePath, memberKey, requestId2);
+  }
+  /** Handler revisions of unfinished executions across a root and its scopes. */
+  unfinishedHandlerRevisions(rootInstanceId) {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT executions.handler_revision AS revision FROM executions
+         JOIN instances ON instances.instance_id = executions.instance_id
+         WHERE (instances.instance_id = ? OR instances.root_instance_id = ?)
+           AND executions.execution_id = instances.current_execution_id
+           AND instances.status IN ('running', 'recovering', 'needs-attention')`
+    ).all(rootInstanceId, rootInstanceId);
+    return rows.map((row) => row.revision);
+  }
+  // --- late outcomes (ADR 0096) ---------------------------------------------
+  insertLateOutcome(row) {
+    this.db.prepare(
+      `INSERT INTO late_outcomes (root_instance_id, scope_instance_id, scope_path, activation_id, member_key,
+           operation_id, callback_kind, callback_target, source, result_json, recorded_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      row.root_instance_id,
+      row.scope_instance_id,
+      row.scope_path,
+      row.activation_id,
+      row.member_key,
+      row.operation_id,
+      row.callback_kind,
+      row.callback_target,
+      row.source,
+      row.result_json,
+      nowIso()
+    );
+  }
+  listPendingLateOutcomes(rootInstanceId) {
+    return rootInstanceId === null ? this.db.prepare(
+      "SELECT * FROM late_outcomes WHERE acknowledged_at IS NULL ORDER BY sequence ASC"
+    ).all() : this.db.prepare(
+      "SELECT * FROM late_outcomes WHERE acknowledged_at IS NULL AND root_instance_id = ? ORDER BY sequence ASC"
+    ).all(rootInstanceId);
+  }
+  getLateOutcome(sequence) {
+    return this.db.prepare("SELECT * FROM late_outcomes WHERE sequence = ?").get(sequence);
+  }
+  acknowledgeLateOutcome(sequence) {
+    const result = this.db.prepare(
+      "UPDATE late_outcomes SET acknowledged_at = ? WHERE sequence = ? AND acknowledged_at IS NULL"
+    ).run(nowIso(), sequence);
+    return Number(result.changes) > 0;
+  }
+  updateInstance(instanceId2, changes) {
+    this.update("instances", "instance_id", instanceId2, changes, {
+      bumpRevision: true
+    });
+  }
+  // --- executions ----------------------------------------------------------
+  getExecution(executionId) {
+    return this.db.prepare("SELECT * FROM executions WHERE execution_id = ?").get(executionId);
+  }
+  findExecutionByRequest(instanceId2, requestId2) {
+    return this.db.prepare(
+      "SELECT * FROM executions WHERE instance_id = ? AND request_id = ?"
+    ).get(instanceId2, requestId2);
+  }
+  insertExecution(row) {
+    const at = nowIso();
+    this.db.prepare(
+      `INSERT INTO executions (execution_id, instance_id, kind, request_id, input_json, from_state,
+           transition, to_state, step, status, handler_revision, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      row.execution_id,
+      row.instance_id,
+      row.kind,
+      row.request_id,
+      row.input_json,
+      row.from_state,
+      row.transition,
+      row.to_state,
+      row.step,
+      row.status,
+      row.handler_revision,
+      at,
+      at
+    );
+  }
+  updateExecution(executionId, changes) {
+    this.update("executions", "execution_id", executionId, changes);
+  }
+  // --- operations ----------------------------------------------------------
+  getOperation(operationId) {
+    return this.db.prepare("SELECT * FROM operations WHERE operation_id = ?").get(operationId);
+  }
+  findOperation(executionId, kind) {
+    return this.db.prepare(
+      "SELECT * FROM operations WHERE execution_id = ? AND callback_kind = ?"
+    ).get(executionId, kind);
+  }
+  /** The execution's operation that is not completed, if any. */
+  findUnresolvedOperation(executionId) {
+    return this.db.prepare(
+      "SELECT * FROM operations WHERE execution_id = ? AND status != 'completed' ORDER BY created_at DESC LIMIT 1"
+    ).get(executionId);
+  }
+  insertOperation(row) {
+    const at = nowIso();
+    this.db.prepare(
+      `INSERT INTO operations (operation_id, execution_id, instance_id, callback_kind, callback_target,
+           strategy, status, attempts, attempt_limit, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      row.operation_id,
+      row.execution_id,
+      row.instance_id,
+      row.callback_kind,
+      row.callback_target,
+      row.strategy,
+      row.status,
+      row.attempts,
+      row.attempt_limit,
+      at,
+      at
+    );
+  }
+  updateOperation(operationId, changes) {
+    this.update("operations", "operation_id", operationId, changes);
+  }
+  // --- attempts ------------------------------------------------------------
+  insertAttempt(row) {
+    this.db.prepare(
+      "INSERT INTO attempts (attempt_id, operation_id, mode, number, started_at) VALUES (?, ?, ?, ?, ?)"
+    ).run(row.attempt_id, row.operation_id, row.mode, row.number, nowIso());
+  }
+  finishAttempt(attemptId, outcome, error) {
+    this.db.prepare(
+      "UPDATE attempts SET finished_at = ?, outcome = ?, error = ? WHERE attempt_id = ?"
+    ).run(nowIso(), outcome, error, attemptId);
+  }
+  /** Attempts left open by a process that stopped mid-callback. */
+  finishInterruptedAttempts(operationId) {
+    this.db.prepare(
+      "UPDATE attempts SET finished_at = ?, outcome = 'interrupted' WHERE operation_id = ? AND finished_at IS NULL"
+    ).run(nowIso(), operationId);
+  }
+  // --- history -------------------------------------------------------------
+  appendHistory(row) {
+    this.db.prepare(
+      `INSERT INTO history (instance_id, at, type, request_id, operation_id, attempt_id, data_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      row.instance_id,
+      nowIso(),
+      row.type,
+      row.request_id,
+      row.operation_id,
+      row.attempt_id,
+      row.data_json
+    );
+  }
+  /** One page of history in sequence order, after `afterSequence` (exclusive). */
+  listHistory(instanceId2, page) {
+    return this.db.prepare(
+      "SELECT * FROM history WHERE instance_id = ? AND sequence > ? ORDER BY sequence ASC LIMIT ?"
+    ).all(instanceId2, page.afterSequence, page.limit);
+  }
+  /** One page of instances ordered by ID, after `afterInstanceId` (exclusive). */
+  listInstances(query) {
+    const where = ["root_instance_id IS NULL"];
+    const values = [];
+    if (query.flowName !== null) {
+      where.push("chart_name = ?");
+      values.push(query.flowName);
+    }
+    if (query.statuses !== null) {
+      if (query.statuses.length === 0) {
+        return [];
+      }
+      where.push(`status IN (${query.statuses.map(() => "?").join(", ")})`);
+      values.push(...query.statuses);
+    }
+    if (query.afterInstanceId !== null) {
+      where.push("instance_id > ?");
+      values.push(query.afterInstanceId);
+    }
+    const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    return this.db.prepare(
+      `SELECT * FROM instances ${clause} ORDER BY instance_id ASC LIMIT ?`
+    ).all(...values, query.limit);
+  }
+  /**
+   * Every instance with unfinished execution (running, recovering or needs attention), ordered
+   * by ID. Unpaged: a deployment decision must see all of them.
+   */
+  listUnfinishedInstances() {
+    return this.db.prepare(
+      `SELECT * FROM instances WHERE status IN (${BLOCKING_STATUSES.map(() => "?").join(", ")}) ORDER BY instance_id ASC`
+    ).all(...BLOCKING_STATUSES);
+  }
+  // --- helpers -------------------------------------------------------------
+  update(table, keyColumn, key, changes, options = {}) {
+    const columns = Object.keys(changes).filter(
+      (column) => changes[column] !== void 0
+    );
+    const assignments = columns.map((column) => `${column} = ?`);
+    assignments.push("updated_at = ?");
+    if (options.bumpRevision) {
+      assignments.push("revision = revision + 1");
+    }
+    const values = columns.map((column) => changes[column] ?? null);
+    this.db.prepare(
+      `UPDATE ${table} SET ${assignments.join(", ")} WHERE ${keyColumn} = ?`
+    ).run(...values, nowIso(), key);
+  }
+};
+
+// src/durable/deployment.ts
+function deploymentBlockers(store) {
+  return Object.freeze(
+    store.listUnfinishedInstances().map((row) => toBlocker(store, row)).sort(
+      (a, b) => a.instanceId < b.instanceId ? -1 : a.instanceId > b.instanceId ? 1 : 0
+    )
+  );
+}
+function toBlocker(store, row) {
+  const root = row.root_instance_id === null || row.root_instance_id === void 0 ? void 0 : store.getInstance(row.root_instance_id);
+  return Object.freeze({
+    instanceId: root?.instance_id ?? row.instance_id,
+    flowName: root?.chart_name ?? row.chart_name,
+    state: row.state,
+    status: row.status,
+    statusReason: row.status_reason,
+    scope: root === void 0 ? null : Object.freeze({
+      path: row.scope_path ?? "",
+      activationId: row.activation_id ?? "",
+      memberKey: row.member_key ?? null,
+      active: row.active === 1
+    })
+  });
+}
+function checkDeployment(options) {
+  const { databasePath } = options;
+  if (!existsSync(databasePath)) {
+    throw new InputError(`No State Flow database exists at ${databasePath}`);
+  }
+  let store;
+  try {
+    store = new SqliteStore(databasePath, { mode: "inspect" });
+  } catch (error) {
+    if (error instanceof OwnershipError) {
+      return Object.freeze({ outcome: "owned", message: error.message });
+    }
+    throw error;
+  }
+  try {
+    const blockers = deploymentBlockers(store);
+    return blockers.length > 0 ? Object.freeze({ outcome: "blocked", blockers }) : Object.freeze({ outcome: "ready" });
+  } finally {
+    store.close();
+  }
+}
+
+// src/durable/ids.ts
+import { randomUUID } from "node:crypto";
+var MAX_ID_LENGTH = 256;
+var CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+function validateApplicationId(kind, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new InputError(`${kind} must be a non-empty string`);
+  }
+  if (value.length > MAX_ID_LENGTH) {
+    throw new InputError(`${kind} must be at most ${MAX_ID_LENGTH} characters`);
+  }
+  if (CONTROL_CHARACTERS.test(value)) {
+    throw new InputError(`${kind} must not contain control characters`);
+  }
+  return value;
+}
+function instanceId(value) {
+  return validateApplicationId("instanceId", value);
+}
+function requestId(value) {
+  return validateApplicationId("requestId", value);
+}
+function mintOperationId() {
+  return `op_${randomUUID()}`;
+}
+function mintAttemptId() {
+  return `att_${randomUUID()}`;
+}
+function mintExecutionId() {
+  return `exe_${randomUUID()}`;
+}
+
+// src/durable/engine.ts
+var MAX_ATTEMPTS = 4;
+function clampLimit(value, fallback, max) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(max, Math.max(1, Math.floor(value)));
+}
+var RECOVERY_DELAYS_MS = [1e3, 5e3, 3e4];
+var BUSY_RETRY_DELAY_MS = 100;
+var InstanceCore = class {
+  constructor(id, flow, scope = null) {
+    this.id = id;
+    this.flow = flow;
+    this.scope = scope;
+  }
+  id;
+  flow;
+  scope;
+  listeners = /* @__PURE__ */ new Set();
+  /** Aborted when a parent Transition interrupts this scope; never for a root (ADR 0095). */
+  abort = new AbortController();
+  activeExecutionId = null;
+  timer = null;
+  infrastructureRetries = 0;
+  /**
+   * Set when an infrastructure error stopped execution in this process; shown in snapshots.
+   * `restartRecovery` or opening the instance again resumes from persisted state.
+   */
+  stall = null;
+  get stalled() {
+    return this.stall !== null;
+  }
+  /** The root instance this core belongs to (itself for a root). */
+  get rootId() {
+    return this.scope?.rootId ?? this.id;
+  }
+};
+var VOID_CALLBACKS = /* @__PURE__ */ new Set([
+  "on-enter",
+  "on-exit"
+]);
+var PARENT_EXIT_TRANSITION_NAME = "parent-exit";
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+function delayAfterAttempt(attempts) {
+  return RECOVERY_DELAYS_MS[attempts - 1] ?? RECOVERY_DELAYS_MS[RECOVERY_DELAYS_MS.length - 1];
+}
+function validateCallbackResult(definition, kind, value, transitionName, stateName = null) {
+  if (VOID_CALLBACKS.has(kind)) {
+    return { ok: true, result: null };
+  }
+  if (kind === "children") {
+    return validateChildInputs(
+      definition.statesByName.get(stateName ?? ""),
+      value
+    );
+  }
+  if (kind === "on-transition") {
+    const transition = definition.transitionsByName.get(transitionName ?? "");
+    if (!transition || !isBranching(transition)) {
+      return { ok: true, result: null };
+    }
+    const names = transition.destinations.map((state) => state.name);
+    const parsed2 = z2.enum(names).safeParse(value);
+    return parsed2.success ? { ok: true, result: parsed2.data } : {
+      ok: false,
+      message: `onTransition for "${transition.name}" must return one of its destinations (${names.map((name) => JSON.stringify(name)).join(", ")}); received ${value === void 0 ? "nothing" : JSON.stringify(value)}`
+    };
+  }
+  const schema = kind === "guard" ? z2.boolean() : z2.enum([...definition.statesByName.keys()]);
+  const parsed = schema.safeParse(value);
+  return parsed.success ? { ok: true, result: parsed.data } : {
+    ok: false,
+    message: `${kind === "guard" ? "guard result must be a boolean" : "start state must be an authored state"}: ${parsed.error.message}`
+  };
+}
+function validateChildInputs(state, value) {
+  const composition = state?.composition;
+  if (!state || !composition) {
+    return { ok: false, message: "children runs only for a composite State" };
+  }
+  const problem = findNonJsonValue(value ?? null);
+  if (problem) {
+    return { ok: false, message: `children result is not JSON: ${problem}` };
+  }
+  const supplied = value ?? {};
+  if (typeof supplied !== "object" || Array.isArray(supplied)) {
+    return { ok: false, message: "children must return an object" };
+  }
+  const result = {};
+  const expected = /* @__PURE__ */ new Set();
+  const checkInput = (graph, input, label) => {
+    const schema = graph.inputSchema;
+    if (schema === null) {
+      return input === void 0 || input === null ? null : `${label} takes no input`;
+    }
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+      return `${label} input is invalid: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`;
+    }
+    if (canonicalJson(parsed.data) !== canonicalJson(input ?? null)) {
+      return `${label} input schema must preserve the JSON input`;
+    }
+    return null;
+  };
+  for (const region of composition.regions) {
+    if (region.kind === "inline") continue;
+    expected.add(region.name);
+    const supplied_ = supplied[region.name];
+    if (region.kind === "flow") {
+      const issue = checkInput(region.graph, supplied_, `"${region.name}"`);
+      if (issue) return { ok: false, message: issue };
+      if (region.graph.inputSchema !== null) {
+        result[region.name] = supplied_;
+      }
+      continue;
+    }
+    if (!Array.isArray(supplied_)) {
+      return {
+        ok: false,
+        message: `FlowList "${region.name}" needs an array of { key, input } members`
+      };
+    }
+    const keys = /* @__PURE__ */ new Set();
+    const members = [];
+    for (const [index, member] of supplied_.entries()) {
+      const record = member;
+      if (typeof record !== "object" || record === null || typeof record.key !== "string" || record.key.length === 0 || Object.keys(record).some((key) => key !== "key" && key !== "input")) {
+        return {
+          ok: false,
+          message: `FlowList "${region.name}" member ${index} must be { key: non-empty string, input }`
+        };
+      }
+      if (keys.has(record.key)) {
+        return {
+          ok: false,
+          message: `FlowList "${region.name}" has duplicate key ${JSON.stringify(record.key)}`
+        };
+      }
+      keys.add(record.key);
+      const issue = checkInput(
+        region.graph,
+        record.input,
+        `FlowList "${region.name}" member ${JSON.stringify(record.key)}`
+      );
+      if (issue) return { ok: false, message: issue };
+      members.push({
+        key: record.key,
+        input: record.input ?? null
+      });
+    }
+    result[region.name] = members;
+  }
+  const unexpected = Object.keys(supplied).filter((key) => !expected.has(key));
+  if (unexpected.length > 0) {
+    return {
+      ok: false,
+      message: `children returned unknown regions: ${unexpected.join(", ")}`
+    };
+  }
+  return { ok: true, result };
+}
+var RuntimeCore = class {
+  constructor(store, onObserverError, onRecoveryError) {
+    this.store = store;
+    this.onObserverError = onObserverError;
+    this.onRecoveryError = onRecoveryError;
+  }
+  store;
+  onObserverError;
+  onRecoveryError;
+  instances = /* @__PURE__ */ new Map();
+  /** Late outcome listeners (ADR 0096); delivery happens after commit. */
+  lateListeners = /* @__PURE__ */ new Set();
+  /** Dependencies of a registered flow by name, for placed flows (ADR 0096). */
+  dependenciesOf = () => void 0;
+  graphCores = /* @__PURE__ */ new WeakMap();
+  active = /* @__PURE__ */ new Set();
+  abort = new AbortController();
+  closing = false;
+  closePromise = null;
+  assertOpen() {
+    if (this.closing) {
+      throw new RuntimeClosedError("The durable runtime is closed");
+    }
+  }
+  /**
+   * Stops admission and scheduling, aborts the shared signal, waits for active callbacks to
+   * settle and checkpoint, then releases the database (ADR 0061). With `timeoutMs`, rejects with
+   * {@link ShutdownTimeoutError} if callbacks are still running by then; the database
+   * stays owned because those callbacks may still write (ADR 0075). Calling close again keeps waiting.
+   */
+  close(options = {}) {
+    if (!this.closePromise) {
+      this.closing = true;
+      for (const instance of this.instances.values()) {
+        this.clearTimer(instance);
+      }
+      this.abort.abort(
+        new RuntimeClosedError("The durable runtime is closing")
+      );
+      this.closePromise = (async () => {
+        while (this.active.size > 0) {
+          await Promise.allSettled([...this.active]);
+        }
+        this.store.close();
+      })();
+    }
+    const { timeoutMs } = options;
+    if (timeoutMs === void 0) {
+      return this.closePromise;
+    }
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new ShutdownTimeoutError(
+            `${this.active.size} callback execution(s) did not settle within ${timeoutMs} ms; the database is still owned. Exit the process to release it; interrupted work recovers on the next open.`
+          )
+        ),
+        timeoutMs
+      );
+    });
+    return Promise.race([this.closePromise, timeout]).finally(
+      () => clearTimeout(timer)
+    );
+  }
+  /**
+   * The runtime-backed deployment gate (ADR 0091, 0094). Reads unfinished execution from storage
+   * and, when there is none, starts closing in the same synchronous step, so no admission can
+   * fall between the check and the handover. A blocked or failed check changes nothing.
+   */
+  async handover(options = {}) {
+    this.assertOpen();
+    this.assertStoreOpen();
+    const blockers = deploymentBlockers(this.store);
+    if (blockers.length > 0) {
+      return Object.freeze({ outcome: "blocked", blockers });
+    }
+    await this.close(options);
+    return Object.freeze({ outcome: "handed-over" });
+  }
+  get isClosed() {
+    return this.closing;
+  }
+  /** Simulates a crash: stops scheduling and drops the connection without waiting. */
+  abandon() {
+    this.closing = true;
+    for (const instance of this.instances.values()) {
+      this.clearTimer(instance);
+    }
+    this.closePromise = Promise.resolve();
+    this.store.close();
+  }
+  // --- observation ---------------------------------------------------------
+  snapshot(instance) {
+    return this.snapshotOf(instance.id);
+  }
+  /** Snapshot read from storage; works for instances this runtime has not opened. */
+  snapshotOf(instanceId2) {
+    this.assertStoreOpen();
+    const row = this.requireInstanceRow(instanceId2);
+    return Object.freeze({
+      instanceId: instanceId2,
+      flowName: row.chart_name,
+      state: row.state,
+      revision: row.revision,
+      status: Object.freeze(this.status(row)),
+      stall: this.instances.get(instanceId2)?.stall ?? null,
+      scopes: Object.freeze(
+        row.root_instance_id ? [] : this.scopeSnapshots(instanceId2)
+      )
+    });
+  }
+  /** Active scopes and exited scopes that retain unresolved work, parents first (ADR 0096). */
+  scopeSnapshots(rootId) {
+    const rows = this.store.listScopes(rootId);
+    const byId = new Map(rows.map((row) => [row.instance_id, row]));
+    return rows.filter(
+      (row) => row.active === 1 || row.status === "running" || row.status === "recovering" || row.status === "needs-attention"
+    ).map(
+      (row) => Object.freeze({
+        path: row.scope_path ?? "",
+        segment: row.segment ?? "",
+        activationId: row.activation_id ?? "",
+        parentActivationId: row.parent_instance_id === rootId ? null : byId.get(row.parent_instance_id ?? "")?.activation_id ?? null,
+        memberKey: row.member_key,
+        flowName: row.chart_name,
+        state: row.state,
+        active: row.active === 1,
+        status: Object.freeze(this.status(row))
+      })
+    );
+  }
+  status(row) {
+    const execution = row.current_execution_id === null ? void 0 : this.store.getExecution(row.current_execution_id);
+    switch (row.status) {
+      case "exited":
+        return {
+          kind: "exited",
+          interrupted: row.exit_reason === "interrupted"
+        };
+      case "ready":
+        return { kind: "ready" };
+      case "terminated":
+        return { kind: "terminated", reason: row.status_reason ?? "" };
+      case "completed":
+        return { kind: "completed" };
+      case "running":
+        return {
+          kind: "running",
+          requestId: execution?.request_id ?? null,
+          transition: execution?.transition ?? null,
+          destination: execution?.kind === "dispatch" ? execution.to_state : null
+        };
+      case "recovering":
+      case "needs-attention": {
+        const operation = execution ? this.store.findUnresolvedOperation(execution.execution_id) : void 0;
+        if (!execution || !operation) {
+          return {
+            kind: "running",
+            requestId: null,
+            transition: null,
+            destination: null
+          };
+        }
+        const work = this.work(execution, operation);
+        return row.status === "recovering" ? { kind: "recovering", work } : { kind: "needs-attention", work, reason: row.status_reason ?? "" };
+      }
+    }
+  }
+  work(execution, operation) {
+    return Object.freeze({
+      operationId: operation.operation_id,
+      requestId: execution.request_id,
+      callback: Object.freeze(callbackRef(operation)),
+      strategy: operation.strategy,
+      attempts: operation.attempts,
+      lastError: operation.last_error,
+      nextAttemptAt: operation.next_attempt_at
+    });
+  }
+  currentWork(instanceId2) {
+    const row = this.requireInstanceRow(instanceId2);
+    if (row.current_execution_id === null) {
+      return null;
+    }
+    const execution = this.store.getExecution(row.current_execution_id);
+    const operation = execution ? this.store.findUnresolvedOperation(execution.execution_id) : void 0;
+    return execution && operation ? this.work(execution, operation) : null;
+  }
+  assertStoreOpen() {
+    if (!this.store.isOpen) {
+      throw new RuntimeClosedError("The durable runtime is closed");
+    }
+  }
+  history(instanceId2, query = {}) {
+    this.assertStoreOpen();
+    const limit = clampLimit(query.limit, 100, 1e3);
+    const afterSequence = Math.max(0, Math.floor(query.afterSequence ?? 0));
+    const rows = this.store.listHistory(instanceId2, {
+      afterSequence,
+      limit: limit + 1
+    });
+    const events = rows.slice(0, limit).map(
+      (row) => Object.freeze({
+        sequence: row.sequence,
+        at: row.at,
+        type: row.type,
+        requestId: row.request_id,
+        operationId: row.operation_id,
+        attemptId: row.attempt_id,
+        data: parseJson(row.data_json)
+      })
+    );
+    return Object.freeze({
+      events: Object.freeze(events),
+      nextAfterSequence: rows.length > limit ? events[events.length - 1]?.sequence ?? null : null
+    });
+  }
+  listInstances(query = {}) {
+    this.assertStoreOpen();
+    const limit = clampLimit(query.limit, 50, 500);
+    const statuses = query.status === void 0 ? null : Array.isArray(query.status) ? query.status : [query.status];
+    const rows = this.store.listInstances({
+      flowName: query.flowName ?? null,
+      statuses,
+      afterInstanceId: query.after ?? null,
+      limit: limit + 1
+    });
+    const instances = rows.slice(0, limit).map(
+      (row) => Object.freeze({
+        instanceId: row.instance_id,
+        flowName: row.chart_name,
+        state: row.state,
+        // Listings hold roots only, which never exit.
+        status: row.status,
+        statusReason: row.status_reason,
+        revision: row.revision,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      })
+    );
+    return Object.freeze({
+      instances: Object.freeze(instances),
+      next: rows.length > limit ? instances[instances.length - 1]?.instanceId ?? null : null
+    });
+  }
+  /** SQLite lock contention can clear without application intervention; other faults stay visible. */
+  isTransientInfrastructureError(error) {
+    if (typeof error !== "object" || error === null) return false;
+    const code = "code" in error ? error.code : void 0;
+    const number = "errcode" in error ? error.errcode : void 0;
+    return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || typeof number === "number" && [5, 6].includes(number & 255);
+  }
+  /** Records an infrastructure stall and tells observers, without letting a broken store throw. */
+  markStalled(instance, error) {
+    instance.stall = Object.freeze({
+      error: errorMessage(error),
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      this.notify(instance);
+    } catch {
+    }
+    if (!this.closing && instance.timer === null && this.isTransientInfrastructureError(error) && instance.infrastructureRetries < RECOVERY_DELAYS_MS.length) {
+      const delay = RECOVERY_DELAYS_MS[instance.infrastructureRetries++];
+      instance.timer = setTimeout(() => {
+        instance.timer = null;
+        if (this.closing || !instance.stalled) return;
+        try {
+          this.startRecovery(instance);
+        } catch (failure) {
+          this.markStalled(instance, failure);
+          this.reportRecoveryError(failure);
+        }
+      }, delay);
+      instance.timer.unref?.();
+    }
+  }
+  /** Explicit restart after a stall (ADR 0076). Returns false when there was nothing to restart. */
+  restartRecovery(instance) {
+    this.assertOpen();
+    if (instance.stall === null || instance.activeExecutionId !== null) {
+      return false;
+    }
+    this.clearTimer(instance);
+    instance.infrastructureRetries = 0;
+    this.startRecovery(instance);
+    this.notify(instance);
+    return true;
+  }
+  /** Runtime-wide snapshot listeners (companion tools). */
+  runtimeListeners = /* @__PURE__ */ new Set();
+  /** Delivers the current snapshot; listener failures never affect execution (ADR 0059). */
+  notify(instance) {
+    if (instance.scope !== null) {
+      const root = this.instances.get(instance.scope.rootId);
+      if (root) this.notify(root);
+      return;
+    }
+    if (instance.listeners.size === 0 && this.runtimeListeners.size === 0) {
+      return;
+    }
+    this.store.afterCommit(() => this.deliver(instance));
+  }
+  deliver(instance) {
+    if (!this.store.isOpen) {
+      return;
+    }
+    let snapshot;
+    try {
+      snapshot = this.snapshot(instance);
+    } catch (error) {
+      this.reportObserverError(error);
+      return;
+    }
+    const listeners = [...instance.listeners, ...this.runtimeListeners];
+    queueMicrotask(() => {
+      for (const listener of listeners) {
+        try {
+          const result = listener(snapshot);
+          if (isThenable(result)) {
+            result.then(
+              void 0,
+              (error) => this.reportObserverError(error)
+            );
+          }
+        } catch (error) {
+          this.reportObserverError(error);
+        }
+      }
+    });
+  }
+  reportObserverError(error) {
+    try {
+      this.onObserverError(error);
+    } catch {
+    }
+  }
+  reportRecoveryError(error) {
+    try {
+      this.onRecoveryError(error);
+    } catch {
+    }
+  }
+  record(instanceId2, type, data, refs = {}) {
+    this.store.appendHistory({
+      instance_id: instanceId2,
+      type,
+      request_id: refs.requestId ?? null,
+      operation_id: refs.operationId ?? null,
+      attempt_id: refs.attemptId ?? null,
+      data_json: canonicalJson(data)
+    });
+  }
+  requireInstanceRow(instanceId2) {
+    const row = this.store.getInstance(instanceId2);
+    if (!row) {
+      throw new Error(`Durable instance ${instanceId2} is missing from storage`);
+    }
+    return row;
+  }
+  // --- execution tracking --------------------------------------------------
+  /** Marks the instance busy while `work` runs and lets close() wait for it. */
+  track(instance, executionId, work) {
+    instance.activeExecutionId = executionId;
+    const promise = work().then((result) => {
+      instance.infrastructureRetries = 0;
+      return result;
+    }).catch((error) => {
+      this.markStalled(instance, error);
+      throw error;
+    }).finally(() => {
+      instance.activeExecutionId = null;
+      this.active.delete(promise);
+      if (instance.flow.root.composite) this.scheduleIdle(instance);
+    });
+    this.active.add(promise);
+    return promise;
+  }
+  /** The flow core executing one graph of a root definition, with its flow's dependencies. */
+  flowCoreFor(rootFlow, graphKey) {
+    const root = rootFlow.root;
+    if (graphKey === root.key) return rootFlow;
+    let cores = this.graphCores.get(root);
+    if (!cores) {
+      cores = /* @__PURE__ */ new Map();
+      this.graphCores.set(root, cores);
+    }
+    let core = cores.get(graphKey);
+    if (!core) {
+      const graph = root.graphs.get(graphKey);
+      if (!graph) {
+        throw new Error(
+          `Graph ${graphKey} is missing from definition ${root.flowName}`
+        );
+      }
+      core = {
+        definition: graph,
+        root,
+        dependencies: graph.flowName === root.flowName ? rootFlow.dependencies : this.dependenciesOf(graph.flowName)
+      };
+      cores.set(graphKey, core);
+    }
+    return core;
+  }
+  /** Loaded core of a scope row, created when first needed (ADR 0096). */
+  scopeCore(rootFlow, row) {
+    const cached = this.instances.get(row.instance_id);
+    if (cached) return cached;
+    const core = new InstanceCore(
+      row.instance_id,
+      this.flowCoreFor(rootFlow, row.graph ?? rootFlow.root.key),
+      Object.freeze({
+        rootId: row.root_instance_id ?? row.instance_id,
+        parentId: row.parent_instance_id ?? "",
+        path: row.scope_path ?? "",
+        segment: row.segment ?? "",
+        activationId: row.activation_id ?? "",
+        memberKey: row.member_key,
+        input: row.input_json === null ? null : parseJson(row.input_json)
+      })
+    );
+    this.instances.set(row.instance_id, core);
+    return core;
+  }
+  idleQueued = /* @__PURE__ */ new Set();
+  /** Runs completion routing and resumes a waiting parent exit after the current step. */
+  scheduleIdle(instance) {
+    if (this.closing || this.idleQueued.has(instance)) return;
+    this.idleQueued.add(instance);
+    queueMicrotask(() => {
+      this.idleQueued.delete(instance);
+      if (this.closing || !this.store.isOpen) return;
+      try {
+        this.onIdle(instance);
+      } catch (error) {
+        this.markStalled(instance, error);
+        this.reportRecoveryError(error);
+      }
+    });
+  }
+  // --- stepping ------------------------------------------------------------
+  /** Runs the execution from its checkpointed step until it finishes or suspends. */
+  async advance(instance, executionId) {
+    const { definition } = instance.flow;
+    for (; ; ) {
+      const execution = this.requireExecution(executionId);
+      if (execution.status !== "running") {
+        return;
+      }
+      const step = execution.step;
+      switch (step) {
+        case "resolve-start-state": {
+          const input = parseJson(execution.input_json);
+          const resolver = definition.resolveStartState;
+          let target2 = input.startState ?? definition.initialState.name;
+          if (input.startState === null && resolver) {
+            const outcome = await this.runStep(
+              instance,
+              execution,
+              "resolve-start-state"
+            );
+            if (outcome.kind === "suspended") {
+              return;
+            }
+            target2 = outcome.result;
+          }
+          this.store.updateExecution(executionId, {
+            to_state: target2,
+            step: "commit"
+          });
+          continue;
+        }
+        case "commit": {
+          const target2 = this.requireState(definition, execution.to_state);
+          this.store.transaction(() => {
+            this.store.updateInstance(instance.id, {
+              state: target2.name
+            });
+            this.store.updateExecution(executionId, { step: "on-enter" });
+            this.record(
+              instance.id,
+              "state-committed",
+              { from: execution.from_state, to: target2.name },
+              { requestId: execution.request_id }
+            );
+            if (target2.final) {
+              this.finishInTransaction(instance, execution, "applied");
+            }
+          });
+          this.notify(instance);
+          if (target2.final) {
+            return;
+          }
+          continue;
+        }
+        case "guard": {
+          const outcome = await this.runStep(instance, execution, "guard");
+          if (outcome.kind === "suspended") {
+            return;
+          }
+          if (outcome.result === false) {
+            this.finish(instance, execution, "blocked");
+            return;
+          }
+          this.store.updateExecution(executionId, { step: "exit-children" });
+          continue;
+        }
+        case "exit-children": {
+          if (await this.exitChildren(instance, execution) === "waiting") {
+            return;
+          }
+          this.store.updateExecution(executionId, { step: "on-exit" });
+          continue;
+        }
+        case "on-transition": {
+          const outcome = await this.runStep(instance, execution, step);
+          if (outcome.kind === "suspended") {
+            return;
+          }
+          const transition = this.requireTransition(definition, execution);
+          const destination = isBranching(transition) ? outcome.result : transition.destinations[0].name;
+          this.store.updateExecution(executionId, {
+            to_state: destination,
+            step: "commit"
+          });
+          continue;
+        }
+        case "on-exit":
+        case "on-enter": {
+          const outcome = await this.runStep(instance, execution, step);
+          if (outcome.kind === "suspended") {
+            return;
+          }
+          this.store.updateExecution(executionId, {
+            step: execution.kind === "exit" ? "done" : nextStep(step)
+          });
+          continue;
+        }
+        case "children": {
+          const target2 = definition.statesByName.get(execution.to_state ?? "");
+          if (target2?.composition?.children) {
+            const outcome = await this.runStep(instance, execution, "children");
+            if (outcome.kind === "suspended") {
+              return;
+            }
+          }
+          this.store.updateExecution(executionId, {
+            step: "activate-children"
+          });
+          continue;
+        }
+        case "activate-children": {
+          const created = this.activateChildren(instance, execution);
+          await this.enterChildren(instance, created);
+          return;
+        }
+        case "done":
+          this.finish(instance, execution, "applied");
+          return;
+      }
+    }
+  }
+  finish(instance, execution, status) {
+    this.store.transaction(
+      () => this.finishInTransaction(instance, execution, status)
+    );
+    this.notify(instance);
+  }
+  /** Ends the execution; an instance in a FinalState becomes `completed`. Runs in a transaction. */
+  finishInTransaction(instance, execution, status) {
+    const row = this.requireInstanceRow(instance.id);
+    if (execution.kind === "exit") {
+      this.store.updateExecution(execution.execution_id, { status });
+      this.store.updateScope(instance.id, {
+        active: 0,
+        exit_reason: "exited"
+      });
+      this.store.updateInstance(instance.id, {
+        status: "exited",
+        status_reason: null,
+        current_execution_id: null
+      });
+      this.recordScopeEvent(instance, "scope-exited", { state: row.state });
+      return;
+    }
+    const completed = status === "applied" && instance.flow.definition.statesByName.get(row.state)?.final === true;
+    this.store.updateExecution(execution.execution_id, { status });
+    this.store.updateInstance(instance.id, {
+      status: completed ? "completed" : "ready",
+      status_reason: null,
+      current_execution_id: null
+    });
+    this.record(
+      instance.id,
+      status === "applied" ? "execution-applied" : "execution-blocked",
+      {
+        kind: execution.kind,
+        transition: execution.transition,
+        ...status === "applied" ? { destination: row.state } : {}
+      },
+      { requestId: execution.request_id }
+    );
+    if (completed) {
+      if (instance.scope !== null) {
+        this.recordScopeEvent(instance, "scope-completed", {
+          state: row.state
+        });
+      } else {
+        this.record(
+          instance.id,
+          "instance-completed",
+          { state: row.state },
+          { requestId: execution.request_id }
+        );
+      }
+    }
+  }
+  /** Records a composition event in the root's history, naming the scope. */
+  recordScopeEvent(instance, type, data) {
+    const scope = instance.scope;
+    if (scope === null) return;
+    this.record(scope.rootId, type, {
+      path: scope.path,
+      activationId: scope.activationId,
+      memberKey: scope.memberKey,
+      ...data
+    });
+  }
+  invocation(instance, execution, kind) {
+    const { definition, dependencies } = instance.flow;
+    const flowName = definition.flowName;
+    const input = instance.scope?.input ?? null;
+    if (kind === "resolve-start-state") {
+      return {
+        callback: definition.resolveStartState,
+        context: {
+          flowName,
+          initialStateName: definition.initialState.name,
+          dependencies,
+          input
+        },
+        args: []
+      };
+    }
+    if (execution.kind === "exit") {
+      const state = this.requireState(definition, execution.from_state);
+      return {
+        callback: kind === "on-exit" ? state.onExit : null,
+        context: {
+          flowName,
+          stateName: state.name,
+          transitionName: PARENT_EXIT_TRANSITION_NAME,
+          dependencies,
+          input
+        },
+        args: []
+      };
+    }
+    if (kind === "children") {
+      const target2 = this.requireState(definition, execution.to_state);
+      return {
+        callback: target2.composition?.children ?? null,
+        context: {
+          flowName,
+          stateName: target2.name,
+          transitionName: execution.transition ?? "default",
+          dependencies,
+          input
+        },
+        // The entering Transition's payload, for example the files of a batch (ADR 0096).
+        args: [
+          execution.kind === "dispatch" ? parseJson(execution.input_json).payload : null
+        ]
+      };
+    }
+    if (execution.kind === "create") {
+      const target2 = this.requireState(definition, execution.to_state);
+      const isInitial = target2.id === definition.initialState.id;
+      return {
+        // Restoring into a non-initial state does not run onEnter (ADR 0035).
+        callback: isInitial ? target2.onEnter : null,
+        context: {
+          flowName,
+          stateName: target2.name,
+          transitionName: "default",
+          dependencies,
+          input
+        },
+        args: []
+      };
+    }
+    const transition = this.requireTransition(definition, execution);
+    const payload = parseJson(execution.input_json).payload;
+    switch (kind) {
+      case "guard":
+      case "on-transition":
+        return {
+          callback: kind === "guard" ? transition.guard : transition.onTransition,
+          context: {
+            flowName,
+            fromState: transition.from.name,
+            // Allowed choices, not a selection: the destination is unknown until onTransition returns.
+            destinations: Object.freeze(
+              transition.destinations.map((state) => state.name)
+            ),
+            transitionName: transition.name,
+            dependencies,
+            input
+          },
+          args: [payload]
+        };
+      case "on-exit":
+        return {
+          callback: transition.from.onExit,
+          context: {
+            flowName,
+            stateName: transition.from.name,
+            transitionName: transition.name,
+            dependencies,
+            input
+          },
+          args: []
+        };
+      case "on-enter": {
+        const target2 = this.requireState(definition, execution.to_state);
+        return {
+          callback: target2.onEnter,
+          context: {
+            flowName,
+            stateName: target2.name,
+            transitionName: transition.name,
+            dependencies,
+            input
+          },
+          args: []
+        };
+      }
+    }
+  }
+  requireTransition(definition, execution) {
+    const transition = definition.transitionsByName.get(
+      execution.transition ?? ""
+    );
+    if (!transition) {
+      throw new Error(
+        `Transition ${execution.transition} is missing from definition ${definition.flowName}`
+      );
+    }
+    return transition;
+  }
+  requireState(definition, name) {
+    const state = definition.statesByName.get(name ?? "");
+    if (!state) {
+      throw new Error(
+        `State ${name} is missing from definition ${definition.flowName}`
+      );
+    }
+    return state;
+  }
+  /** Returns a checkpointed result, or creates the operation and runs it once. */
+  async runStep(instance, execution, kind) {
+    const invocation = this.invocation(instance, execution, kind);
+    if (!invocation.callback) {
+      return { kind: "completed", result: null };
+    }
+    const existing = this.store.findOperation(execution.execution_id, kind);
+    if (existing) {
+      return existing.status === "completed" ? { kind: "completed", result: parseJson(existing.result_json) } : { kind: "suspended" };
+    }
+    const operation = {
+      operation_id: mintOperationId(),
+      execution_id: execution.execution_id,
+      instance_id: instance.id,
+      callback_kind: kind,
+      callback_target: callbackTarget(invocation, kind),
+      strategy: invocation.callback.strategy,
+      status: "running",
+      result_json: null,
+      attempts: 0,
+      attempt_limit: MAX_ATTEMPTS,
+      last_error: null,
+      last_cause: null,
+      next_attempt_at: null
+    };
+    return this.attempt(instance, execution, operation, "run", {
+      prelude: () => this.store.insertOperation(operation)
+    });
+  }
+  /**
+   * One attempt at an operation. The operation and attempt are persisted in one transaction
+   * before user code runs, so a crash mid-callback is detected as interrupted on the next open
+   * (ADR 0055, 0065). The attempt's result is settled in a second single transaction.
+   */
+  async attempt(instance, execution, operation, mode, options = {}) {
+    const invocation = this.invocation(
+      instance,
+      execution,
+      operation.callback_kind
+    );
+    const callback = invocation.callback;
+    if (!callback) {
+      throw new Error(
+        `Operation ${operation.operation_id} has no callback in the current definition`
+      );
+    }
+    const attemptNumber = operation.attempts + 1;
+    const attemptId = mintAttemptId();
+    this.store.transaction(() => {
+      options.prelude?.();
+      this.store.updateOperation(operation.operation_id, {
+        status: "running",
+        attempts: attemptNumber,
+        next_attempt_at: null
+      });
+      this.store.insertAttempt({
+        attempt_id: attemptId,
+        operation_id: operation.operation_id,
+        mode,
+        number: attemptNumber
+      });
+      this.record(
+        instance.id,
+        "callback-started",
+        { callback: operation.callback_kind, mode, attempt: attemptNumber },
+        {
+          requestId: execution.request_id,
+          operationId: operation.operation_id,
+          attemptId
+        }
+      );
+    });
+    const refs = {
+      requestId: execution.request_id,
+      operationId: operation.operation_id,
+      attemptId
+    };
+    const context = {
+      ...invocation.context,
+      instanceId: instance.rootId,
+      operation: Object.freeze({
+        operationId: operation.operation_id,
+        attemptId,
+        attempt: attemptNumber
+      }),
+      // Scoped cancellation: a parent interrupt aborts only this scope (ADR 0095).
+      signal: instance.scope === null ? this.abort.signal : AbortSignal.any([this.abort.signal, instance.abort.signal]),
+      scope: instance.scope === null ? null : Object.freeze({
+        path: instance.scope.path,
+        activationId: instance.scope.activationId,
+        memberKey: instance.scope.memberKey
+      })
+    };
+    const current = this.requireOperation(operation.operation_id);
+    if (mode === "run") {
+      let value;
+      try {
+        value = await callback.run(context, ...invocation.args);
+      } catch (error) {
+        const cause = this.closing || instance.abort.signal.aborted ? "interrupted" : "failed";
+        return this.store.transaction(() => {
+          this.store.finishAttempt(attemptId, cause, errorMessage(error));
+          return this.failed(
+            instance,
+            execution,
+            current,
+            cause,
+            errorMessage(error),
+            refs
+          );
+        });
+      }
+      return this.store.transaction(() => {
+        const validated = validateCallbackResult(
+          instance.flow.definition,
+          operation.callback_kind,
+          value,
+          execution.transition,
+          execution.to_state
+        );
+        if (!validated.ok) {
+          this.store.finishAttempt(
+            attemptId,
+            "invalid-result",
+            validated.message
+          );
+          if (operation.callback_kind === "on-transition" && !this.isFenced(execution.execution_id)) {
+            return this.failed(
+              instance,
+              execution,
+              current,
+              "failed",
+              `Invalid callback result: ${validated.message}`,
+              refs
+            );
+          }
+          return this.escalate(
+            instance,
+            execution,
+            current,
+            `Invalid callback result: ${validated.message}`,
+            refs
+          );
+        }
+        if (this.isFenced(execution.execution_id)) {
+          return this.settleLate(
+            instance,
+            execution,
+            current,
+            attemptId,
+            validated.result,
+            "late-result",
+            refs
+          );
+        }
+        return this.complete(
+          instance,
+          execution,
+          current,
+          attemptId,
+          validated.result,
+          refs
+        );
+      });
+    }
+    const reconcile = callback.reconcile;
+    if (!reconcile) {
+      throw new Error(
+        `Operation ${operation.operation_id} has no reconcile function`
+      );
+    }
+    let decision;
+    try {
+      decision = await reconcile(
+        {
+          ...context,
+          recovery: Object.freeze({
+            cause: operation.last_cause ?? "failed",
+            lastError: operation.last_error
+          })
+        },
+        ...invocation.args
+      );
+    } catch (error) {
+      return this.store.transaction(() => {
+        this.store.finishAttempt(attemptId, "failed", errorMessage(error));
+        this.store.updateOperation(current.operation_id, {
+          last_error: errorMessage(error)
+        });
+        return this.scheduleOrEscalate(
+          instance,
+          execution,
+          this.requireOperation(current.operation_id),
+          refs,
+          this.closing ? 0 : delayAfterAttempt(attemptNumber)
+        );
+      });
+    }
+    const settled = this.store.transaction(
+      () => this.settleReconcile(
+        instance,
+        execution,
+        current,
+        attemptId,
+        decision,
+        refs
+      )
+    );
+    return settled === "replay" ? this.attempt(instance, execution, current, "run") : settled;
+  }
+  /** Applies one reconciliation decision (ADR 0064). Runs inside a transaction. */
+  settleReconcile(instance, execution, operation, attemptId, decision, refs) {
+    const kind = isRecord2(decision) ? decision.decision : void 0;
+    switch (kind) {
+      case "completed": {
+        const validated = validateCallbackResult(
+          instance.flow.definition,
+          operation.callback_kind,
+          decision.result,
+          execution.transition,
+          execution.to_state
+        );
+        if (!validated.ok) {
+          this.store.finishAttempt(
+            attemptId,
+            "invalid-result",
+            validated.message
+          );
+          return this.escalate(
+            instance,
+            execution,
+            operation,
+            `Invalid reconciliation result: ${validated.message}`,
+            refs
+          );
+        }
+        if (this.isFenced(execution.execution_id)) {
+          return this.settleLate(
+            instance,
+            execution,
+            operation,
+            attemptId,
+            validated.result,
+            "reconciled",
+            refs
+          );
+        }
+        return this.complete(
+          instance,
+          execution,
+          operation,
+          attemptId,
+          validated.result,
+          refs
+        );
+      }
+      case "safe-to-retry":
+        this.store.finishAttempt(attemptId, "safe-to-retry", null);
+        if (this.isFenced(execution.execution_id)) {
+          return this.escalate(
+            instance,
+            execution,
+            operation,
+            NO_REPLAY_REASON,
+            refs
+          );
+        }
+        if (operation.attempts >= operation.attempt_limit) {
+          return this.escalate(
+            instance,
+            execution,
+            operation,
+            exhaustedReason(operation),
+            refs
+          );
+        }
+        return "replay";
+      case "pending":
+        this.store.finishAttempt(attemptId, "pending", null);
+        return this.scheduleOrEscalate(
+          instance,
+          execution,
+          operation,
+          refs,
+          delayAfterAttempt(operation.attempts)
+        );
+      case "needs-attention": {
+        const reason = decision.reason;
+        this.store.finishAttempt(attemptId, "needs-attention", null);
+        return this.escalate(
+          instance,
+          execution,
+          operation,
+          typeof reason === "string" && reason.length > 0 ? reason : "Reconciliation requires attention",
+          refs
+        );
+      }
+      default:
+        this.store.finishAttempt(attemptId, "invalid-decision", null);
+        return this.escalate(
+          instance,
+          execution,
+          operation,
+          "Reconciliation returned an invalid decision",
+          refs
+        );
+    }
+  }
+  complete(instance, execution, operation, attemptId, result, refs) {
+    this.store.transaction(() => {
+      this.checkpoint(instance, execution, operation, result);
+      this.store.finishAttempt(attemptId, "completed", null);
+      this.record(
+        instance.id,
+        "callback-completed",
+        { callback: operation.callback_kind, result },
+        refs
+      );
+    });
+    return { kind: "completed", result };
+  }
+  /**
+   * Records a callback as completed and, in the same transaction, marks a suspended execution
+   * running again, so a crash can never leave a completed callback whose execution never resumes.
+   * Must run inside a transaction.
+   */
+  checkpoint(instance, execution, operation, result) {
+    this.store.updateOperation(operation.operation_id, {
+      status: "completed",
+      result_json: JSON.stringify(result),
+      next_attempt_at: null
+    });
+    const status = this.requireExecution(execution.execution_id).status;
+    if (status !== "running" && status !== "interrupted") {
+      this.store.updateExecution(execution.execution_id, { status: "running" });
+      this.store.updateInstance(instance.id, {
+        status: "running",
+        status_reason: null
+      });
+    }
+  }
+  /** Whether a parent Transition interrupted this execution (ADR 0095). */
+  isFenced(executionId) {
+    return this.requireExecution(executionId).status === "interrupted";
+  }
+  /**
+   * Records the established outcome of interrupted work (ADR 0095, 0096): the operation is
+   * completed as evidence, the application is told durably, and the exited graph never advances.
+   * Must run inside a transaction.
+   */
+  settleLate(instance, execution, operation, attemptId, result, source, refs) {
+    this.store.updateOperation(operation.operation_id, {
+      status: "completed",
+      result_json: JSON.stringify(result),
+      next_attempt_at: null
+    });
+    if (attemptId !== null) {
+      this.store.finishAttempt(attemptId, "completed", null);
+    }
+    this.record(
+      instance.id,
+      "callback-completed",
+      { callback: operation.callback_kind, result, late: true },
+      refs
+    );
+    this.recordLateOutcome(instance, operation, source, result);
+    this.releaseRetained(instance, execution);
+    this.notify(instance);
+    return { kind: "suspended" };
+  }
+  /** Durable report of a late outcome for the application (ADR 0096). Inside a transaction. */
+  recordLateOutcome(instance, operation, source, result) {
+    const scope = instance.scope;
+    if (scope === null) return;
+    this.store.insertLateOutcome({
+      root_instance_id: scope.rootId,
+      scope_instance_id: instance.id,
+      scope_path: scope.path,
+      activation_id: scope.activationId,
+      member_key: scope.memberKey,
+      operation_id: operation.operation_id,
+      callback_kind: operation.callback_kind,
+      callback_target: operation.callback_target,
+      source,
+      result_json: canonicalJson(result)
+    });
+    this.recordScopeEvent(instance, "late-outcome", {
+      operationId: operation.operation_id,
+      callback: operation.callback_kind,
+      source,
+      result
+    });
+    if (this.lateListeners.size > 0) {
+      this.store.afterCommit(() => {
+        for (const outcome of this.pendingLateOutcomes(scope.rootId)) {
+          if (outcome.operationId !== operation.operation_id) continue;
+          for (const listener of [...this.lateListeners]) {
+            try {
+              const value = listener(outcome);
+              if (isThenable(value)) {
+                value.then(
+                  void 0,
+                  (error) => this.reportObserverError(error)
+                );
+              }
+            } catch (error) {
+              this.reportObserverError(error);
+            }
+          }
+        }
+      });
+    }
+  }
+  /** Unacknowledged late outcomes, oldest first. */
+  pendingLateOutcomes(rootId) {
+    return this.store.listPendingLateOutcomes(rootId).map(
+      (row) => Object.freeze({
+        sequence: row.sequence,
+        instanceId: row.root_instance_id,
+        path: row.scope_path,
+        activationId: row.activation_id,
+        memberKey: row.member_key,
+        operationId: row.operation_id,
+        callback: Object.freeze(
+          callbackRef({
+            callback_kind: row.callback_kind,
+            callback_target: row.callback_target
+          })
+        ),
+        source: row.source,
+        result: parseJson(row.result_json),
+        recordedAt: row.recorded_at
+      })
+    );
+  }
+  /** An exited scope with no unresolved work left stops blocking deployment. In a transaction. */
+  releaseRetained(instance, execution) {
+    if (this.store.findUnresolvedOperation(execution.execution_id)) return;
+    const row = this.store.getScope(instance.id);
+    if (!row || row.active === 1) return;
+    this.store.updateInstance(instance.id, {
+      status: "exited",
+      status_reason: null,
+      current_execution_id: null
+    });
+  }
+  /** Applies the declared strategy after a failed or interrupted run (ADR 0046). */
+  failed(instance, execution, operation, cause, message, refs) {
+    return this.store.transaction(() => {
+      this.store.updateOperation(operation.operation_id, {
+        last_error: message,
+        last_cause: cause
+      });
+      this.record(
+        instance.id,
+        cause === "interrupted" ? "recovery-interrupted" : "callback-failed",
+        { callback: operation.callback_kind, error: message },
+        refs
+      );
+      return this.settleFailure(
+        instance,
+        execution,
+        operation,
+        cause,
+        message,
+        refs
+      );
+    });
+  }
+  settleFailure(instance, execution, operation, cause, message, refs) {
+    const current = this.requireOperation(operation.operation_id);
+    if (this.isFenced(execution.execution_id) && current.strategy !== "reconcile") {
+      return this.escalate(
+        instance,
+        execution,
+        current,
+        NO_REPLAY_REASON,
+        refs
+      );
+    }
+    if (current.strategy === "manual") {
+      return this.escalate(
+        instance,
+        execution,
+        current,
+        `Manual recovery required: ${message}`,
+        refs
+      );
+    }
+    return this.scheduleOrEscalate(
+      instance,
+      execution,
+      current,
+      refs,
+      cause === "interrupted" ? 0 : delayAfterAttempt(current.attempts)
+    );
+  }
+  scheduleOrEscalate(instance, execution, operation, refs, delayMs) {
+    if (operation.attempts >= operation.attempt_limit) {
+      return this.escalate(
+        instance,
+        execution,
+        operation,
+        exhaustedReason(operation),
+        refs
+      );
+    }
+    const nextAttemptAt = new Date(Date.now() + delayMs).toISOString();
+    const fenced = this.isFenced(execution.execution_id);
+    this.store.transaction(() => {
+      this.store.updateOperation(operation.operation_id, {
+        status: "recovering",
+        next_attempt_at: nextAttemptAt
+      });
+      if (!fenced) {
+        this.store.updateExecution(execution.execution_id, {
+          status: "recovering"
+        });
+      }
+      this.store.updateInstance(instance.id, {
+        status: "recovering",
+        status_reason: null
+      });
+      this.record(
+        instance.id,
+        "recovery-scheduled",
+        { callback: operation.callback_kind, nextAttemptAt },
+        refs
+      );
+    });
+    this.scheduleTimer(instance, delayMs);
+    this.notify(instance);
+    return { kind: "suspended" };
+  }
+  escalate(instance, execution, operation, reason, refs) {
+    const fenced = this.isFenced(execution.execution_id);
+    this.store.transaction(() => {
+      this.store.updateOperation(operation.operation_id, {
+        status: "needs-attention",
+        next_attempt_at: null
+      });
+      if (!fenced) {
+        this.store.updateExecution(execution.execution_id, {
+          status: "needs-attention"
+        });
+      }
+      this.store.updateInstance(instance.id, {
+        status: "needs-attention",
+        status_reason: reason
+      });
+      this.record(
+        instance.id,
+        "needs-attention",
+        { callback: operation.callback_kind, reason },
+        refs
+      );
+    });
+    this.notify(instance);
+    return { kind: "suspended" };
+  }
+  // --- recovery scheduling -------------------------------------------------
+  scheduleTimer(instance, delayMs) {
+    this.store.afterCommit(() => this.armTimer(instance, delayMs));
+  }
+  armTimer(instance, delayMs) {
+    this.clearTimer(instance);
+    if (this.closing) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      instance.timer = null;
+      void this.recover(instance).catch((error) => {
+        this.markStalled(instance, error);
+        this.reportRecoveryError(error);
+      });
+    }, delayMs);
+    timer.unref?.();
+    instance.timer = timer;
+  }
+  clearTimer(instance) {
+    if (instance.timer !== null) {
+      clearTimeout(instance.timer);
+      instance.timer = null;
+    }
+  }
+  /** One scheduled automatic recovery attempt for the instance's unresolved operation. */
+  async recover(instance) {
+    if (this.closing) {
+      return;
+    }
+    if (instance.activeExecutionId !== null) {
+      this.scheduleTimer(instance, BUSY_RETRY_DELAY_MS);
+      return;
+    }
+    const row = this.requireInstanceRow(instance.id);
+    if (row.status !== "recovering" || row.current_execution_id === null) {
+      return;
+    }
+    const execution = this.requireExecution(row.current_execution_id);
+    const operation = this.store.findUnresolvedOperation(
+      execution.execution_id
+    );
+    if (!operation || operation.status !== "recovering") {
+      return;
+    }
+    await this.track(
+      instance,
+      execution.execution_id,
+      () => this.recoverOnce(instance, execution, operation)
+    );
+  }
+  /**
+   * One recovery attempt following the declared strategy (reconcile, or run again for
+   * safe-replay and manual), then the execution's remaining steps if it completed.
+   */
+  async recoverOnce(instance, execution, operation, prelude) {
+    const mode = operation.strategy === "reconcile" ? "reconcile" : "run";
+    if (mode === "run" && this.isFenced(execution.execution_id)) {
+      this.escalate(instance, execution, operation, NO_REPLAY_REASON, {
+        requestId: execution.request_id,
+        operationId: operation.operation_id
+      });
+      return;
+    }
+    const outcome = await this.attempt(instance, execution, operation, mode, {
+      prelude
+    });
+    if (outcome.kind === "completed" && !this.isFenced(execution.execution_id)) {
+      this.notify(instance);
+      await this.advance(instance, execution.execution_id);
+    }
+  }
+  /**
+   * Operator retry (ADR 0073): grants one more bounded attempt and commits it, the resumed
+   * status and the audit entry together with the attempt start, so a crash cannot strand it.
+   */
+  manualRetry(instance, execution, operation, audit) {
+    return this.track(
+      instance,
+      execution.execution_id,
+      () => this.recoverOnce(instance, execution, operation, () => {
+        const fenced = this.isFenced(execution.execution_id);
+        this.store.updateOperation(operation.operation_id, {
+          // A reconcile check may conclude safe-to-retry, so it also gets the replay it permits,
+          // except for interrupted work, which is only ever checked (ADR 0095).
+          attempt_limit: operation.attempts + (operation.strategy === "reconcile" && !fenced ? 2 : 1)
+        });
+        if (!fenced) {
+          this.store.updateExecution(execution.execution_id, {
+            status: "running"
+          });
+        }
+        this.store.updateInstance(instance.id, {
+          status: "running",
+          status_reason: null
+        });
+        audit();
+      })
+    );
+  }
+  /**
+   * Starts recovery for an instance loaded from storage (ADR 0050), or restarts it after a
+   * stall. Also repairs an execution whose callback completed but which never resumed.
+   */
+  startRecovery(instance) {
+    instance.stall = null;
+    if (instance.activeExecutionId !== null) {
+      return;
+    }
+    const row = this.requireInstanceRow(instance.id);
+    if (row.status === "ready" || row.status === "terminated" || row.status === "completed" || row.status === "exited" || row.current_execution_id === null) {
+      return;
+    }
+    const execution = this.requireExecution(row.current_execution_id);
+    const operation = this.store.findUnresolvedOperation(
+      execution.execution_id
+    );
+    if (!operation && execution.status === "interrupted") {
+      this.store.transaction(() => this.releaseRetained(instance, execution));
+      return;
+    }
+    if (operation?.status === "running") {
+      this.store.transaction(() => {
+        this.store.finishInterruptedAttempts(operation.operation_id);
+        this.failed(
+          instance,
+          execution,
+          operation,
+          "interrupted",
+          "The process stopped while the callback was running",
+          {
+            requestId: execution.request_id,
+            operationId: operation.operation_id
+          }
+        );
+      });
+      return;
+    }
+    if (operation?.status === "recovering") {
+      const due = operation.next_attempt_at ? Date.parse(operation.next_attempt_at) - Date.now() : 0;
+      this.scheduleTimer(instance, Math.max(0, due));
+      return;
+    }
+    if (operation) {
+      return;
+    }
+    if (execution.status !== "running") {
+      this.store.transaction(() => {
+        this.store.updateExecution(execution.execution_id, {
+          status: "running"
+        });
+        this.store.updateInstance(instance.id, {
+          status: "running",
+          status_reason: null
+        });
+      });
+    }
+    void this.track(
+      instance,
+      execution.execution_id,
+      () => this.advance(instance, execution.execution_id)
+    ).catch((error) => {
+      this.markStalled(instance, error);
+      this.reportRecoveryError(error);
+    });
+  }
+  // --- composition (ADR 0095, 0096) ------------------------------------------
+  /** Every active descendant of a scope, inner before outer, later siblings first. */
+  activeDescendants(instanceId2) {
+    const result = [];
+    const visit = (parentId) => {
+      const children = this.store.listChildScopes(parentId).reverse();
+      for (const child of children) {
+        visit(child.instance_id);
+        if (child.active === 1) result.push(child);
+      }
+    };
+    visit(instanceId2);
+    return result;
+  }
+  /**
+   * Whether a descendant has running or unresolved work: the `block` policy answers `busy`
+   * (ADR 0095). Exited activations that only retain old work do not count.
+   */
+  hasBusyDescendant(instance) {
+    return this.activeDescendants(instance.id).some(
+      (row) => row.status === "running" || row.status === "recovering" || row.status === "needs-attention" || (this.instances.get(row.instance_id)?.activeExecutionId ?? null) !== null
+    );
+  }
+  /** Whether an ancestor scope has an execution in progress, which reserves this subtree. */
+  ancestorBusy(instance) {
+    for (let parentId = instance.scope?.parentId ?? null; parentId; ) {
+      const parent = this.store.getScope(parentId);
+      if (!parent) return false;
+      if (parent.current_execution_id !== null) return true;
+      parentId = parent.parent_instance_id;
+    }
+    return false;
+  }
+  rootFlowOf(instance) {
+    const root = this.instances.get(instance.rootId);
+    if (!root) {
+      throw new Error(`Root instance ${instance.rootId} is not loaded`);
+    }
+    return root.flow;
+  }
+  /**
+   * Exits the active descendants of the source State (ADR 0095). `interrupt` first records,
+   * durably and at once, the interruption of every descendant with running or unresolved work;
+   * the remaining descendants run their own `onExit`, inner before outer, each checkpointed.
+   */
+  async exitChildren(instance, execution) {
+    const transition = this.requireTransition(
+      instance.flow.definition,
+      execution
+    );
+    if (transition.from.composition === null) return "done";
+    if (transition.childWork === "interrupt") {
+      this.interruptDescendants(instance, execution);
+    }
+    for (; ; ) {
+      if (this.requireExecution(execution.execution_id).status !== "running") {
+        return "waiting";
+      }
+      const next = this.activeDescendants(instance.id)[0];
+      if (!next) break;
+      const core = this.scopeCore(this.rootFlowOf(instance), next);
+      if (next.status === "completed" || next.status === "ready") {
+        const state = core.flow.definition.statesByName.get(next.state);
+        if (next.status === "completed" || !state?.onExit) {
+          this.store.transaction(() => {
+            this.store.updateScope(next.instance_id, {
+              active: 0,
+              exit_reason: "exited"
+            });
+            this.store.updateInstance(next.instance_id, {
+              status: "exited",
+              current_execution_id: null
+            });
+            this.recordScopeEvent(core, "scope-exited", { state: next.state });
+          });
+          continue;
+        }
+        const exitId = mintExecutionId();
+        this.store.transaction(() => {
+          this.store.insertExecution({
+            execution_id: exitId,
+            instance_id: next.instance_id,
+            kind: "exit",
+            request_id: null,
+            input_json: canonicalJson({ parent: execution.execution_id }),
+            from_state: next.state,
+            transition: null,
+            to_state: null,
+            step: "on-exit",
+            status: "running",
+            handler_revision: instance.flow.root.handlerRevision
+          });
+          this.store.updateInstance(next.instance_id, {
+            status: "running",
+            current_execution_id: exitId
+          });
+        });
+        await this.track(core, exitId, () => this.advance(core, exitId));
+        if (this.store.getScope(next.instance_id)?.active === 1) {
+          return "waiting";
+        }
+        continue;
+      }
+      return "waiting";
+    }
+    this.store.transaction(() => {
+      this.store.updateScope(instance.id, { children_activation_id: null });
+    });
+    return "done";
+  }
+  /** Durably fences every busy descendant of the source State, then aborts its signal. */
+  interruptDescendants(instance, execution) {
+    const victims = this.activeDescendants(instance.id).filter((row) => {
+      if (row.current_execution_id === null) return false;
+      const current = this.store.getExecution(row.current_execution_id);
+      return current !== void 0 && current.kind !== "exit";
+    });
+    if (victims.length === 0) return;
+    const cores = victims.map(
+      (row) => this.scopeCore(this.rootFlowOf(instance), row)
+    );
+    this.store.transaction(() => {
+      victims.forEach((row, index) => {
+        const core = cores[index];
+        const current = this.requireExecution(row.current_execution_id);
+        this.store.updateExecution(current.execution_id, {
+          status: "interrupted"
+        });
+        this.store.updateScope(row.instance_id, {
+          active: 0,
+          exit_reason: "interrupted"
+        });
+        const operation = this.store.findUnresolvedOperation(
+          current.execution_id
+        );
+        if (!operation) {
+          this.store.updateInstance(row.instance_id, {
+            status: "exited",
+            status_reason: null,
+            current_execution_id: null
+          });
+        } else if (operation.status === "recovering" && operation.strategy !== "reconcile") {
+          this.store.updateOperation(operation.operation_id, {
+            status: "needs-attention",
+            next_attempt_at: null
+          });
+          this.store.updateInstance(row.instance_id, {
+            status: "needs-attention",
+            status_reason: NO_REPLAY_REASON
+          });
+        }
+        this.record(
+          row.instance_id,
+          "scope-interrupted",
+          { transition: execution.transition },
+          { requestId: current.request_id }
+        );
+        this.recordScopeEvent(core, "scope-interrupted", {
+          state: row.state,
+          transition: execution.transition,
+          requestId: current.request_id,
+          retained: operation?.operation_id ?? null
+        });
+      });
+    });
+    for (const core of cores) {
+      const operation = this.store.getScope(core.id)?.status;
+      if (operation !== "recovering") this.clearTimer(core);
+      core.abort.abort(
+        new RuntimeClosedError("A parent Transition interrupted this scope")
+      );
+    }
+  }
+  /**
+   * Creates the child scopes of the composite State this execution entered, together with the
+   * execution's completion (ADR 0096). Idempotent per activation. Returns the created scopes.
+   */
+  activateChildren(instance, execution) {
+    const definition = instance.flow.definition;
+    const target2 = definition.statesByName.get(execution.to_state ?? "");
+    const composition = target2?.composition ?? null;
+    const row = this.store.getScope(instance.id);
+    if (!composition || !row) {
+      this.finish(instance, execution, "applied");
+      return [];
+    }
+    if (row.children_activation_id === execution.execution_id) {
+      this.finish(instance, execution, "applied");
+      return this.store.listChildScopes(instance.id).filter((child) => child.activation_id === execution.execution_id).map((child) => this.scopeCore(this.rootFlowOf(instance), child));
+    }
+    const inputs = (() => {
+      const operation = this.store.findOperation(
+        execution.execution_id,
+        "children"
+      );
+      return operation?.status === "completed" ? parseJson(operation.result_json) : {};
+    })();
+    const rootId = instance.rootId;
+    const basePath = instance.scope === null ? "" : `${instance.scope.path}${instance.scope.memberKey === null ? "" : `[${instance.scope.memberKey}]`}/`;
+    const created = [];
+    this.store.transaction(() => {
+      let position = 0;
+      for (const region of composition.regions) {
+        const members = region.kind === "list" ? inputs[region.name] ?? [] : [
+          {
+            key: null,
+            input: region.kind === "flow" ? inputs[region.name] ?? null : null
+          }
+        ];
+        for (const member of members) {
+          const scopeId = `scp_${mintExecutionId().slice(4)}`;
+          const createId = mintExecutionId();
+          const graph = region.graph;
+          const scopeRow = {
+            instance_id: scopeId,
+            chart_name: graph.flowName,
+            definition_id: instance.flow.root.definitionId,
+            state: graph.initialState.name,
+            status: "running",
+            status_reason: null,
+            current_execution_id: createId,
+            root_instance_id: rootId,
+            parent_instance_id: instance.id,
+            scope_path: `${basePath}${region.segment}`,
+            segment: region.segment,
+            graph: graph.key,
+            activation_id: scopeId,
+            member_key: member.key,
+            input_json: canonicalJson(member.input),
+            position: position++
+          };
+          this.store.insertScope(scopeRow);
+          this.store.insertExecution({
+            execution_id: createId,
+            instance_id: scopeId,
+            kind: "create",
+            request_id: null,
+            input_json: canonicalJson({ startState: null }),
+            from_state: null,
+            transition: null,
+            to_state: graph.initialState.name,
+            // Nested activations always start at their default (ADR 0096).
+            step: "commit",
+            status: "running",
+            handler_revision: instance.flow.root.handlerRevision
+          });
+          created.push(this.store.getScope(scopeId));
+        }
+      }
+      this.store.updateScope(instance.id, {
+        children_activation_id: execution.execution_id
+      });
+      this.record(
+        rootId,
+        "scope-activated",
+        {
+          state: target2.name,
+          parentPath: instance.scope?.path ?? null,
+          scopes: created.map((child) => ({
+            path: child.scope_path ?? "",
+            activationId: child.activation_id ?? "",
+            memberKey: child.member_key
+          }))
+        },
+        { requestId: execution.request_id }
+      );
+      this.finishInTransaction(instance, execution, "applied");
+    });
+    this.notify(instance);
+    return created.map(
+      (child) => this.scopeCore(this.rootFlowOf(instance), child)
+    );
+  }
+  /** Runs each new child's entry in authored order; each checkpoints independently. */
+  async enterChildren(instance, children) {
+    for (const child of children) {
+      if (this.closing) return;
+      const row = this.store.getScope(child.id);
+      if (!row || row.current_execution_id === null || row.active !== 1) {
+        continue;
+      }
+      const executionId = row.current_execution_id;
+      if (child.activeExecutionId !== null) continue;
+      await this.track(
+        child,
+        executionId,
+        () => this.advance(child, executionId)
+      );
+    }
+    this.scheduleIdle(instance);
+  }
+  /** After a scope settles: route completion and resume an ancestor waiting to exit it. */
+  onIdle(instance) {
+    this.checkCompletion(instance);
+    for (let parentId = instance.scope?.parentId ?? null; parentId; ) {
+      const parent = this.instances.get(parentId);
+      if (!parent) return;
+      this.checkCompletion(parent);
+      this.resumeExit(parent);
+      parentId = parent.scope?.parentId ?? null;
+    }
+  }
+  /** Resumes an ancestor's exit that was waiting for a descendant's onExit. */
+  resumeExit(instance) {
+    if (instance.activeExecutionId !== null || this.closing) return;
+    const row = this.store.getScope(instance.id);
+    if (!row || row.current_execution_id === null || row.status !== "running") {
+      return;
+    }
+    const execution = this.requireExecution(row.current_execution_id);
+    if (execution.step !== "exit-children" || execution.status !== "running") {
+      return;
+    }
+    void this.track(
+      instance,
+      execution.execution_id,
+      () => this.advance(instance, execution.execution_id)
+    ).catch((error) => {
+      this.markStalled(instance, error);
+      this.reportRecoveryError(error);
+    });
+  }
+  /**
+   * Fires the composite State's `trigger="done"` Transition once every child of the current
+   * activation has completed (ADR 0096). The request ID is derived from the activation, so the
+   * completion fires at most once, including across restarts.
+   */
+  checkCompletion(instance) {
+    if (instance.activeExecutionId !== null || this.closing) return;
+    const row = this.store.getScope(instance.id);
+    if (!row || row.status !== "ready" || row.active === 0) return;
+    if (this.ancestorBusy(instance)) return;
+    const activation = row.children_activation_id;
+    if (!activation) return;
+    const state = instance.flow.definition.statesByName.get(row.state);
+    const composition = state?.composition;
+    const done = composition?.done;
+    if (!composition || !done) return;
+    const current = this.store.listChildScopes(instance.id).filter((child) => child.active === 1);
+    if (current.some((child) => child.status !== "completed")) return;
+    const requestId2 = `done:${activation}`;
+    if (this.store.findExecutionByRequest(instance.id, requestId2)) return;
+    const regions = {};
+    for (const region of composition.regions) {
+      const inRegion = current.filter(
+        (child) => child.segment === region.segment
+      );
+      regions[region.name] = region.kind === "list" ? {
+        members: inRegion.map((child) => ({
+          key: child.member_key ?? "",
+          final: child.state
+        }))
+      } : { final: inRegion[0]?.state ?? null };
+    }
+    const payload = { regions };
+    const executionId = mintExecutionId();
+    this.store.transaction(() => {
+      this.store.insertExecution({
+        execution_id: executionId,
+        instance_id: instance.id,
+        kind: "dispatch",
+        request_id: requestId2,
+        input_json: canonicalJson({
+          fromState: row.state,
+          transition: done.name,
+          payload
+        }),
+        from_state: row.state,
+        transition: done.name,
+        to_state: null,
+        step: "guard",
+        status: "running",
+        handler_revision: instance.flow.root.handlerRevision
+      });
+      this.store.updateInstance(instance.id, {
+        status: "running",
+        current_execution_id: executionId
+      });
+      this.record(
+        instance.id,
+        "execution-started",
+        {
+          transition: done.name,
+          from: row.state,
+          destinations: done.destinations.map((target2) => target2.name),
+          payload,
+          trigger: "done"
+        },
+        { requestId: requestId2 }
+      );
+    });
+    this.notify(instance);
+    void this.track(
+      instance,
+      executionId,
+      () => this.advance(instance, executionId)
+    ).catch((error) => {
+      this.markStalled(instance, error);
+      this.reportRecoveryError(error);
+    });
+  }
+  // --- lookups -------------------------------------------------------------
+  requireExecution(executionId) {
+    const execution = this.store.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution ${executionId} is missing from storage`);
+    }
+    return execution;
+  }
+  requireOperation(operationId) {
+    const operation = this.store.getOperation(operationId);
+    if (!operation) {
+      throw new Error(`Operation ${operationId} is missing from storage`);
+    }
+    return operation;
+  }
+};
+function isThenable(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+var NO_REPLAY_REASON = "Interrupted work is never replayed after its activation exited; establish its outcome with Confirm it completed, or Terminate";
+function exhaustedReason(operation) {
+  const last = operation.last_error ? `: ${operation.last_error}` : "";
+  return `Automatic recovery exhausted after ${operation.attempts} attempts${last}`;
+}
+function nextStep(step) {
+  switch (step) {
+    case "on-exit":
+      return "on-transition";
+    case "on-transition":
+      return "commit";
+    case "on-enter":
+      return "children";
+  }
+}
+function callbackTarget(invocation, kind) {
+  const context = invocation.context;
+  switch (kind) {
+    case "resolve-start-state":
+      return null;
+    case "on-enter":
+    case "on-exit":
+    case "children":
+      return context.stateName;
+    case "guard":
+    case "on-transition":
+      return context.transitionName;
+  }
+}
+function callbackRef(operation) {
+  const target2 = operation.callback_target ?? "";
+  switch (operation.callback_kind) {
+    case "resolve-start-state":
+      return { kind: "resolve-start-state" };
+    case "on-enter":
+    case "on-exit":
+    case "children":
+      return { kind: operation.callback_kind, state: target2 };
+    case "guard":
+    case "on-transition":
+      return { kind: operation.callback_kind, transition: target2 };
+  }
+}
+
+// src/durable/resolve-input.ts
+import { z as z3 } from "zod";
+var target = {
+  operationId: z3.string().min(1).transform((value) => value),
+  expectedAttempts: z3.number().int().nonnegative(),
+  reason: z3.string().refine((value) => value.trim().length > 0, "A reason is required")
+};
+var confirmation = z3.discriminatedUnion("callback", [
+  z3.strictObject({
+    ...target,
+    action: z3.literal("confirm-completed"),
+    callback: z3.literal("guard"),
+    result: z3.boolean()
+  }),
+  z3.strictObject({
+    ...target,
+    action: z3.literal("confirm-completed"),
+    callback: z3.literal("resolve-start-state"),
+    result: z3.string()
+  }),
+  // A branching onTransition is confirmed with its selected destination (ADR 0087).
+  z3.strictObject({
+    ...target,
+    action: z3.literal("confirm-completed"),
+    callback: z3.literal("on-transition"),
+    result: z3.string().nullable().optional()
+  }).transform(
+    ({ result, ...input }) => typeof result === "string" ? { ...input, result } : input
+  ),
+  // A composite State's children callback is confirmed with its inputs and members (ADR 0096).
+  z3.strictObject({
+    ...target,
+    action: z3.literal("confirm-completed"),
+    callback: z3.literal("children"),
+    result: z3.json()
+  }),
+  z3.strictObject({
+    ...target,
+    action: z3.literal("confirm-completed"),
+    callback: z3.enum(["on-enter", "on-exit"]),
+    result: z3.null().optional()
+  }).transform(({ result, ...input }) => {
+    void result;
+    return input;
+  })
+]);
+var resolveInputSchema = z3.discriminatedUnion("action", [
+  z3.strictObject({ ...target, action: z3.literal("retry") }),
+  z3.strictObject({ ...target, action: z3.literal("terminate") }),
+  confirmation
+]);
+function parseResolveInput(value) {
+  const result = resolveInputSchema.safeParse(value);
+  if (!result.success) {
+    throw new InputError(`Invalid resolve input: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/durable/runtime.ts
+var runtimeCores = /* @__PURE__ */ new WeakMap();
+function createUnmanagedRuntime(options) {
+  const store = new SqliteStore(options.databasePath);
+  const core = new RuntimeCore(
+    store,
+    options.onObserverError ?? ((error) => console.error("State Flow observer failed", error)),
+    options.onRecoveryError ?? ((error) => console.error("State Flow background recovery failed", error))
+  );
+  const flowsByName = /* @__PURE__ */ new Map();
+  core.dependenciesOf = (flowName) => flowsByName.get(flowName)?.dependencies;
+  function registerFlow(compiled, dependencies) {
+    core.assertOpen();
+    const definition = loadFlowDefinition(compiled);
+    if (flowsByName.has(definition.flowName))
+      throw new InputError(
+        `Flow "${definition.flowName}" is already registered with this runtime`
+      );
+    for (const [name, placed] of definition.placed) {
+      const registered = flowsByName.get(name);
+      if (!registered) {
+        throw new InputError(
+          `Flow "${definition.flowName}" places "${name}": register "${name}" first so its dependencies are available`
+        );
+      }
+      if (registered.root.definitionId !== placed.definitionId) {
+        throw new InputError(
+          `Flow "${definition.flowName}" places "${name}" with definition ${placed.definitionId}, but the registered "${name}" has ${registered.root.definitionId}; register modules from the same build`
+        );
+      }
+    }
+    const flow = { definition, root: definition, dependencies };
+    const api = createFlowApi(core, flow);
+    flowsByName.set(definition.flowName, flow);
+    return api;
+  }
+  const runtime = {
+    async createFlow(compiled, dependencies) {
+      return registerFlow(
+        compiled,
+        dependencies
+      );
+    },
+    close: (options2) => core.close(options2),
+    handover: (options2) => core.handover(options2),
+    inspector: {
+      listInstances: (query) => core.listInstances(query),
+      getSnapshot: (id) => {
+        const valid = instanceId(id);
+        return core.store.getInstance(valid) ? core.snapshotOf(valid) : null;
+      },
+      history: (id, query) => core.history(instanceId(id), query),
+      subscribe(listener) {
+        const wrapped = (snapshot) => listener(snapshot);
+        core.runtimeListeners.add(wrapped);
+        return () => {
+          core.runtimeListeners.delete(wrapped);
+        };
+      },
+      lateOutcomes(query = {}) {
+        core.assertStoreOpen();
+        return Object.freeze(
+          core.pendingLateOutcomes(
+            query.instanceId === void 0 ? null : instanceId(query.instanceId)
+          )
+        );
+      },
+      subscribeLateOutcomes(listener) {
+        const wrapped = (outcome) => listener(outcome);
+        core.lateListeners.add(wrapped);
+        return () => {
+          core.lateListeners.delete(wrapped);
+        };
+      }
+    },
+    controls: {
+      acknowledgeLateOutcome(sequence) {
+        core.assertStoreOpen();
+        if (!Number.isInteger(sequence)) {
+          throw new InputError("Late outcome sequence must be an integer");
+        }
+        return core.store.acknowledgeLateOutcome(sequence);
+      },
+      async resolve(id, untrustedInput) {
+        core.assertOpen();
+        const valid = instanceId(id);
+        const input = parseResolveInput(untrustedInput);
+        const row = core.store.getInstance(valid);
+        if (!row) {
+          return {
+            outcome: "rejected",
+            reason: "unavailable",
+            message: `Instance ${valid} does not exist`
+          };
+        }
+        const flow = flowsByName.get(row.chart_name);
+        const loaded = flow ? loadInstance(core, flow, valid) : void 0;
+        if (loaded?.kind === "opened") {
+          return resolve(core, loaded.instance, input);
+        }
+        if (input.action === "terminate") {
+          return terminateUnloadable(core, valid, input);
+        }
+        return {
+          outcome: "rejected",
+          reason: "unavailable",
+          message: flow ? `Instance ${valid} cannot be loaded by the registered flow (${loaded?.kind}); only terminate is available` : `No flow named "${row.chart_name}" is registered; only terminate is available`
+        };
+      },
+      restartRecovery(id) {
+        const instance = core.instances.get(instanceId(id));
+        return instance ? core.restartRecovery(instance) : false;
+      }
+    }
+  };
+  runtimeCores.set(runtime, core);
+  return runtime;
+}
+function createFlowApi(core, flow) {
+  const definition = flow.root;
+  const instanceApis = /* @__PURE__ */ new WeakMap();
+  const apiFor = (instance) => {
+    let api = instanceApis.get(instance);
+    if (!api) {
+      api = createInstanceApi(core, instance);
+      instanceApis.set(instance, api);
+    }
+    return api;
+  };
+  async function createInstance(id) {
+    if (core.instances.has(id) || core.store.getInstance(id)) {
+      return { kind: "already-exists", id };
+    }
+    const executionId = mintExecutionId();
+    core.store.transaction(() => {
+      core.store.insertInstance({
+        instance_id: id,
+        chart_name: definition.flowName,
+        definition_id: definition.definitionId,
+        state: definition.initialState.name,
+        status: "running",
+        status_reason: null,
+        current_execution_id: executionId
+      });
+      core.store.insertExecution({
+        execution_id: executionId,
+        instance_id: id,
+        kind: "create",
+        request_id: null,
+        // `resolveStartState` (or the initial state) chooses where the instance starts. The field
+        // stays null; executions persisted by earlier versions may still carry a start state.
+        input_json: canonicalJson({ startState: null }),
+        from_state: null,
+        transition: null,
+        to_state: null,
+        step: "resolve-start-state",
+        status: "running",
+        handler_revision: definition.handlerRevision
+      });
+      core.record(id, "instance-created", {
+        flowName: definition.flowName,
+        definitionId: definition.definitionId
+      });
+    });
+    const instance = new InstanceCore(id, flow);
+    core.instances.set(id, instance);
+    await core.track(
+      instance,
+      executionId,
+      () => core.advance(instance, executionId)
+    );
+    return { kind: "created", instance, executionId };
+  }
+  return {
+    flowName: definition.flowName,
+    definitionId: definition.definitionId,
+    async ensureInstance(input) {
+      core.assertOpen();
+      const id = instanceId(input.instanceId);
+      let loaded = loadInstance(core, flow, id);
+      if (loaded.kind === "not-found") {
+        const created = await createInstance(id);
+        loaded = created.kind === "created" ? { kind: "opened", instance: created.instance } : loadInstance(core, flow, id);
+      }
+      if (loaded.kind === "mismatch") {
+        throw new DefinitionMismatchError(
+          loaded.context
+        );
+      }
+      if (loaded.kind === "not-found") {
+        throw new InputError(`Instance ${id} disappeared during ensure`);
+      }
+      return apiFor(loaded.instance);
+    }
+  };
+}
+var UNFINISHED = /* @__PURE__ */ new Set([
+  "running",
+  "recovering",
+  "needs-attention"
+]);
+function loadInstance(core, flow, id) {
+  const definition = flow.root;
+  const row = core.store.getScope(id);
+  if (!row) {
+    return { kind: "not-found" };
+  }
+  const cached = core.instances.get(id);
+  if (row.root_instance_id != null || row.chart_name !== definition.flowName || row.definition_id !== definition.definitionId || cached !== void 0 && cached.flow !== flow) {
+    return {
+      kind: "mismatch",
+      context: {
+        reason: "definition",
+        instanceId: id,
+        message: row.root_instance_id != null ? `Instance ${id} is a nested scope of ${row.root_instance_id}, not a root instance` : `Instance ${id} uses flow "${row.chart_name}" with definition ${row.definition_id}; this flow uses "${definition.flowName}" with definition ${definition.definitionId}`,
+        storedFlowName: row.chart_name,
+        storedDefinitionId: row.definition_id,
+        currentDefinitionId: definition.definitionId
+      }
+    };
+  }
+  if (cached === void 0) {
+    const stale = core.store.unfinishedHandlerRevisions(id).find((revision) => revision !== definition.handlerRevision);
+    if (stale !== void 0) {
+      return {
+        kind: "mismatch",
+        context: {
+          reason: "handler-revision",
+          instanceId: id,
+          message: `Instance ${id} has unresolved work from handler revision ${stale}; this build uses ${definition.handlerRevision}`,
+          storedHandlerRevision: stale,
+          currentHandlerRevision: definition.handlerRevision
+        }
+      };
+    }
+  }
+  if (cached) {
+    if (cached.stalled) {
+      core.startRecovery(cached);
+    }
+    return { kind: "opened", instance: cached };
+  }
+  const instance = new InstanceCore(id, flow);
+  core.instances.set(id, instance);
+  core.startRecovery(instance);
+  if (definition.composite) {
+    const scopes = core.store.listScopes(id).filter((scope) => scope.active === 1 || UNFINISHED.has(scope.status)).map((scope) => core.scopeCore(flow, scope));
+    for (const scope of scopes) {
+      core.startRecovery(scope);
+    }
+    for (const scope of [instance, ...scopes]) {
+      core.scheduleIdle(scope);
+    }
+  }
+  return { kind: "opened", instance };
+}
+function activeChildScope(core, parentId, segment, memberKey) {
+  return core.store.listChildScopes(parentId).find(
+    (row) => row.active === 1 && row.segment === segment && (row.member_key ?? null) === memberKey
+  );
+}
+function regionAt(graph, segment) {
+  for (const state of graph.statesByName.values()) {
+    for (const region of state.composition?.regions ?? []) {
+      if (region.segment === segment) return region;
+    }
+  }
+  return void 0;
+}
+function scopeNavigation(core, locator) {
+  return (segment, memberKey) => {
+    const region = regionAt(locator.graph, segment);
+    if (!region) {
+      throw new InputError(
+        `No nested scope ${JSON.stringify(segment)} in ${locator.path === "" ? `flow "${locator.graph.flowName}"` : `scope "${locator.path}"`}`
+      );
+    }
+    if (region.kind === "list" !== (memberKey !== void 0)) {
+      throw new InputError(
+        region.kind === "list" ? `Scope ${JSON.stringify(segment)} is a FlowList: pass a member key` : `Scope ${JSON.stringify(segment)} is not a FlowList: it takes no member key`
+      );
+    }
+    const key = memberKey ?? null;
+    if (key !== null && (typeof key !== "string" || key.length === 0)) {
+      throw new InputError("FlowList member keys are non-empty strings");
+    }
+    return createScopeHandle(core, {
+      root: locator.root,
+      parentId: locator.parentId,
+      graph: region.graph,
+      path: locator.path === "" ? segment : `${locator.path}/${segment}`,
+      segment,
+      memberKey: key
+    });
+  };
+}
+function createScopeHandle(core, target2) {
+  const resolveRow = () => {
+    const parentId = target2.parentId();
+    return parentId === null ? void 0 : activeChildScope(core, parentId, target2.segment, target2.memberKey);
+  };
+  const resolveCore = () => {
+    const row = resolveRow();
+    return row ? core.scopeCore(target2.root.flow, row) : void 0;
+  };
+  return {
+    path: target2.path,
+    memberKey: target2.memberKey,
+    scope: scopeNavigation(core, {
+      root: target2.root,
+      parentId: () => resolveRow()?.instance_id ?? null,
+      graph: target2.graph,
+      path: target2.memberKey === null ? target2.path : `${target2.path}[${target2.memberKey}]`
+    }),
+    getSnapshot: () => {
+      core.assertStoreOpen();
+      const row = resolveRow();
+      return row ? core.snapshotOf(row.instance_id) : null;
+    },
+    history: (query) => {
+      const row = resolveRow();
+      return row ? core.history(row.instance_id, query) : Object.freeze({ events: Object.freeze([]), nextAfterSequence: null });
+    },
+    when(from) {
+      const hasOutgoing = [...target2.graph.transitionsByName.values()].some(
+        (transition) => transition.from.name === from && transition.trigger === "dispatch"
+      );
+      if (!hasOutgoing) {
+        throw new InputError(
+          `State ${JSON.stringify(from)} has no dispatchable transitions in scope "${target2.path}"`
+        );
+      }
+      return {
+        handle(handlers) {
+          assertHandlers(handlers, SCOPED_DISPATCH_OUTCOMES);
+          return {
+            dispatch: async (input) => {
+              core.assertOpen();
+              const requestId2 = requestId(input.requestId);
+              const recorded = core.store.findScopedExecutionByRequest(
+                target2.root.id,
+                target2.path,
+                target2.memberKey,
+                requestId2
+              );
+              const scopeCore = resolveCore();
+              if (recorded && recorded.instance_id !== scopeCore?.id) {
+                const owner = core.scopeCore(
+                  target2.root.flow,
+                  core.store.getScope(recorded.instance_id)
+                );
+                return dispatch(core, owner, from, handlers, input);
+              }
+              if (!scopeCore) {
+                return handlers.inactive({ input });
+              }
+              return dispatch(core, scopeCore, from, handlers, input);
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function createInstanceApi(core, instance) {
+  const definition = instance.flow.definition;
+  const api = {
+    instanceId: instance.id,
+    scope: scopeNavigation(core, {
+      root: instance,
+      parentId: () => instance.id,
+      graph: definition,
+      path: ""
+    }),
+    getSnapshot: () => core.snapshot(instance),
+    subscribe(listener) {
+      const wrapped = (snapshot) => listener(snapshot);
+      instance.listeners.add(wrapped);
+      return () => {
+        instance.listeners.delete(wrapped);
+      };
+    },
+    history: (query) => core.history(instance.id, query),
+    when(from) {
+      const hasOutgoing = [...definition.transitionsByName.values()].some(
+        (transition) => transition.from.name === from && transition.trigger === "dispatch"
+      );
+      if (!hasOutgoing) {
+        throw new InputError(
+          `State ${JSON.stringify(from)} has no outgoing transitions in flow "${definition.flowName}"`
+        );
+      }
+      return {
+        handle(handlers) {
+          assertHandlers(handlers, DISPATCH_OUTCOMES);
+          return {
+            dispatch: (input) => dispatch(core, instance, from, handlers, input)
+          };
+        }
+      };
+    },
+    handleResolve(handlers) {
+      assertHandlers(handlers, ["accepted", "rejected"]);
+      return {
+        resolve: async (input) => {
+          const result = await resolve(core, instance, input);
+          return handlers[result.outcome](result);
+        }
+      };
+    },
+    handleRestart(handlers) {
+      assertHandlers(handlers, ["restarted", "not-restarted"]);
+      return {
+        restart: () => handlers[core.restartRecovery(instance) ? "restarted" : "not-restarted"]({})
+      };
+    }
+  };
+  return api;
+}
+var DISPATCH_OUTCOMES = [
+  "applied",
+  "blocked",
+  "invalid-payload",
+  "busy",
+  "recovery-pending",
+  "needs-attention",
+  "state-mismatch",
+  "request-conflict",
+  "terminated",
+  "completed"
+];
+var SCOPED_DISPATCH_OUTCOMES = [
+  ...DISPATCH_OUTCOMES,
+  "interrupted",
+  "inactive"
+];
+function assertHandlers(handlers, expected) {
+  const missing = expected.filter((key) => typeof handlers[key] !== "function");
+  const extra = Object.keys(handlers).filter((key) => !expected.includes(key));
+  if (missing.length > 0 || extra.length > 0) {
+    throw new InputError(
+      `Outcome handlers must be exactly ${expected.join(", ")}` + (missing.length ? `; missing ${missing.join(", ")}` : "") + (extra.length ? `; unexpected ${extra.join(", ")}` : "")
+    );
+  }
+}
+function requireWork(core, id) {
+  const work = core.currentWork(id);
+  if (!work) {
+    throw new Error(`Instance ${id} has no unresolved work`);
+  }
+  return work;
+}
+function reasonOf(snapshot) {
+  return snapshot.status.kind === "needs-attention" || snapshot.status.kind === "terminated" ? snapshot.status.reason : "";
+}
+function recordedDispatch(core, instance, handlers, input, requestId2, inputJson) {
+  const recorded = core.store.findExecutionByRequest(instance.id, requestId2);
+  if (!recorded) return { found: false };
+  if (recorded.input_json !== inputJson) {
+    const original = parseJson(recorded.input_json);
+    return {
+      found: true,
+      value: handlers["request-conflict"]({ input, recorded: original })
+    };
+  }
+  if (instance.activeExecutionId === recorded.execution_id && recorded.status !== "interrupted")
+    return {
+      found: true,
+      value: handlers.busy({ input, snapshot: core.snapshot(instance) })
+    };
+  return {
+    found: true,
+    value: selectRecorded(core, instance, handlers, input, recorded, true)
+  };
+}
+async function dispatch(core, instance, from, handlers, input) {
+  core.assertOpen();
+  const { definition } = instance.flow;
+  const requestId2 = requestId(input.requestId);
+  const transition = definition.transitionsByName.get(input.transition);
+  if (!transition || transition.from.name !== from) {
+    throw new InputError(
+      `Transition ${JSON.stringify(input.transition)} does not leave "${from}" in flow "${definition.flowName}"`
+    );
+  }
+  if (transition.trigger === "done") {
+    throw new InputError(
+      `Transition ${JSON.stringify(transition.name)} fires when the children of "${from}" complete; it cannot be dispatched`
+    );
+  }
+  const payload = input.payload === void 0 ? null : input.payload;
+  const problem = findNonJsonValue(payload);
+  if (problem) {
+    return handlers["invalid-payload"]({
+      input,
+      issues: [
+        { path: [], message: `Payload is not JSON-compatible: ${problem}` }
+      ]
+    });
+  }
+  const payloadJson = canonicalJson(payload);
+  input = Object.freeze({
+    requestId: requestId2,
+    transition: transition.name,
+    payload: parseJson(payloadJson)
+  });
+  const inputJson = canonicalJson({
+    fromState: from,
+    transition: transition.name,
+    payload: input.payload
+  });
+  const previous = recordedDispatch(
+    core,
+    instance,
+    handlers,
+    input,
+    requestId2,
+    inputJson
+  );
+  if (previous.found) return previous.value;
+  const parsed = await transition.payloadSchema.safeParseAsync(
+    parseJson(payloadJson)
+  );
+  core.assertOpen();
+  const concurrent = recordedDispatch(
+    core,
+    instance,
+    handlers,
+    input,
+    requestId2,
+    inputJson
+  );
+  if (concurrent.found) return concurrent.value;
+  if (!parsed.success) {
+    return handlers["invalid-payload"]({
+      input,
+      issues: parsed.error.issues.map(({ path, message }) => ({
+        path,
+        message
+      }))
+    });
+  }
+  const parsedProblem = findNonJsonValue(parsed.data);
+  if (parsedProblem || canonicalJson(parsed.data) !== payloadJson) {
+    return handlers["invalid-payload"]({
+      input,
+      issues: [
+        {
+          path: [],
+          message: "Payload schemas must preserve the JSON input; coercion, defaults, transforms and stripped fields are not supported"
+        }
+      ]
+    });
+  }
+  if (instance.activeExecutionId !== null) {
+    return handlers.busy({ input, snapshot: core.snapshot(instance) });
+  }
+  const row = core.requireInstanceRow(instance.id);
+  const snapshot = core.snapshot(instance);
+  if (instance.scope !== null && row.active !== 1) {
+    return handlers.inactive({ input });
+  }
+  switch (row.status) {
+    case "completed":
+      return handlers.completed({ input, snapshot });
+    case "terminated":
+      return handlers.terminated({
+        input,
+        snapshot,
+        reason: row.status_reason ?? ""
+      });
+    case "needs-attention":
+      return handlers["needs-attention"]({
+        input,
+        snapshot,
+        work: requireWork(core, instance.id),
+        reason: row.status_reason ?? ""
+      });
+    case "recovering":
+      return handlers["recovery-pending"]({
+        input,
+        snapshot,
+        work: requireWork(core, instance.id)
+      });
+    case "running":
+      return handlers.busy({ input, snapshot });
+    case "exited":
+      return handlers.inactive({ input });
+    case "ready":
+      break;
+  }
+  if (row.state !== from) {
+    return handlers["state-mismatch"]({
+      input,
+      expectedState: from,
+      actualState: row.state,
+      snapshot
+    });
+  }
+  if (core.ancestorBusy(instance) || transition.from.composition !== null && transition.childWork === "block" && core.hasBusyDescendant(instance)) {
+    return handlers.busy({ input, snapshot });
+  }
+  const executionId = mintExecutionId();
+  core.store.transaction(() => {
+    core.store.insertExecution({
+      execution_id: executionId,
+      instance_id: instance.id,
+      kind: "dispatch",
+      request_id: requestId2,
+      input_json: inputJson,
+      from_state: from,
+      transition: transition.name,
+      // Selected by onTransition for a branching transition; recorded before the commit.
+      to_state: null,
+      step: "guard",
+      status: "running",
+      handler_revision: instance.flow.root.handlerRevision
+    });
+    core.store.updateInstance(instance.id, {
+      status: "running",
+      current_execution_id: executionId
+    });
+    core.record(
+      instance.id,
+      "execution-started",
+      {
+        transition: transition.name,
+        from,
+        destinations: transition.destinations.map((state) => state.name),
+        payload: input.payload,
+        ...transition.from.composition !== null ? { childWork: transition.childWork } : {}
+      },
+      { requestId: requestId2 }
+    );
+  });
+  core.notify(instance);
+  await core.track(
+    instance,
+    executionId,
+    () => core.advance(instance, executionId)
+  );
+  return selectRecorded(
+    core,
+    instance,
+    handlers,
+    input,
+    core.requireExecution(executionId),
+    false
+  );
+}
+function selectRecorded(core, instance, handlers, input, execution, duplicate) {
+  const snapshot = core.snapshot(instance);
+  switch (execution.status) {
+    case "applied":
+      return handlers.applied({
+        input,
+        snapshot,
+        duplicate,
+        destination: execution.to_state
+      });
+    case "blocked":
+      return handlers.blocked({ input, snapshot, duplicate });
+    case "terminated":
+      return handlers.terminated({
+        input,
+        snapshot,
+        reason: reasonOf(snapshot)
+      });
+    case "interrupted":
+      return handlers.interrupted({ input, snapshot, duplicate });
+    case "needs-attention": {
+      const work = core.currentWork(instance.id);
+      if (work) {
+        return handlers["needs-attention"]({
+          input,
+          snapshot,
+          work,
+          reason: reasonOf(snapshot)
+        });
+      }
+      return handlers.busy({ input, snapshot });
+    }
+    case "recovering":
+    case "running": {
+      const work = core.currentWork(instance.id);
+      if (work && snapshot.status.kind === "recovering") {
+        return handlers["recovery-pending"]({ input, snapshot, work });
+      }
+      return handlers.busy({ input, snapshot });
+    }
+  }
+}
+async function resolve(core, root, untrustedInput) {
+  core.assertOpen();
+  const input = parseResolveInput(untrustedInput);
+  const instance = operationOwner(core, root, input.operationId);
+  const row = core.requireInstanceRow(instance.id);
+  const execution = row.current_execution_id === null ? void 0 : core.store.getExecution(row.current_execution_id);
+  const operation = execution ? core.store.findUnresolvedOperation(execution.execution_id) : void 0;
+  if (instance.activeExecutionId !== null || row.status !== "needs-attention" || !execution || !operation || operation.status !== "needs-attention" || operation.operation_id !== input.operationId || operation.attempts !== input.expectedAttempts) {
+    return staleRejection(root.id, input, operation);
+  }
+  const fenced = execution.status === "interrupted";
+  const refs = {
+    requestId: execution.request_id,
+    operationId: operation.operation_id
+  };
+  const audit = (data) => {
+    core.record(
+      instance.id,
+      "manual-resolution",
+      { action: input.action, reason: input.reason, ...data },
+      refs
+    );
+    if (instance !== root) {
+      core.recordScopeEvent(instance, "manual-resolution", {
+        action: input.action,
+        reason: input.reason,
+        operationId: operation.operation_id,
+        ...data
+      });
+    }
+  };
+  switch (input.action) {
+    case "terminate":
+      terminateTree(core, root.id, input.reason, audit);
+      return { outcome: "accepted", snapshot: core.snapshot(root) };
+    case "retry": {
+      if (fenced && operation.strategy !== "reconcile") {
+        return {
+          outcome: "rejected",
+          reason: "not-replayable",
+          message: `Operation ${operation.operation_id} belongs to an exited activation; interrupted work is never replayed. Confirm its outcome or terminate.`
+        };
+      }
+      await core.manualRetry(instance, execution, operation, () => audit({}));
+      return { outcome: "accepted", snapshot: core.snapshot(root) };
+    }
+    case "confirm-completed": {
+      if (input.callback !== operation.callback_kind) {
+        return {
+          outcome: "rejected",
+          reason: "callback-mismatch",
+          message: `Operation ${operation.operation_id} is ${operation.callback_kind}, not ${input.callback}`
+        };
+      }
+      const supplied = "result" in input ? input.result : void 0;
+      const validated = validateConfirmedResult(
+        instance.flow.definition,
+        operation.callback_kind,
+        supplied,
+        execution.transition,
+        execution.to_state
+      );
+      if (!validated.ok) {
+        return {
+          outcome: "rejected",
+          reason: "invalid-result",
+          message: validated.message
+        };
+      }
+      if (fenced) {
+        core.store.transaction(() => {
+          audit({ result: validated.result });
+          core.settleLate(
+            instance,
+            execution,
+            operation,
+            null,
+            validated.result,
+            "confirmed",
+            refs
+          );
+        });
+        return { outcome: "accepted", snapshot: core.snapshot(root) };
+      }
+      core.store.transaction(() => {
+        core.checkpoint(instance, execution, operation, validated.result);
+        audit({ result: validated.result });
+      });
+      core.notify(instance);
+      await core.track(
+        instance,
+        execution.execution_id,
+        () => core.advance(instance, execution.execution_id)
+      );
+      return { outcome: "accepted", snapshot: core.snapshot(root) };
+    }
+    default:
+      throw new InputError(
+        `Unknown resolve action ${JSON.stringify(input.action)}`
+      );
+  }
+}
+function operationOwner(core, root, operationId) {
+  const operation = core.store.getOperation(operationId);
+  if (!operation || operation.instance_id === root.id) return root;
+  const scope = core.store.getScope(operation.instance_id);
+  if (!scope || scope.root_instance_id !== root.id) return root;
+  return core.scopeCore(root.flow, scope);
+}
+function staleRejection(instanceId2, input, operation) {
+  const detail = operation && operation.operation_id === input.operationId ? ` (it has had ${operation.attempts} attempt(s); the action expected ${input.expectedAttempts})` : "";
+  return {
+    outcome: "rejected",
+    reason: "stale",
+    message: `Operation ${input.operationId} is not the work awaiting attention on instance ${instanceId2}${detail}`
+  };
+}
+function terminateTree(core, rootId, reason, audit) {
+  const rows = [
+    core.store.getScope(rootId),
+    ...core.store.listScopes(rootId)
+  ];
+  core.store.transaction(() => {
+    for (const row of rows) {
+      const execution = row.current_execution_id === null ? void 0 : core.store.getExecution(row.current_execution_id);
+      if (execution) {
+        const operation = core.store.findUnresolvedOperation(
+          execution.execution_id
+        );
+        if (operation) {
+          core.store.updateOperation(operation.operation_id, {
+            status: "terminated"
+          });
+        }
+        if (execution.status !== "interrupted") {
+          core.store.updateExecution(execution.execution_id, {
+            status: "terminated"
+          });
+        }
+      }
+      if (row.instance_id !== rootId) {
+        core.store.updateScope(row.instance_id, { active: 0 });
+      }
+      if (row.instance_id === rootId || row.active === 1 || UNFINISHED.has(row.status)) {
+        core.store.updateInstance(row.instance_id, {
+          status: "terminated",
+          status_reason: reason
+        });
+      }
+    }
+    audit({});
+    core.record(rootId, "instance-terminated", { reason });
+  });
+  for (const row of rows) {
+    const loaded = core.instances.get(row.instance_id);
+    if (!loaded) continue;
+    core.clearTimer(loaded);
+    if (loaded.scope !== null) {
+      loaded.abort.abort(new InputError("The instance was terminated"));
+    }
+  }
+  const root = core.instances.get(rootId);
+  if (root) core.notify(root);
+}
+function terminateUnloadable(core, instanceId2, input) {
+  const owner = core.store.getOperation(input.operationId);
+  const ownerRow = owner && owner.instance_id !== instanceId2 ? core.store.getScope(owner.instance_id) : void 0;
+  const rowId = ownerRow && ownerRow.root_instance_id === instanceId2 ? ownerRow.instance_id : instanceId2;
+  const row = core.requireInstanceRow(rowId);
+  const cached = core.instances.get(rowId);
+  const execution = row.current_execution_id === null ? void 0 : core.store.getExecution(row.current_execution_id);
+  const operation = execution ? core.store.findUnresolvedOperation(execution.execution_id) : void 0;
+  if (cached !== void 0 && cached.activeExecutionId !== null || row.status === "ready" || row.status === "terminated" || row.status === "completed" || row.status === "exited" || !execution || !operation || operation.operation_id !== input.operationId || operation.attempts !== input.expectedAttempts) {
+    return staleRejection(instanceId2, input, operation);
+  }
+  terminateTree(
+    core,
+    instanceId2,
+    input.reason,
+    (data) => core.record(
+      instanceId2,
+      "manual-resolution",
+      { action: "terminate", reason: input.reason, unloadable: true, ...data },
+      { requestId: execution.request_id, operationId: operation.operation_id }
+    )
+  );
+  return { outcome: "accepted", snapshot: core.snapshotOf(instanceId2) };
+}
+function validateConfirmedResult(definition, kind, result, transitionName, stateName) {
+  const transition = kind === "on-transition" ? definition.transitionsByName.get(transitionName ?? "") : void 0;
+  const producesResult = kind === "guard" || kind === "resolve-start-state" || kind === "children" || transition !== void 0 && isBranching(transition);
+  if (!producesResult && result !== void 0 && result !== null) {
+    return { ok: false, message: `${kind} does not produce a result` };
+  }
+  return validateCallbackResult(
+    definition,
+    kind,
+    result,
+    transitionName,
+    stateName
+  );
+}
+
+// src/durable/create-runtime.ts
+function createRuntime(options) {
+  const { shutdownTimeoutMs, ...runtimeOptions } = options;
+  const runtime = createUnmanagedRuntime(runtimeOptions);
+  const close = runtime.close;
+  const handover = runtime.handover;
+  runtime.close = (options2) => close({ timeoutMs: options2?.timeoutMs ?? shutdownTimeoutMs });
+  runtime.handover = (options2) => handover({ timeoutMs: options2?.timeoutMs ?? shutdownTimeoutMs });
+  return Object.assign(runtime, {
+    [Symbol.asyncDispose]: () => runtime.close()
+  });
+}
+
+// src/durable/scoped-runtime.ts
+async function withRuntime(options, run) {
+  const runtime = createRuntime(options);
+  let work;
+  try {
+    work = { ok: true, value: await run(runtime) };
+  } catch (error) {
+    work = { ok: false, error };
+  }
+  try {
+    await runtime.close();
+  } catch (error) {
+    if (!work.ok)
+      throw new AggregateError(
+        [work.error, error],
+        "Application work and State Flow shutdown both failed"
+      );
+    throw error;
+  }
+  if (!work.ok) throw work.error;
+  return work.value;
+}
+
+// src/durable/recovery-target.ts
+function recoveryTarget(work) {
+  const target2 = {
+    operationId: work.operationId,
+    expectedAttempts: work.attempts
+  };
+  const base = {
+    retry: (reason) => ({ ...target2, action: "retry", reason }),
+    terminate: (reason) => ({ ...target2, action: "terminate", reason })
+  };
+  switch (work.callback.kind) {
+    case "guard":
+      return Object.freeze({
+        ...base,
+        callback: "guard",
+        confirm: (result, reason) => ({
+          ...target2,
+          action: "confirm-completed",
+          callback: "guard",
+          result,
+          reason
+        })
+      });
+    case "resolve-start-state":
+      return Object.freeze({
+        ...base,
+        callback: "resolve-start-state",
+        confirm: (result, reason) => ({
+          ...target2,
+          action: "confirm-completed",
+          callback: "resolve-start-state",
+          result,
+          reason
+        })
+      });
+    case "children":
+      return Object.freeze({
+        ...base,
+        callback: "children",
+        confirm: (result, reason) => ({
+          ...target2,
+          action: "confirm-completed",
+          callback: "children",
+          result,
+          reason
+        })
+      });
+    case "on-transition":
+      return Object.freeze({
+        ...base,
+        callback: "on-transition",
+        confirm: (reason, destination) => ({
+          ...target2,
+          action: "confirm-completed",
+          callback: "on-transition",
+          ...destination === void 0 ? {} : { result: destination },
+          reason
+        })
+      });
+    default: {
+      const callback = work.callback.kind;
+      return Object.freeze({
+        ...base,
+        callback,
+        confirm: (reason) => ({
+          ...target2,
+          action: "confirm-completed",
+          callback,
+          reason
+        })
+      });
+    }
+  }
+}
+export {
+  DefinitionError,
+  DefinitionMismatchError,
+  InputError,
+  MAX_ATTEMPTS,
+  OwnershipError,
+  RECOVERY_DELAYS_MS,
+  RuntimeClosedError,
+  RuntimeError,
+  SchemaError,
+  ShutdownTimeoutError,
+  checkDeployment,
+  createRuntime,
+  createUnmanagedRuntime,
+  instanceId,
+  parseResolveInput,
+  recoveryTarget,
+  requestId,
+  resolveInputSchema,
+  withRuntime
+};