@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-HRRI4BLF.js

@@ -0,0 +1,4456 @@
+import {
+  FLOW_CONNECTION_BINDINGS_MAP_KEY,
+  MAX_RUN_ACTION_OUTPUT_BYTES,
+  appendRunTimelineEvent,
+  appendRunTimelineEvents,
+  boundRunActionOutput,
+  boundRunEventJson,
+  createRunEventIdempotencyKey
+} from "./chunk-F4PTFXZH.js";
+import {
+  DESIGN_POD_METHODS,
+  INVOCATIONS_MAP_KEY,
+  canonicalDesignPodJson,
+  digestDesignPodValue,
+  readDesignPodDefinition,
+  readDesignPodState
+} from "./chunk-JIDTNKKL.js";
+import {
+  getNestedValue
+} from "./chunk-JVROGQ7Q.js";
+import {
+  DM_NOTIFICATIONS_MAP_KEY,
+  RUNS_MAP_KEY,
+  RUNS_TERMINAL_MAP_KEY,
+  RUNS_TERMINAL_PENDING_MAP_KEY,
+  assertRunActionExecutionAllowed,
+  collectPhantomLegacyRun,
+  createRunRuntimeReaderWithDoc,
+  createRunScopedRuntimeManager,
+  ensureRun,
+  ensureRunScopedMap,
+  getAction,
+  getExistingRunsMap,
+  getExistingRunsTerminalMap,
+  getExistingRunsTerminalPendingMap,
+  getRunMeta,
+  getRunScopedMap,
+  getRunsTerminalMap,
+  getRunsTerminalPendingMap,
+  isBelowTheLineBlock,
+  isRecordInRun,
+  isRepeatableAction,
+  readActionState,
+  resetActionState,
+  resolveActiveRunId,
+  resolveRecordRunId,
+  resolveRunIdForExecution,
+  seedRunFromLegacyRuntime,
+  setMultiRunStorage,
+  usesLegacyRuntimeCompatibility,
+  writeActionState
+} from "./chunk-IIIZZ4E4.js";
+import {
+  warnOnce
+} from "./chunk-HT6L7A5M.js";
+import {
+  assertLegacyFlowOperationAllowed
+} from "./chunk-RRYBAE6E.js";
+import {
+  getExistingYMap,
+  isYDocLike
+} from "./chunk-NCSGIRRQ.js";
+
+// src/core/types/baseUcan.ts
+function isRuntimeRef(value) {
+  return typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string";
+}
+
+// src/core/lib/flowEngine/triggers.ts
+import * as Y from "yjs";
+var RUN_RECORD_AUDIT_TYPE = "block.run";
+function computePendingInvocationId(args) {
+  const { sourceBlockId, sourceRunId, listenerBlockId, eventName, eventIndex, sessionRunId } = args;
+  const input = `${sessionRunId ? `${sessionRunId}:` : ""}${sourceBlockId}:${sourceRunId}:${listenerBlockId}:${eventName}:${eventIndex}`;
+  return `pi-${fnv1a32(input)}`;
+}
+function snapshotInputRefs(inputs, getNodeOutput2) {
+  const snapshots = {};
+  walkRefs(inputs, (ref) => {
+    if (ref.$ref.startsWith("trigger.")) return;
+    const parsed = parseOutputRef(ref.$ref);
+    if (!parsed) return;
+    const output = getNodeOutput2(parsed.nodeId);
+    if (!output) return;
+    snapshots[ref.$ref] = getNestedValue(output, parsed.fieldPath);
+  });
+  return snapshots;
+}
+function walkRefs(value, visit) {
+  if (isRuntimeRef(value)) {
+    visit(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) walkRefs(item, visit);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    for (const v of Object.values(value)) walkRefs(v, visit);
+  }
+}
+function parseOutputRef(ref) {
+  const outputIndex = ref.indexOf(".output.");
+  if (outputIndex === -1) return null;
+  return {
+    nodeId: ref.slice(0, outputIndex),
+    fieldPath: ref.slice(outputIndex + ".output.".length)
+  };
+}
+function fnv1a32(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+var PENDING_INVOCATIONS_MAP_KEY = "pendingInvocations";
+function getPendingInvocationsMap(yDoc, sessionRunId) {
+  if (usesLegacyRuntimeCompatibility(yDoc)) {
+    return yDoc.getMap(PENDING_INVOCATIONS_MAP_KEY);
+  }
+  return ensureRunScopedMap(yDoc, resolveRunIdForExecution(yDoc, sessionRunId), PENDING_INVOCATIONS_MAP_KEY);
+}
+function readPendingInvocationsMap(yDoc, sessionRunId) {
+  if (usesLegacyRuntimeCompatibility(yDoc)) {
+    return getExistingYMap(yDoc, PENDING_INVOCATIONS_MAP_KEY);
+  }
+  const runId = sessionRunId || resolveActiveRunId(yDoc);
+  if (!runId) return void 0;
+  return getRunScopedMap(yDoc, runId, PENDING_INVOCATIONS_MAP_KEY);
+}
+function countPendingInvocations(yDoc, sessionRunId) {
+  const outer = readPendingInvocationsMap(yDoc, sessionRunId);
+  if (!outer) return 0;
+  let count = 0;
+  outer.forEach((inner) => {
+    if (inner && typeof inner.forEach === "function") {
+      inner.forEach(() => {
+        count += 1;
+      });
+    }
+  });
+  return count;
+}
+function getOrCreateBlockPendingMap(yDoc, blockId, sessionRunId) {
+  const outer = getPendingInvocationsMap(yDoc, sessionRunId);
+  let inner = outer.get(blockId);
+  if (!inner) {
+    inner = new Y.Map();
+    outer.set(blockId, inner);
+  }
+  return inner;
+}
+function readPendingInvocations(yDoc, blockId, sessionRunId) {
+  const outer = readPendingInvocationsMap(yDoc, sessionRunId);
+  if (!outer) return [];
+  const inner = outer.get(blockId);
+  if (!inner) return [];
+  const items = [];
+  inner.forEach((value) => {
+    if (value && typeof value === "object") {
+      items.push(value);
+    }
+  });
+  items.sort((a, b) => a.emittedAt.localeCompare(b.emittedAt));
+  return items;
+}
+function queuePendingInvocation(yDoc, listenerBlockId, invocation, sessionRunId) {
+  let created = false;
+  yDoc.transact(() => {
+    const inner = getOrCreateBlockPendingMap(yDoc, listenerBlockId, sessionRunId || invocation.sessionRunId);
+    if (inner.has(invocation.id)) return;
+    inner.set(invocation.id, invocation);
+    created = true;
+  });
+  return created;
+}
+function removePendingInvocation(yDoc, listenerBlockId, pendingInvocationId, sessionRunId) {
+  const outer = readPendingInvocationsMap(yDoc, sessionRunId);
+  if (!outer) return false;
+  const inner = outer.get(listenerBlockId);
+  if (!inner) return false;
+  if (!inner.has(pendingInvocationId)) return false;
+  inner.delete(pendingInvocationId);
+  return true;
+}
+function readConsumedPendingInvocationIds(yDoc, listenerBlockId, sessionRunId) {
+  const consumed = /* @__PURE__ */ new Set();
+  for (const record of readRunRecords(yDoc, listenerBlockId, sessionRunId)) {
+    if (record.fromPendingInvocationId) consumed.add(record.fromPendingInvocationId);
+  }
+  return consumed;
+}
+function sweepExpiredPendingInvocations(yDoc, now = Date.now(), sessionRunId) {
+  const outer = readPendingInvocationsMap(yDoc, sessionRunId);
+  if (!outer) return 0;
+  let removed = 0;
+  outer.forEach((inner, listenerBlockId) => {
+    const innerMap = inner;
+    if (!innerMap || typeof innerMap.forEach !== "function") return;
+    const expiredIds = [];
+    innerMap.forEach((value, id) => {
+      const expiresAt = value?.expiresAt;
+      if (expiresAt && Date.parse(expiresAt) < now) expiredIds.push(id);
+    });
+    for (const id of expiredIds) {
+      innerMap.delete(id);
+      removed += 1;
+    }
+    void listenerBlockId;
+  });
+  return removed;
+}
+var BARRIER_STATE_MAP_KEY = "barrierState";
+function getBarrierStateMap(yDoc, sessionRunId) {
+  if (usesLegacyRuntimeCompatibility(yDoc)) {
+    return yDoc.getMap(BARRIER_STATE_MAP_KEY);
+  }
+  return ensureRunScopedMap(yDoc, resolveRunIdForExecution(yDoc, sessionRunId), BARRIER_STATE_MAP_KEY);
+}
+function readBarrierStateMap(yDoc, sessionRunId) {
+  if (usesLegacyRuntimeCompatibility(yDoc)) {
+    return getExistingYMap(yDoc, BARRIER_STATE_MAP_KEY);
+  }
+  const runId = sessionRunId || resolveActiveRunId(yDoc);
+  if (!runId) return void 0;
+  return getRunScopedMap(yDoc, runId, BARRIER_STATE_MAP_KEY);
+}
+function getOrCreateListenerBarrierMap(yDoc, listenerBlockId, sessionRunId) {
+  const outer = getBarrierStateMap(yDoc, sessionRunId);
+  let inner = outer.get(listenerBlockId);
+  if (!inner) {
+    inner = new Y.Map();
+    outer.set(listenerBlockId, inner);
+  }
+  return inner;
+}
+function recordBarrierEvent(yDoc, listenerBlockId, entry, sessionRunId) {
+  let written = false;
+  yDoc.transact(() => {
+    const inner = getOrCreateListenerBarrierMap(yDoc, listenerBlockId, sessionRunId || entry.sessionRunId);
+    const key = `${entry.sourceBlockId}::${entry.eventName}`;
+    const existing = inner.get(key);
+    if (existing && typeof existing === "object" && existing.runId === entry.runId) return;
+    inner.set(key, entry);
+    written = true;
+  });
+  return written;
+}
+function readBarrierState(yDoc, listenerBlockId, sessionRunId) {
+  const outer = readBarrierStateMap(yDoc, sessionRunId);
+  if (!outer) return [];
+  const inner = outer.get(listenerBlockId);
+  if (!inner) return [];
+  const entries = [];
+  inner.forEach((value) => {
+    if (value && typeof value === "object") {
+      entries.push(value);
+    }
+  });
+  return entries;
+}
+function clearBarrierState(yDoc, listenerBlockId, sessionRunId) {
+  const outer = readBarrierStateMap(yDoc, sessionRunId);
+  if (!outer) return;
+  yDoc.transact(() => {
+    outer.delete(listenerBlockId);
+  });
+}
+function computeBarrierInvocationId(entries, listenerBlockId, sessionRunId) {
+  const sorted = [...entries].sort((a, b) => a.sourceBlockId.localeCompare(b.sourceBlockId));
+  const input = `${sessionRunId ? `${sessionRunId}|` : ""}${sorted.map((e) => `${e.sourceBlockId}:${e.runId}:${e.eventName}`).join("|")}|>${listenerBlockId}`;
+  return `bi-${fnv1a32(input)}`;
+}
+function mergeBarrierPayloads(entries) {
+  const merged = {};
+  for (const entry of entries) {
+    if (entry.alias) {
+      merged[entry.alias] = entry.payload;
+    } else {
+      Object.assign(merged, entry.payload);
+    }
+  }
+  return merged;
+}
+function appendRunRecord(yDoc, blockId, details, userId) {
+  const auditMap = yDoc.getMap("auditTrail");
+  yDoc.transact(() => {
+    let arr = auditMap.get(blockId);
+    if (!arr) {
+      arr = new Y.Array();
+      auditMap.set(blockId, arr);
+    }
+    const event = {
+      id: `${details.runId}`,
+      blockId,
+      type: RUN_RECORD_AUDIT_TYPE,
+      details,
+      message: void 0,
+      meta: {
+        timestamp: details.completedAt,
+        userId,
+        editable: false
+      }
+    };
+    arr.push([event]);
+  });
+}
+function readRunRecords(yDoc, blockId, sessionRunId) {
+  const auditMap = getExistingYMap(yDoc, "auditTrail");
+  if (!auditMap) return [];
+  const arr = auditMap.get(blockId);
+  if (!arr) return [];
+  const records = [];
+  arr.forEach((entry) => {
+    if (!entry || typeof entry !== "object") return;
+    const e = entry;
+    if (e.type === RUN_RECORD_AUDIT_TYPE && e.details) {
+      if (sessionRunId && !isRecordInRun(e.details.sessionRunId, sessionRunId)) {
+        return;
+      }
+      records.push(e.details);
+    }
+  });
+  return records;
+}
+function findFailedListenersForSourceRun(yDoc, sourceBlockId, sourceRunId, listenerBlockIds) {
+  const failures = [];
+  for (const listenerBlockId of listenerBlockIds) {
+    const records = readRunRecords(yDoc, listenerBlockId);
+    for (const record of records) {
+      if (!record.error) continue;
+      if (record.triggeredBy?.sourceBlockId !== sourceBlockId) continue;
+      if (record.fromPendingInvocationId == null) continue;
+      const sourceRunIdField = record.sourceRunId;
+      if (sourceRunIdField && sourceRunIdField !== sourceRunId) continue;
+      failures.push({ listenerBlockId, record });
+    }
+  }
+  return failures;
+}
+function replayFailedListenerRun(yDoc, failedRecord, listenerBlockId, originalPayload, originalRefSnapshots, assigneeDid, sessionRunId) {
+  if (!failedRecord.triggeredBy) return false;
+  const replayId = `${failedRecord.runId}:replay-${Date.now().toString(36)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const replay = {
+    id: replayId,
+    triggeringBlockId: failedRecord.triggeredBy.sourceBlockId,
+    sourceRunId: failedRecord.sourceRunId || failedRecord.runId,
+    sessionRunId: sessionRunId || failedRecord.sessionRunId,
+    eventName: failedRecord.triggeredBy.eventName,
+    eventIndex: 0,
+    payload: originalPayload,
+    refSnapshots: originalRefSnapshots,
+    assigneeDid,
+    emittedAt: now,
+    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+  };
+  return queuePendingInvocation(yDoc, listenerBlockId, replay, sessionRunId || failedRecord.sessionRunId);
+}
+
+// src/core/lib/flowEngine/versionManifest.ts
+var VERSION_MANIFEST = {
+  "0.3": {
+    version: "0.3",
+    label: "Legacy",
+    ucanRequired: false,
+    delegationRootRequired: false,
+    whitelistOnlyAllowed: true,
+    unrestrictedAllowed: true,
+    executionPath: "legacy",
+    authorizationFn: "v1",
+    allowedAuthModes: ["anyone", "actors", "capability"],
+    ui: {
+      showDelegationPanel: false,
+      showWhitelistConfig: true,
+      showAnyoneConfig: true,
+      showMigrationBanner: true,
+      requirePinForExecution: false
+    },
+    description: "Legacy version. UCAN optional, whitelist-only authorization accepted."
+  },
+  "1.0.0": {
+    version: "1.0.0",
+    label: "UCAN Required",
+    ucanRequired: true,
+    delegationRootRequired: true,
+    whitelistOnlyAllowed: false,
+    unrestrictedAllowed: false,
+    executionPath: "invocation",
+    authorizationFn: "v2",
+    allowedAuthModes: ["capability"],
+    ui: {
+      showDelegationPanel: true,
+      showWhitelistConfig: false,
+      showAnyoneConfig: false,
+      showMigrationBanner: false,
+      requirePinForExecution: true
+    },
+    description: "UCAN-enforced. Every block execution requires a valid delegation chain."
+  }
+};
+var LATEST_VERSION = "1.0.0";
+var tempUcanEnforcementDisabled = false;
+function isTempUcanEnforcementDisabled() {
+  return tempUcanEnforcementDisabled;
+}
+var MIGRATION_PATH = ["0.3", "1.0.0"];
+function getVersionPolicy(version) {
+  const policy = VERSION_MANIFEST[version] ?? VERSION_MANIFEST[LATEST_VERSION];
+  if (tempUcanEnforcementDisabled && policy.ucanRequired) {
+    return {
+      ...policy,
+      ucanRequired: false,
+      delegationRootRequired: false,
+      ui: { ...policy.ui, requirePinForExecution: false }
+    };
+  }
+  return policy;
+}
+function isVersionAtLeast(current, minimum) {
+  const currentIdx = MIGRATION_PATH.indexOf(current);
+  const minimumIdx = MIGRATION_PATH.indexOf(minimum);
+  const effectiveCurrent = currentIdx === -1 ? MIGRATION_PATH.length : currentIdx;
+  return effectiveCurrent >= minimumIdx;
+}
+
+// src/core/lib/flowEngine/reconcile.ts
+var activeReconciliations = /* @__PURE__ */ new WeakMap();
+function flattenBlocks(blocks) {
+  const flattened = [];
+  const visit = (block) => {
+    flattened.push(block);
+    if (Array.isArray(block?.children)) block.children.forEach(visit);
+  };
+  blocks.forEach(visit);
+  return flattened;
+}
+function reconcilePendingInvocations(editor, runId) {
+  const yDoc = editor._yDoc;
+  if (!yDoc) return;
+  const sessionRunId = resolveRunIdForExecution(yDoc, runId);
+  let activeRuns = activeReconciliations.get(yDoc);
+  if (!activeRuns) {
+    activeRuns = /* @__PURE__ */ new Set();
+    activeReconciliations.set(yDoc, activeRuns);
+  }
+  if (activeRuns.has(sessionRunId)) return;
+  activeRuns.add(sessionRunId);
+  try {
+    _reconcilePendingInvocationsInner(editor, yDoc, sessionRunId);
+  } finally {
+    activeRuns.delete(sessionRunId);
+  }
+}
+function _reconcilePendingInvocationsInner(editor, yDoc, runId) {
+  const blocks = flattenBlocks(editor.document || []);
+  if (blocks.length === 0) return;
+  const listenersBySource = /* @__PURE__ */ new Map();
+  const barrierListenersBySource = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const trigger = parseTrigger(block);
+    if (!trigger) continue;
+    if (trigger.type === "block.event") {
+      if (!trigger.sourceBlockId || !trigger.eventName) continue;
+      const key = `${trigger.sourceBlockId}::${trigger.eventName}`;
+      if (!listenersBySource.has(key)) listenersBySource.set(key, []);
+      listenersBySource.get(key).push({ block, trigger });
+    } else if (trigger.type === "block.event.all" && trigger.sources) {
+      for (const source of trigger.sources) {
+        if (!source.sourceBlockId || !source.eventName) continue;
+        const key = `${source.sourceBlockId}::${source.eventName}`;
+        if (!barrierListenersBySource.has(key)) barrierListenersBySource.set(key, []);
+        barrierListenersBySource.get(key).push({ block, trigger, source });
+      }
+    }
+  }
+  if (listenersBySource.size === 0 && barrierListenersBySource.size === 0) return;
+  const now = Date.now();
+  sweepExpiredPendingInvocations(yDoc, now, runId);
+  const consumedByListener = /* @__PURE__ */ new Map();
+  const isConsumed = (listenerBlockId, pendingId) => {
+    let consumed = consumedByListener.get(listenerBlockId);
+    if (!consumed) {
+      consumed = readConsumedPendingInvocationIds(yDoc, listenerBlockId, runId);
+      consumedByListener.set(listenerBlockId, consumed);
+    }
+    return consumed.has(pendingId);
+  };
+  const schemaVersionRaw = yDoc.getMap("root").get("schema_version");
+  const ucanRequired = typeof schemaVersionRaw === "string" ? !!getVersionPolicy(schemaVersionRaw)?.ucanRequired : false;
+  const invocationsMap = yDoc.getMap("invocations");
+  const getNodeOutput2 = (nodeId) => {
+    const out = readActionState(yDoc, runId, nodeId).output;
+    return out && typeof out === "object" && !Array.isArray(out) ? out : void 0;
+  };
+  for (const block of blocks) {
+    const sourceBlockId = block?.id;
+    if (!sourceBlockId) continue;
+    let hasAnyListener = false;
+    for (const key of listenersBySource.keys()) {
+      if (key.startsWith(`${sourceBlockId}::`)) {
+        hasAnyListener = true;
+        break;
+      }
+    }
+    for (const key of barrierListenersBySource.keys()) {
+      if (key.startsWith(`${sourceBlockId}::`)) {
+        hasAnyListener = true;
+        break;
+      }
+    }
+    if (!hasAnyListener) continue;
+    const records = readRunRecords(yDoc, sourceBlockId, runId);
+    for (const record of records) {
+      if (!isTrustedRunRecord(record, ucanRequired, invocationsMap)) continue;
+      processRunRecord(yDoc, runId, sourceBlockId, record, listenersBySource, getNodeOutput2, isConsumed, now);
+      processBarrierRunRecord(yDoc, runId, sourceBlockId, record, barrierListenersBySource, getNodeOutput2, isConsumed, now);
+    }
+  }
+}
+function dispatchFlowStartTriggers(params) {
+  const blocks = flattenBlocks(params.blocks);
+  const sourceRunId = params.sourceEventId || `${params.runId}:run.started`;
+  const emittedAt = new Date(params.startedAt).toISOString();
+  const getNodeOutput2 = (nodeId) => {
+    const output = readActionState(params.yDoc, params.runId, nodeId).output;
+    return output && typeof output === "object" && !Array.isArray(output) ? output : void 0;
+  };
+  let queued = 0;
+  for (const block of blocks) {
+    const trigger = parseTrigger(block);
+    if (trigger?.type !== "flow.start" || !block?.id) continue;
+    const id = computePendingInvocationId({
+      sourceBlockId: "__flow_start__",
+      sourceRunId,
+      listenerBlockId: block.id,
+      eventName: "flow.start",
+      eventIndex: 0,
+      sessionRunId: params.runId
+    });
+    const inputs = parseInputs(block);
+    const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
+    const invocation = {
+      id,
+      triggeringBlockId: "__flow_start__",
+      sourceRunId,
+      sessionRunId: params.runId,
+      eventName: "flow.start",
+      eventIndex: 0,
+      payload: {
+        runId: params.runId,
+        startedAt: params.startedAt,
+        ...params.sourceEventId ? { eventId: params.sourceEventId } : {}
+      },
+      refSnapshots,
+      assigneeDid: resolveAssignee(block) || "unassigned",
+      emittedAt,
+      expiresAt: computeExpiry(block, emittedAt)
+    };
+    if (queuePendingInvocation(params.yDoc, block.id, invocation, params.runId)) {
+      queued += 1;
+    }
+    writeActionState(params.yDoc, params.runId, block.id, {
+      pendingPayload: { ...invocation.payload, ...refSnapshots }
+    });
+  }
+  return queued;
+}
+function isTrustedRunRecord(record, ucanRequired, invocationsMap) {
+  if (!ucanRequired) return true;
+  if (!record.invocationCid) return false;
+  return invocationsMap.get(record.invocationCid) !== void 0;
+}
+function processRunRecord(yDoc, runId, sourceBlockId, record, listenersBySource, getNodeOutput2, isConsumed, now) {
+  if (!Array.isArray(record.events)) return;
+  record.events.forEach((event, eventIndex) => {
+    if (!event?.name) return;
+    const key = `${sourceBlockId}::${event.name}`;
+    const listeners = listenersBySource.get(key);
+    if (!listeners || listeners.length === 0) return;
+    for (const { block: listenerBlock } of listeners) {
+      const listenerBlockId = listenerBlock.id;
+      if (!listenerBlockId) continue;
+      const id = computePendingInvocationId({
+        sourceBlockId,
+        sourceRunId: record.runId,
+        listenerBlockId,
+        eventName: event.name,
+        eventIndex,
+        sessionRunId: runId
+      });
+      if (isConsumed(listenerBlockId, id)) continue;
+      const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
+      const inputs = parseInputs(listenerBlock);
+      const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
+      const expiresAt = computeExpiry(listenerBlock, record.completedAt);
+      if (expiresAt && Date.parse(expiresAt) < now) continue;
+      const invocation = {
+        id,
+        triggeringBlockId: sourceBlockId,
+        sourceRunId: record.runId,
+        sessionRunId: runId,
+        eventName: event.name,
+        eventIndex,
+        payload: event.payload,
+        refSnapshots,
+        assigneeDid,
+        emittedAt: record.completedAt,
+        expiresAt
+      };
+      queuePendingInvocation(yDoc, listenerBlockId, invocation, runId);
+      writeActionState(yDoc, runId, listenerBlockId, {
+        pendingPayload: { ...event.payload, ...refSnapshots }
+      });
+    }
+  });
+}
+function processBarrierRunRecord(yDoc, runId, sourceBlockId, record, barrierListenersBySource, getNodeOutput2, isConsumed, now) {
+  if (!Array.isArray(record.events)) return;
+  for (const event of record.events) {
+    if (!event?.name) continue;
+    const key = `${sourceBlockId}::${event.name}`;
+    const listeners = barrierListenersBySource.get(key);
+    if (!listeners || listeners.length === 0) continue;
+    for (const { block: listenerBlock, trigger, source } of listeners) {
+      const listenerBlockId = listenerBlock.id;
+      if (!listenerBlockId) continue;
+      const entry = {
+        sourceBlockId,
+        eventName: event.name,
+        alias: source.alias,
+        runId: record.runId,
+        sessionRunId: runId,
+        payload: event.payload || {},
+        emittedAt: record.completedAt
+      };
+      recordBarrierEvent(yDoc, listenerBlockId, entry, runId);
+      const existing = readActionState(yDoc, runId, listenerBlockId).pendingPayload || {};
+      writeActionState(yDoc, runId, listenerBlockId, {
+        pendingPayload: { ...existing, ...event.payload || {} }
+      });
+      const allSources = trigger.sources || [];
+      const currentState = readBarrierState(yDoc, listenerBlockId, runId);
+      const requiredSources = allSources.filter((s) => s.optional !== true);
+      const gatingSources = requiredSources.length > 0 ? requiredSources : allSources;
+      const allFired = gatingSources.length > 0 && gatingSources.every((s) => currentState.some((e) => e.sourceBlockId === s.sourceBlockId && e.eventName === s.eventName));
+      if (!allFired) continue;
+      const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
+      const id = computeBarrierInvocationId(currentState, listenerBlockId, runId);
+      if (isConsumed(listenerBlockId, id)) continue;
+      const mergedPayload = mergeBarrierPayloads(currentState);
+      const inputs = parseInputs(listenerBlock);
+      const refSnapshots = snapshotInputRefs(inputs, getNodeOutput2);
+      const expiresAt = computeExpiry(listenerBlock, record.completedAt);
+      if (expiresAt && Date.parse(expiresAt) < now) continue;
+      const invocation = {
+        id,
+        triggeringBlockId: sourceBlockId,
+        sourceRunId: record.runId,
+        sessionRunId: runId,
+        eventName: `barrier:${allSources.map((s) => s.alias).join("+")}`,
+        eventIndex: 0,
+        payload: mergedPayload,
+        refSnapshots,
+        assigneeDid,
+        emittedAt: record.completedAt,
+        expiresAt
+      };
+      queuePendingInvocation(yDoc, listenerBlockId, invocation, runId);
+      clearBarrierState(yDoc, listenerBlockId, runId);
+      writeActionState(yDoc, runId, listenerBlockId, {
+        pendingPayload: { ...mergedPayload, ...refSnapshots }
+      });
+    }
+  }
+}
+function parseTrigger(block) {
+  const raw = block?.props?.trigger;
+  if (!raw || typeof raw !== "string") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      return parsed;
+    }
+  } catch {
+    warnOnce(`trigger-parse:${block?.id}`, `[flow-config] block ${block?.id}: props.trigger is not valid JSON; trigger ignored`);
+  }
+  return null;
+}
+function parseInputs(block) {
+  const raw = block?.props?.inputs;
+  if (!raw || typeof raw !== "string") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+    warnOnce(`inputs-parse:${block?.id}`, `[flow-config] block ${block?.id}: props.inputs is not valid JSON; treated as empty`);
+  }
+  return {};
+}
+function resolveAssignee(block) {
+  const raw = block?.props?.assignment;
+  if (!raw) return void 0;
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const did = parsed?.assignedActor?.did;
+    return typeof did === "string" && did.length > 0 ? did : void 0;
+  } catch {
+    warnOnce(`assignment-parse:${block?.id}`, `[flow-config] block ${block?.id}: props.assignment is not valid JSON; assignee unresolved`);
+    return void 0;
+  }
+}
+function computeExpiry(block, emittedAt) {
+  const ttlAbsolute = block?.props?.ttlAbsoluteDueDate;
+  if (typeof ttlAbsolute === "string" && ttlAbsolute) {
+    return ttlAbsolute;
+  }
+  const ttlFromEnablement = block?.props?.ttlFromEnablement;
+  if (typeof ttlFromEnablement === "string" && ttlFromEnablement) {
+    const ms = parseIsoDurationToMs(ttlFromEnablement);
+    if (ms != null) {
+      return new Date(new Date(emittedAt).getTime() + ms).toISOString();
+    }
+  }
+  return new Date(new Date(emittedAt).getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString();
+}
+function parseIsoDurationToMs(duration) {
+  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(duration);
+  if (!match) return null;
+  const [, d, h, m, s] = match;
+  let ms = 0;
+  if (d) ms += parseInt(d, 10) * 24 * 60 * 60 * 1e3;
+  if (h) ms += parseInt(h, 10) * 60 * 60 * 1e3;
+  if (m) ms += parseInt(m, 10) * 60 * 1e3;
+  if (s) ms += parseInt(s, 10) * 1e3;
+  return ms;
+}
+function getActionForBlock(block) {
+  const actionType = block?.props?.actionType;
+  if (typeof actionType !== "string") return void 0;
+  return getAction(actionType);
+}
+
+// src/core/lib/flowEngine/emitEvents.ts
+function writeRunRecordAndReconcile(editor, blockId, output, events, actorDid, detailsPatch = {}, runId) {
+  const yDoc = editor._yDoc;
+  if (!yDoc) return;
+  if (events.length === 0) return;
+  const executionId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const details = {
+    runId: executionId,
+    sessionRunId: runId || resolveActiveRunId(yDoc),
+    output,
+    events,
+    startedAt: now,
+    completedAt: now,
+    actorDid,
+    ...detailsPatch
+  };
+  appendRunRecord(yDoc, blockId, details, actorDid);
+  reconcilePendingInvocations(editor, details.sessionRunId);
+}
+
+// src/core/lib/flowEngine/runtime.ts
+var XERO_WORK_ITEMS_MAP_NAME = "xeroWorkItems";
+var XERO_WORK_TERMINAL_MAP_NAME = "xeroWorkItemsTerminal";
+var XERO_CONNECTION_MAP_NAME = "xeroConnection";
+var ensureStateObject = (value) => {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return { ...value };
+};
+var createYMapManager = (map) => {
+  return {
+    get: (nodeId) => {
+      const stored = map.get(nodeId);
+      return ensureStateObject(stored);
+    },
+    update: (nodeId, updates) => {
+      const current = ensureStateObject(map.get(nodeId));
+      map.set(nodeId, { ...current, ...updates });
+    }
+  };
+};
+var createMemoryManager = () => {
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    get: (nodeId) => ensureStateObject(memory.get(nodeId)),
+    update: (nodeId, updates) => {
+      const current = ensureStateObject(memory.get(nodeId));
+      memory.set(nodeId, { ...current, ...updates });
+    }
+  };
+};
+function resolveEditorYDoc(editor) {
+  const direct = editor?._yDoc;
+  if (direct && typeof direct.getMap === "function") return direct;
+  const viaRuntime = editor?._yRuntime?.doc;
+  return viaRuntime && typeof viaRuntime.getMap === "function" ? viaRuntime : void 0;
+}
+var createRuntimeStateManager = (editor, runId) => {
+  const yDoc = resolveEditorYDoc(editor);
+  if (yDoc) {
+    return createRunScopedRuntimeManager(yDoc, resolveRunIdForExecution(yDoc, runId));
+  }
+  if (editor?._yRuntime) {
+    return createYMapManager(editor._yRuntime);
+  }
+  return createMemoryManager();
+};
+var createYDocRuntimeManager = (yDoc, runId) => {
+  return createRunScopedRuntimeManager(yDoc, resolveRunIdForExecution(yDoc, runId));
+};
+function clearRuntimeForTemplateClone(yDoc) {
+  const runtime = yDoc.getMap("runtime");
+  const runs = yDoc.getMap(RUNS_MAP_KEY);
+  const runsTerminalPending = yDoc.getMap(RUNS_TERMINAL_PENDING_MAP_KEY);
+  const runsTerminal = yDoc.getMap(RUNS_TERMINAL_MAP_KEY);
+  const invocations = yDoc.getMap("invocations");
+  const pendingInvocations = yDoc.getMap("pendingInvocations");
+  const barrierState = yDoc.getMap(BARRIER_STATE_MAP_KEY);
+  const dmNotificationState = yDoc.getMap(DM_NOTIFICATIONS_MAP_KEY);
+  const agentOutbox = yDoc.getMap("agentOutbox");
+  const agentLeases = yDoc.getMap("agentLeases");
+  const auditTrail = yDoc.getMap("auditTrail");
+  const xeroWorkItems = yDoc.getMap(XERO_WORK_ITEMS_MAP_NAME);
+  const xeroWorkTerminal = yDoc.getMap(XERO_WORK_TERMINAL_MAP_NAME);
+  const xeroConnection = yDoc.getMap(XERO_CONNECTION_MAP_NAME);
+  const connectionBindings = yDoc.getMap(FLOW_CONNECTION_BINDINGS_MAP_KEY);
+  const designPodState = yDoc.getMap("designPodState");
+  const root = yDoc.getMap("root");
+  yDoc.transact(() => {
+    runtime.forEach((_, key) => runtime.delete(key));
+    runs.forEach((_, key) => runs.delete(key));
+    runsTerminalPending.forEach((_, key) => runsTerminalPending.delete(key));
+    runsTerminal.forEach((_, key) => runsTerminal.delete(key));
+    invocations.forEach((_, key) => invocations.delete(key));
+    pendingInvocations.forEach((_, key) => pendingInvocations.delete(key));
+    barrierState.forEach((_, key) => barrierState.delete(key));
+    dmNotificationState.forEach((_, key) => dmNotificationState.delete(key));
+    agentOutbox.forEach((_, key) => agentOutbox.delete(key));
+    agentLeases.forEach((_, key) => agentLeases.delete(key));
+    auditTrail.forEach((_, key) => auditTrail.delete(key));
+    xeroWorkItems.forEach((_, key) => xeroWorkItems.delete(key));
+    xeroWorkTerminal.forEach((_, key) => xeroWorkTerminal.delete(key));
+    xeroConnection.forEach((_, key) => xeroConnection.delete(key));
+    connectionBindings.forEach((_, key) => connectionBindings.delete(key));
+    designPodState.forEach((_, key) => designPodState.delete(key));
+    root.delete("activeRunId");
+  });
+}
+
+// src/core/lib/flowEngine/conditions.ts
+var OPERATOR_INVERSIONS = {
+  equals: "not_equals",
+  not_equals: "equals",
+  contains: "not_contains",
+  not_contains: "contains",
+  is_empty: "is_not_empty",
+  is_not_empty: "is_empty",
+  greater_than: "less_than",
+  less_than: "greater_than"
+};
+var ACTION_INVERSIONS = {
+  disable: "enable",
+  hide: "show",
+  enable: null,
+  show: null
+};
+function normalizeCondition(condition) {
+  const canonicalAction = ACTION_INVERSIONS[condition.effect.action];
+  if (canonicalAction === null) return condition;
+  let value = condition.rule.value;
+  if ((condition.rule.operator === "equals" || condition.rule.operator === "not_equals") && typeof value === "boolean") {
+    value = !value;
+  }
+  return {
+    ...condition,
+    rule: {
+      ...condition.rule,
+      operator: OPERATOR_INVERSIONS[condition.rule.operator],
+      value
+    },
+    effect: { ...condition.effect, action: canonicalAction }
+  };
+}
+function normalizeConditions(conditions) {
+  return conditions.map(normalizeCondition);
+}
+function parseConditionConfig(value) {
+  if (!value) return { enabled: false, mode: "all_must_pass", conditions: [] };
+  try {
+    const parsed = typeof value === "string" ? JSON.parse(value) : value;
+    if (!parsed || typeof parsed !== "object") {
+      return { enabled: false, mode: "all_must_pass", conditions: [] };
+    }
+    const candidate = parsed;
+    return {
+      enabled: candidate.enabled === true,
+      mode: candidate.mode === "any_can_pass" ? "any_can_pass" : "all_must_pass",
+      conditions: Array.isArray(candidate.conditions) ? candidate.conditions : []
+    };
+  } catch {
+    return { enabled: false, mode: "all_must_pass", conditions: [] };
+  }
+}
+var InvalidConditionConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidConditionConfigError";
+  }
+};
+function parseConditionConfigStrict(value) {
+  if (value == null || value === "") {
+    return { enabled: false, mode: "all_must_pass", conditions: [] };
+  }
+  let parsed;
+  try {
+    parsed = typeof value === "string" ? JSON.parse(value) : value;
+  } catch {
+    throw new InvalidConditionConfigError("Block conditions are not valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new InvalidConditionConfigError("Block conditions must be an object.");
+  }
+  const candidate = parsed;
+  if (candidate.enabled !== true) {
+    return { enabled: false, mode: "all_must_pass", conditions: [] };
+  }
+  if (candidate.mode !== "all_must_pass" && candidate.mode !== "any_can_pass") {
+    throw new InvalidConditionConfigError("Enabled block conditions require a valid mode.");
+  }
+  if (!Array.isArray(candidate.conditions)) {
+    throw new InvalidConditionConfigError("Enabled block conditions require a conditions array.");
+  }
+  for (const condition of candidate.conditions) {
+    if (!condition || typeof condition !== "object" || typeof condition.sourceBlockId !== "string" || !condition.rule || !condition.effect) {
+      throw new InvalidConditionConfigError("Block conditions contain an invalid condition.");
+    }
+  }
+  return {
+    enabled: true,
+    mode: candidate.mode,
+    conditions: candidate.conditions
+  };
+}
+function flattenBlocks2(blocks) {
+  const flattened = [];
+  const visit = (block) => {
+    flattened.push(block);
+    const children = block?.children;
+    if (Array.isArray(children)) children.forEach(visit);
+  };
+  blocks.forEach(visit);
+  return flattened;
+}
+function resolveRuntimeValue(runtime, property) {
+  if (!runtime) return void 0;
+  if (property.startsWith("output.")) {
+    return getNestedValue(runtime.output, property.slice("output.".length));
+  }
+  const direct = getNestedValue(runtime, property);
+  if (direct !== void 0) return direct;
+  return getNestedValue(runtime.output, property);
+}
+function resolveConditionSourceValue(condition, sourceBlock, options = {}) {
+  const runtimeValue = resolveRuntimeValue(options.getRuntimeState?.(condition.sourceBlockId), condition.rule.property);
+  if (runtimeValue !== void 0 || options.allowPropsFallback === false) return runtimeValue;
+  const props = sourceBlock?.props;
+  return getNestedValue(props, condition.rule.property);
+}
+function compareConditionValue(sourceValue, operator, expected) {
+  switch (operator) {
+    case "equals":
+      return sourceValue === expected;
+    case "not_equals":
+      return sourceValue !== expected;
+    case "greater_than":
+      return typeof sourceValue === "number" && typeof expected === "number" && sourceValue > expected;
+    case "less_than":
+      return typeof sourceValue === "number" && typeof expected === "number" && sourceValue < expected;
+    case "contains":
+      return typeof sourceValue === "string" && typeof expected === "string" && sourceValue.toLowerCase().includes(expected.toLowerCase());
+    case "not_contains":
+      return typeof sourceValue === "string" && typeof expected === "string" && !sourceValue.toLowerCase().includes(expected.toLowerCase());
+    case "is_empty":
+      return sourceValue === "" || sourceValue === null || sourceValue === void 0;
+    case "is_not_empty":
+      return sourceValue !== "" && sourceValue !== null && sourceValue !== void 0;
+  }
+}
+function evaluateCondition(condition, sourceBlock, options = {}) {
+  if (!sourceBlock) {
+    return {
+      passes: false,
+      message: `Required block not found: ${condition.name || condition.sourceBlockType}`
+    };
+  }
+  const passes = compareConditionValue(resolveConditionSourceValue(condition, sourceBlock, options), condition.rule.operator, condition.rule.value);
+  return { passes, message: passes ? void 0 : condition.effect.message };
+}
+function evaluateBlockConditions(conditionConfig, editorDocument, options = {}) {
+  if (!conditionConfig.enabled || conditionConfig.conditions.length === 0) return { actions: [] };
+  const blocks = flattenBlocks2(editorDocument);
+  const evaluations = normalizeConditions(conditionConfig.conditions).map((condition) => {
+    const sourceBlock = blocks.find((block) => {
+      const candidate = block;
+      return candidate.id === condition.sourceBlockId && candidate.type === condition.sourceBlockType;
+    });
+    return { condition, result: evaluateCondition(condition, sourceBlock, options) };
+  });
+  const passed = conditionConfig.mode === "all_must_pass" ? evaluations.every(({ result }) => result.passes) ? evaluations : [] : evaluations.filter(({ result }) => result.passes);
+  return {
+    actions: passed.map(({ condition }) => ({
+      action: condition.effect.action,
+      message: condition.effect.message,
+      conditionName: condition.name
+    }))
+  };
+}
+function evaluateBlockConditionsForRun(conditionConfig, editorDocument, yDoc, sessionRunId) {
+  return evaluateBlockConditions(conditionConfig, editorDocument, {
+    getRuntimeState: (blockId) => readActionState(yDoc, sessionRunId, blockId),
+    allowPropsFallback: usesLegacyRuntimeCompatibility(yDoc)
+  });
+}
+function evaluateBlockExecutionEligibilityForRun(conditionConfig, editorDocument, yDoc, sessionRunId) {
+  const normalized = normalizeConditions(conditionConfig.conditions);
+  const result = evaluateBlockConditionsForRun(conditionConfig, editorDocument, yDoc, sessionRunId);
+  const requiresEnable = normalized.some((condition) => condition.effect.action === "enable");
+  const requiresShow = normalized.some((condition) => condition.effect.action === "show");
+  const enabled = !conditionConfig.enabled || !requiresEnable || result.actions.some((action) => action.action === "enable");
+  const visible = !conditionConfig.enabled || !requiresShow || result.actions.some((action) => action.action === "show");
+  const failedMessage = normalized.map((condition) => condition.effect.message).find((message) => !!message);
+  return {
+    eligible: enabled && visible,
+    enabled,
+    visible,
+    ...enabled && visible ? {} : { message: failedMessage || "Block conditions are not satisfied." },
+    result
+  };
+}
+
+// src/core/lib/flowEngine/utils.ts
+var buildAuthzFromProps = (props) => {
+  const linkedClaimCollectionId = typeof props.linkedClaimCollectionId === "string" ? props.linkedClaimCollectionId.trim() : "";
+  const authz = {};
+  if (linkedClaimCollectionId) {
+    authz.linkedClaim = { collectionId: linkedClaimCollectionId };
+  }
+  return authz;
+};
+var buildFlowNodeFromBlock = (block) => {
+  const base = {
+    id: block.id,
+    type: block.type,
+    props: block.props || {}
+  };
+  const authz = buildAuthzFromProps(block.props || {});
+  return {
+    ...base,
+    ...authz
+  };
+};
+
+// src/core/lib/flowEngine/proof.ts
+var PROOF_MISSING_CODE = "PROOF_MISSING";
+function getOutputValue(output, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc && typeof acc === "object") return acc[key];
+    return void 0;
+  }, output);
+}
+function isProofValue(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "number") return !Number.isNaN(value);
+  return !!value;
+}
+function validateActionProof(action, output) {
+  const proof = action.proof;
+  if (proof === "none") return { valid: true };
+  if (proof === void 0) {
+    if (action.sideEffect) {
+      return {
+        valid: false,
+        reason: `Action '${action.type}' has a side effect but declares no proof of execution. Declare proof (or 'none') on its ActionDefinition.`
+      };
+    }
+    return { valid: true };
+  }
+  if ("validate" in proof) {
+    let valid = false;
+    try {
+      valid = proof.validate(output);
+    } catch {
+      valid = false;
+    }
+    return valid ? { valid: true } : { valid: false, reason: `Action '${action.type}' returned success but its proof validator rejected the output.` };
+  }
+  const satisfied = proof.fields.some((field) => isProofValue(getOutputValue(output, field)));
+  if (satisfied) return { valid: true };
+  return {
+    valid: false,
+    reason: `Action '${action.type}' returned success without proof. Expected at least one of [${proof.fields.join(", ")}] in the output. Check the handler logs.`
+  };
+}
+
+// src/core/lib/flowEngine/completion.ts
+function isActionDone(action, actionState, runContext) {
+  if (!action) return false;
+  return action.done.isDone(actionState, runContext);
+}
+function isActionTypeDone(actionType, actionState, runContext) {
+  return isActionDone(actionType ? getAction(actionType) : void 0, actionState, runContext);
+}
+async function reconcileCompletion(params) {
+  const action = getAction(params.actionType);
+  if (!action) throw new Error(`Unknown action type "${params.actionType}"`);
+  const previous = readActionState(params.yDoc, params.sessionRunId, params.blockId);
+  const ctx = {
+    runId: params.sessionRunId,
+    flowId: params.flowId,
+    flowUri: params.flowUri,
+    actorDid: params.actorDid,
+    nodeId: params.blockId,
+    services: params.services,
+    handlers: params.handlers,
+    now: params.now?.() ?? Date.now()
+  };
+  const check = action.done.check ? await action.done.check({ inputs: params.inputs, actionState: previous, ctx }) : {
+    done: isActionDone(action, previous, ctx),
+    source: "runtime-proof"
+  };
+  if (check.done === "unknown") {
+    return { transition: "unknown", check, previous, next: previous };
+  }
+  if (action.done.reopenable && previous.state !== "completed") {
+    return { transition: "unchanged", check, previous, next: previous };
+  }
+  if (check.done === true) {
+    if (isActionDone(action, previous, ctx)) {
+      return { transition: "unchanged", check, previous, next: previous };
+    }
+    const mergedOutput = {
+      ...previous.output || {},
+      ...check.output || {}
+    };
+    const proof = validateActionProof(action, mergedOutput);
+    const bounded = boundRunActionOutput(mergedOutput);
+    if (!proof.valid || bounded.exceeded) {
+      const { next: next2 } = writeActionState(params.yDoc, params.sessionRunId, params.blockId, {
+        state: "needs_verification",
+        output: bounded.output,
+        error: {
+          message: bounded.exceeded ? "External completion output exceeds the run-head size limit." : proof.reason || "External completion did not return the action proof.",
+          code: bounded.exceeded ? "RUN_OUTPUT_TOO_LARGE" : "COMPLETION_PROOF_MISSING",
+          at: ctx.now
+        },
+        reconciledAt: ctx.now,
+        completionSource: check.source
+      });
+      return {
+        transition: "needs_verification",
+        check,
+        previous,
+        next: next2
+      };
+    }
+    const { next } = writeActionState(params.yDoc, params.sessionRunId, params.blockId, {
+      state: "completed",
+      output: bounded.output,
+      error: void 0,
+      executedAt: previous.executedAt ?? ctx.now,
+      reconciledAt: ctx.now,
+      completionSource: check.source
+    });
+    return { transition: "adopted", check, previous, next };
+  }
+  if (previous.state === "completed" && action.done.reopenable) {
+    if (!check.output) {
+      return { transition: "unchanged", check, previous, next: previous };
+    }
+    const wasDone = isActionDone(action, previous, ctx);
+    const bounded = boundRunActionOutput({
+      ...previous.output || {},
+      ...check.output
+    });
+    if (bounded.exceeded) {
+      return { transition: "unchanged", check, previous, next: previous };
+    }
+    const { next } = writeActionState(params.yDoc, params.sessionRunId, params.blockId, {
+      output: bounded.output,
+      reconciledAt: ctx.now,
+      completionSource: check.source
+    });
+    return { transition: wasDone ? "reopened" : "unchanged", check, previous, next };
+  }
+  if (previous.state === "completed") {
+    const { next } = writeActionState(params.yDoc, params.sessionRunId, params.blockId, {
+      state: "needs_verification",
+      error: {
+        message: check.reason || "External completion check contradicts the completed run state.",
+        code: "COMPLETION_MISMATCH",
+        at: ctx.now
+      },
+      reconciledAt: ctx.now,
+      completionSource: check.source
+    });
+    return { transition: "needs_verification", check, previous, next };
+  }
+  return { transition: "unchanged", check, previous, next: previous };
+}
+async function reconcileCheckableCompletions(params) {
+  const results = {};
+  for (const [blockId, actionType] of Object.entries(params.actionTypes)) {
+    const action = getAction(actionType);
+    if (!action?.done.check) continue;
+    try {
+      results[blockId] = await reconcileCompletion({
+        yDoc: params.yDoc,
+        sessionRunId: params.sessionRunId,
+        blockId,
+        actionType,
+        inputs: params.inputsFor(blockId, actionType),
+        flowId: params.flowId,
+        flowUri: params.flowUri,
+        actorDid: params.actorDid,
+        services: params.services,
+        handlers: params.handlers,
+        now: params.now
+      });
+    } catch (error) {
+      const previous = readActionState(params.yDoc, params.sessionRunId, blockId);
+      results[blockId] = {
+        transition: "unknown",
+        check: { done: "unknown", source: "reconcile", reason: error instanceof Error ? error.message : String(error) },
+        previous,
+        next: previous
+      };
+    }
+  }
+  return results;
+}
+
+// src/core/lib/flowAgent/store.ts
+import * as Y2 from "yjs";
+
+// src/core/lib/flowAgent/utils.ts
+function stableStringify(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",")}}`;
+}
+function fnv1a322(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function createIntentHash(intent) {
+  return fnv1a322(stableStringify(intent));
+}
+function parseJsonProp(value, fallback) {
+  if (value == null || value === "") return fallback;
+  if (typeof value === "object") return value;
+  if (typeof value !== "string") return fallback;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed;
+  } catch {
+    return fallback;
+  }
+}
+function getBlockActionType(block) {
+  const props = block?.props;
+  const actionType = props?.actionType;
+  return typeof actionType === "string" && actionType.length > 0 ? actionType : void 0;
+}
+function getBlockTitle(block) {
+  const props = block?.props;
+  const title = props?.title;
+  return typeof title === "string" && title.length > 0 ? title : void 0;
+}
+function getBlockType(block) {
+  const type = block?.type;
+  return typeof type === "string" && type.length > 0 ? type : "block";
+}
+function getBlockProps(block) {
+  return block?.props || {};
+}
+function getBlockId(block) {
+  const id = block?.id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function getAssigneeDid(block) {
+  const props = getBlockProps(block);
+  const assignment = parseJsonProp(props.assignment, {});
+  const did = assignment?.assignedActor?.did;
+  return typeof did === "string" && did.length > 0 ? did : void 0;
+}
+function getDueAt(block) {
+  const props = getBlockProps(block);
+  const ttlAbsoluteDueDate = props.ttlAbsoluteDueDate;
+  if (typeof ttlAbsoluteDueDate !== "string" || ttlAbsoluteDueDate.length === 0) return void 0;
+  const parsed = new Date(ttlAbsoluteDueDate).getTime();
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function capabilityForCommand(can, flowUri, nodeId) {
+  return {
+    can,
+    with: `${flowUri}:${nodeId}`
+  };
+}
+
+// src/core/lib/flowAgent/store.ts
+var FLOW_AGENT_OUTBOX_KEY = "agentOutbox";
+var FLOW_AGENT_LEASES_KEY = "agentLeases";
+var FLOW_AGENT_AUDIT_SCOPE = "__flow_agent__";
+function readExistingMap(yDoc, key) {
+  return getExistingYMap(yDoc, key);
+}
+function getFlowAgentMaps(yDoc) {
+  return {
+    outbox: yDoc.getMap(FLOW_AGENT_OUTBOX_KEY),
+    leases: yDoc.getMap(FLOW_AGENT_LEASES_KEY)
+  };
+}
+function computeAgentCommandId(params) {
+  const intentHash = createIntentHash(params);
+  return `${params.flowId}:${params.nodeId}:${intentHash}`;
+}
+function queueAgentCommand(yDoc, command) {
+  const { outbox } = getFlowAgentMaps(yDoc);
+  const existing = outbox.get(command.id);
+  if (existing) {
+    const retryFailedAssignment = existing.type === "assign_actor" && existing.status === "failed";
+    const retryFailedDiagnosis = existing.type === "diagnose_blocker" && existing.status === "failed";
+    const retryUnprovenDiagnosis = existing.type === "diagnose_blocker" && existing.status === "confirmed" && typeof existing.payload.delegatedInvocationId !== "string";
+    if (retryFailedAssignment || retryFailedDiagnosis || retryUnprovenDiagnosis) {
+      const retried = {
+        ...existing,
+        status: "queued",
+        error: void 0,
+        lease: void 0,
+        reason: command.reason,
+        payload: command.payload,
+        capability: command.capability,
+        actorDid: command.actorDid,
+        updatedAt: command.updatedAt
+      };
+      outbox.set(command.id, retried);
+      try {
+        appendAgentLedgerEvent(yDoc, {
+          type: "agent.command",
+          flowId: retried.flowId,
+          sessionRunId: retried.sessionRunId,
+          nodeId: retried.nodeId,
+          commandId: retried.id,
+          actorDid: retried.actorDid,
+          timestamp: retried.updatedAt,
+          details: {
+            commandType: retried.type,
+            status: retried.status,
+            idempotencyKey: retried.idempotencyKey,
+            reason: retried.reason,
+            retry: true,
+            retryCause: retryFailedDiagnosis ? "diagnosis_failed" : retryUnprovenDiagnosis ? "missing_delegated_invocation" : "assignment_failed"
+          }
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to append flow-agent ledger event";
+        if (!message.includes("Unexpected content type") && !message.includes("already been defined with a different constructor")) {
+          throw error;
+        }
+      }
+      return { command: retried, created: true };
+    }
+    return { command: existing, created: false };
+  }
+  outbox.set(command.id, command);
+  try {
+    appendAgentLedgerEvent(yDoc, {
+      type: "agent.command",
+      flowId: command.flowId,
+      sessionRunId: command.sessionRunId,
+      nodeId: command.nodeId,
+      commandId: command.id,
+      actorDid: command.actorDid,
+      timestamp: command.createdAt,
+      details: {
+        commandType: command.type,
+        status: command.status,
+        idempotencyKey: command.idempotencyKey,
+        reason: command.reason
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to append flow-agent ledger event";
+    if (!message.includes("Unexpected content type") && !message.includes("already been defined with a different constructor")) {
+      throw error;
+    }
+  }
+  return { command, created: true };
+}
+function belongsToSessionRun(value, sessionRunId) {
+  return !sessionRunId || isRecordInRun(value.sessionRunId, sessionRunId);
+}
+function readAgentCommands(yDoc, sessionRunId) {
+  const outbox = readExistingMap(yDoc, FLOW_AGENT_OUTBOX_KEY);
+  if (!outbox) return [];
+  const commands = [];
+  outbox.forEach((command) => {
+    if (belongsToSessionRun(command, sessionRunId)) {
+      commands.push({
+        ...command,
+        sessionRunId: resolveRecordRunId(command.sessionRunId, sessionRunId)
+      });
+    }
+  });
+  commands.sort(
+    (a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0) || (a.id ?? a.commandId ?? "").localeCompare(b.id ?? b.commandId ?? "")
+  );
+  return commands;
+}
+function readQueuedAgentCommands(yDoc, sessionRunId) {
+  return readAgentCommands(yDoc, sessionRunId).filter((command) => command.status === "queued" || command.status === "leased" || command.status === "running");
+}
+function readFlowAgentLeases(yDoc, sessionRunId) {
+  const leases = readExistingMap(yDoc, FLOW_AGENT_LEASES_KEY);
+  if (!leases) return [];
+  const results = [];
+  leases.forEach((lease) => {
+    if (belongsToSessionRun(lease, sessionRunId)) {
+      results.push({
+        ...lease,
+        sessionRunId: resolveRecordRunId(lease.sessionRunId, sessionRunId)
+      });
+    }
+  });
+  results.sort((a, b) => (a.acquiredAt ?? 0) - (b.acquiredAt ?? 0) || (a.id ?? a.commandId ?? "").localeCompare(b.id ?? b.commandId ?? ""));
+  return results;
+}
+function updateAgentCommand(yDoc, commandId, patch) {
+  const { outbox } = getFlowAgentMaps(yDoc);
+  const current = outbox.get(commandId);
+  if (!current) return null;
+  const next = { ...current, ...patch };
+  outbox.set(commandId, next);
+  return next;
+}
+function appendAgentLedgerEvent(yDoc, event) {
+  const auditMap = yDoc.getMap("auditTrail");
+  let arr = auditMap.get(FLOW_AGENT_AUDIT_SCOPE);
+  if (!arr) {
+    arr = new Y2.Array();
+    auditMap.set(FLOW_AGENT_AUDIT_SCOPE, arr);
+  }
+  const fullEvent = {
+    id: event.id || `${event.type}:${event.commandId || event.nodeId || "flow"}:${createIntentHash(event.details)}:${event.timestamp}`,
+    type: event.type,
+    flowId: event.flowId,
+    sessionRunId: event.sessionRunId,
+    actorDid: event.actorDid,
+    timestamp: event.timestamp,
+    details: JSON.parse(stableStringify(event.details))
+  };
+  if (event.nodeId) fullEvent.nodeId = event.nodeId;
+  if (event.commandId) fullEvent.commandId = event.commandId;
+  arr.push([
+    {
+      id: fullEvent.id,
+      type: fullEvent.type,
+      details: fullEvent,
+      meta: {
+        timestamp: new Date(fullEvent.timestamp).toISOString(),
+        userId: fullEvent.actorDid,
+        editable: false
+      }
+    }
+  ]);
+  return fullEvent;
+}
+function readAgentLedgerEvents(yDoc, eventType, sessionRunId) {
+  const auditMap = readExistingMap(yDoc, "auditTrail");
+  if (!auditMap) return [];
+  const arr = auditMap.get(FLOW_AGENT_AUDIT_SCOPE);
+  if (!arr) return [];
+  const events = [];
+  arr.forEach((value) => {
+    if (!value || typeof value !== "object") return;
+    const entry = value;
+    if (!entry.details) return;
+    if (eventType && entry.details.type !== eventType) return;
+    if (sessionRunId && !isRecordInRun(entry.details.sessionRunId, sessionRunId)) {
+      return;
+    }
+    events.push({
+      ...entry.details,
+      sessionRunId: resolveRecordRunId(entry.details.sessionRunId, sessionRunId)
+    });
+  });
+  events.sort((a, b) => a.timestamp - b.timestamp || a.id.localeCompare(b.id));
+  return events;
+}
+
+// src/core/lib/flowEngine/runMigration.ts
+function stampMapValues(yDoc, key, sessionRunId) {
+  const map = getExistingYMap(yDoc, key);
+  if (!map) return 0;
+  let stamped = 0;
+  map.forEach((value, entryKey) => {
+    if (!value || typeof value !== "object" || value.sessionRunId) return;
+    map.set(entryKey, { ...value, sessionRunId });
+    stamped += 1;
+  });
+  return stamped;
+}
+function stampAuditEntries(yDoc, scope, sessionRunId, matches) {
+  const auditMap = getExistingYMap(yDoc, "auditTrail");
+  const arr = auditMap?.get(scope);
+  if (!arr) return 0;
+  let stamped = 0;
+  for (let index = 0; index < arr.length; index += 1) {
+    const value = arr.get(index);
+    if (!value || typeof value !== "object") continue;
+    const entry = value;
+    if (!entry.details || entry.details.sessionRunId || !matches(entry)) continue;
+    arr.delete(index, 1);
+    arr.insert(index, [{ ...entry, details: { ...entry.details, sessionRunId } }]);
+    stamped += 1;
+  }
+  return stamped;
+}
+function stampPreSessionRecords(yDoc, sessionRunId) {
+  const auditScopes = getExistingYMap(yDoc, "auditTrail");
+  let runRecords = 0;
+  auditScopes?.forEach((_, scope) => {
+    if (scope === FLOW_AGENT_AUDIT_SCOPE) return;
+    runRecords += stampAuditEntries(yDoc, scope, sessionRunId, (entry) => entry.type === RUN_RECORD_AUDIT_TYPE);
+  });
+  return {
+    commands: stampMapValues(yDoc, FLOW_AGENT_OUTBOX_KEY, sessionRunId),
+    leases: stampMapValues(yDoc, FLOW_AGENT_LEASES_KEY, sessionRunId),
+    ledgerEvents: stampAuditEntries(yDoc, FLOW_AGENT_AUDIT_SCOPE, sessionRunId, () => true),
+    invocations: stampInvocations(yDoc, sessionRunId),
+    runRecords
+  };
+}
+function stampInvocations(yDoc, sessionRunId) {
+  const map = getExistingYMap(yDoc, INVOCATIONS_MAP_KEY);
+  if (!map) return 0;
+  let stamped = 0;
+  map.forEach((value, cid) => {
+    if (!value || typeof value !== "object" || value.sessionRunId) return;
+    map.set(cid, { ...value, sessionRunId });
+    stamped += 1;
+  });
+  return stamped;
+}
+function deriveMigratedStartedAt(yDoc) {
+  let earliest;
+  getExistingYMap(yDoc, "runtime")?.forEach((value) => {
+    if (!value || typeof value !== "object") return;
+    const executedAt = value.executedAt;
+    if (typeof executedAt !== "number" || !Number.isFinite(executedAt)) return;
+    if (earliest === void 0 || executedAt < earliest) earliest = executedAt;
+  });
+  if (earliest !== void 0) return earliest;
+  const createdAt = getExistingYMap(yDoc, "root")?.get("createdAt");
+  if (typeof createdAt === "number" && Number.isFinite(createdAt)) return createdAt;
+  if (typeof createdAt === "string") {
+    const parsed = Date.parse(createdAt);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return 0;
+}
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function encodeCrockford(value, length) {
+  let remaining = value;
+  let encoded = "";
+  for (let index = 0; index < length; index += 1) {
+    encoded = CROCKFORD[remaining % 32] + encoded;
+    remaining = Math.floor(remaining / 32);
+  }
+  return encoded;
+}
+function deriveMigratedRunId(params) {
+  const seed = `${params.docId}\0${params.defHash}\0${params.startedAt}`;
+  return `r-0001-${encodeCrockford(fnv1a(seed), 8)}${encodeCrockford(fnv1a(`${seed}\0salt`), 8)}`;
+}
+
+// src/core/lib/flowEngine/runLifecycle.ts
+var RunLifecycleAuthorizationError = class extends Error {
+  constructor(capability, message) {
+    super(message);
+    this.capability = capability;
+    this.name = "RunLifecycleAuthorizationError";
+  }
+};
+var RunNotReadyError = class extends Error {
+  constructor(incompleteBlockIds) {
+    super(`Run cannot close while manifest actions remain incomplete: ${incompleteBlockIds.join(", ")}`);
+    this.incompleteBlockIds = incompleteBlockIds;
+    this.name = "RunNotReadyError";
+  }
+};
+var FlowNotMigratedError = class extends Error {
+  constructor(flowUri) {
+    super("This flow predates sessions. Migrate it to enable them.");
+    this.flowUri = flowUri;
+    this.name = "FlowNotMigratedError";
+  }
+};
+var RunNotMigratedError = class extends Error {
+  constructor(runId) {
+    super(`Run "${runId}" has no frozen manifest, so it is not a session.`);
+    this.runId = runId;
+    this.name = "RunNotMigratedError";
+  }
+};
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(canonicalize);
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    const nested = value[key];
+    if (nested !== void 0 && typeof nested !== "function") result[key] = canonicalize(nested);
+  }
+  return result;
+}
+function fnv1a323(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function computeRunDefinitionHash(definition) {
+  return `def-${fnv1a323(JSON.stringify(canonicalize(definition)))}`;
+}
+function toRunJsonValue(value) {
+  if (value === void 0) return null;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+function walkBlocks(blocks, visit) {
+  for (const block of blocks) {
+    visit(block);
+    if (Array.isArray(block.children)) walkBlocks(block.children, visit);
+  }
+}
+function buildRunDefinitionSnapshot(blocks, definition = blocks) {
+  const blockIds = [];
+  const actionTypes = {};
+  walkBlocks(blocks, (block) => {
+    const actionType = block.props?.actionType;
+    if (!block.id || typeof actionType !== "string" || isBelowTheLineBlock(block) || actionType === "qi/flow.run.start" || actionType === "qi/flow.run.close") {
+      return;
+    }
+    blockIds.push(block.id);
+    actionTypes[block.id] = actionType;
+  });
+  return {
+    manifest: {
+      blockIds,
+      defHash: computeRunDefinitionHash(definition)
+    },
+    actionTypes
+  };
+}
+var CROCKFORD2 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function encodeTime(timestamp) {
+  let value = Math.max(0, Math.floor(timestamp));
+  let encoded = "";
+  for (let i = 0; i < 10; i += 1) {
+    encoded = CROCKFORD2[value % 32] + encoded;
+    value = Math.floor(value / 32);
+  }
+  return encoded;
+}
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.getRandomValues) return cryptoApi.getRandomValues(bytes);
+  for (let i = 0; i < length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  return bytes;
+}
+function createRunUlid(timestamp = Date.now()) {
+  const bytes = randomBytes(16);
+  let randomPart = "";
+  for (let i = 0; i < 16; i += 1) randomPart += CROCKFORD2[bytes[i] & 31];
+  return `${encodeTime(timestamp)}${randomPart}`;
+}
+function nextRunSequence(yDoc) {
+  let max = 0;
+  getExistingRunsMap(yDoc)?.forEach((_, runId) => {
+    max = Math.max(max, getRunMeta(yDoc, runId)?.seq || 0);
+  });
+  return max + 1;
+}
+function createRunId(seq, timestamp = Date.now()) {
+  return `r-${String(seq).padStart(4, "0")}-${createRunUlid(timestamp)}`;
+}
+function listRuns(yDoc) {
+  const terminal = getExistingRunsTerminalMap(yDoc);
+  const runs = [];
+  getExistingRunsMap(yDoc)?.forEach((_, id) => {
+    const meta = getRunMeta(yDoc, id);
+    if (!meta) return;
+    const terminalRecord = terminal?.get(id);
+    runs.push({
+      id,
+      meta: { ...meta, manifest: meta.manifest ? { ...meta.manifest, blockIds: [...meta.manifest.blockIds] } : void 0 },
+      terminal: terminalRecord ? { ...terminalRecord, summary: terminalRecord.summary ? { ...terminalRecord.summary } : void 0 } : void 0
+    });
+  });
+  return runs.sort((a, b) => b.meta.seq - a.meta.seq || b.meta.startedAt - a.meta.startedAt || b.id.localeCompare(a.id));
+}
+function listOpenRuns(yDoc) {
+  return listRuns(yDoc).filter((run) => !run.terminal);
+}
+function setAdvisoryActiveRunId(yDoc, runId) {
+  if (!getExistingRunsMap(yDoc)?.has(runId)) throw new Error(`Unknown run "${runId}"`);
+  yDoc.getMap("root").set("activeRunId", runId);
+}
+async function requireAuthorization(authorize, request) {
+  if (isTempUcanEnforcementDisabled()) {
+    return { allowed: true };
+  }
+  const decision = await authorize(request);
+  if (!decision.allowed) {
+    throw new RunLifecycleAuthorizationError(request.can, decision.reason || `${request.actorDid} is not authorized for ${request.can}`);
+  }
+  return decision;
+}
+var lifecycleQueues = /* @__PURE__ */ new WeakMap();
+async function withLifecycleLock(yDoc, key, operation) {
+  let queues = lifecycleQueues.get(yDoc);
+  if (!queues) {
+    queues = /* @__PURE__ */ new Map();
+    lifecycleQueues.set(yDoc, queues);
+  }
+  const previous = queues.get(key) || Promise.resolve();
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const current = previous.then(() => gate);
+  queues.set(key, current);
+  await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (queues.get(key) === current) queues.delete(key);
+  }
+}
+async function startRun(params) {
+  return withLifecycleLock(params.yDoc, "__start__", async () => {
+    assertLegacyFlowOperationAllowed(params.protocolGate, "run.start");
+    if (usesLegacyRuntimeCompatibility(params.yDoc)) {
+      throw new FlowNotMigratedError(params.flowUri);
+    }
+    const authorization = await requireAuthorization(params.authorize, {
+      can: "flow/run.start",
+      with: params.flowUri,
+      actorDid: params.actorDid
+    });
+    const now = params.now?.() ?? Date.now();
+    const seq = nextRunSequence(params.yDoc);
+    const runId = createRunId(seq, now);
+    const meta = {
+      seq,
+      startedAt: now,
+      startedByDid: params.actorDid,
+      origin: "started",
+      ...params.label ? { label: params.label } : {},
+      manifest: {
+        blockIds: [...params.definition.manifest.blockIds],
+        defHash: params.definition.manifest.defHash
+      }
+    };
+    const eventId = await params.eventLog.append({
+      runId,
+      kind: "run.started",
+      payload: {
+        ...authorization.invocationCid ? { invocationCid: authorization.invocationCid } : {},
+        definitionRevision: params.definition.manifest.defHash,
+        ...params.label ? { label: params.label } : {}
+      },
+      idempotencyKey: createRunEventIdempotencyKey("run.started", runId),
+      ts: now
+    });
+    let flowStartInvocations = 0;
+    params.yDoc.transact(() => {
+      setMultiRunStorage(params.yDoc);
+      ensureRun(params.yDoc, runId, meta);
+      for (const blockId of meta.manifest.blockIds) {
+        resetActionState(params.yDoc, runId, blockId, { state: "idle" });
+      }
+      if (params.document) {
+        flowStartInvocations = dispatchFlowStartTriggers({
+          yDoc: params.yDoc,
+          runId,
+          blocks: params.document,
+          startedAt: now,
+          sourceEventId: eventId
+        });
+      }
+      params.yDoc.getMap("root").set("activeRunId", runId);
+    });
+    return {
+      run: { id: runId, meta },
+      eventId,
+      flowStartInvocations
+    };
+  });
+}
+async function migrateFlowToSessions(params) {
+  return withLifecycleLock(params.yDoc, "__start__", async () => {
+    const empty = { actionStates: 0, pendingInvocations: 0, barrierEntries: 0 };
+    if (!usesLegacyRuntimeCompatibility(params.yDoc)) {
+      return { seeded: empty, phantomCollected: false, alreadyMigrated: true };
+    }
+    const authorization = await requireAuthorization(params.authorize, {
+      can: "flow/run.start",
+      with: params.flowUri,
+      actorDid: params.actorDid
+    });
+    const startedAt = deriveMigratedStartedAt(params.yDoc);
+    const runId = deriveMigratedRunId({
+      docId: String(params.yDoc.getMap("root").get("doc_id") || params.flowUri),
+      defHash: params.definition.manifest.defHash,
+      startedAt
+    });
+    const meta = {
+      seq: 1,
+      startedAt,
+      startedByDid: params.actorDid,
+      origin: "migrated",
+      label: params.label || "Session 1 (migrated)",
+      manifest: {
+        blockIds: [...params.definition.manifest.blockIds],
+        defHash: params.definition.manifest.defHash
+      }
+    };
+    const eventId = await params.eventLog.append({
+      runId,
+      kind: "run.started",
+      payload: {
+        ...authorization.invocationCid ? { invocationCid: authorization.invocationCid } : {},
+        definitionRevision: params.definition.manifest.defHash,
+        label: meta.label
+      },
+      idempotencyKey: createRunEventIdempotencyKey("run.started", runId),
+      ts: startedAt
+    });
+    let seeded = empty;
+    let stamped;
+    let phantomCollected = false;
+    params.yDoc.transact(() => {
+      phantomCollected = collectPhantomLegacyRun(params.yDoc);
+      ensureRun(params.yDoc, runId, meta);
+      seeded = seedRunFromLegacyRuntime(params.yDoc, runId);
+      stamped = stampPreSessionRecords(params.yDoc, runId);
+      setMultiRunStorage(params.yDoc);
+      params.yDoc.getMap("root").set("activeRunId", runId);
+    });
+    return {
+      run: { id: runId, meta },
+      eventId,
+      seeded,
+      stamped,
+      phantomCollected,
+      alreadyMigrated: false
+    };
+  });
+}
+function computeRunSummary(yDoc, runId, actionTypes, context) {
+  const meta = getRunMeta(yDoc, runId);
+  if (!meta?.manifest) throw new RunNotMigratedError(runId);
+  const runContext = { ...context, runId };
+  const summary = {};
+  for (const blockId of meta.manifest.blockIds) {
+    summary[blockId] = isActionDone(actionTypes[blockId] ? getAction(actionTypes[blockId]) : void 0, readActionState(yDoc, runId, blockId), runContext);
+  }
+  return summary;
+}
+function inspectPinnedDesignPodRunForClosure(yDoc, runId) {
+  const designPodDefinition = getExistingYMap(yDoc, "designPodDefinition");
+  const designPodState = getExistingYMap(yDoc, "designPodState");
+  const designPodIdentity = designPodState?.get("identity");
+  if (designPodDefinition?.get("manifest") && !designPodIdentity?.sessionRunId) {
+    throw new Error("A Design POD session cannot close or cancel before its project identity is pinned");
+  }
+  const isPinnedDesignPodRun = designPodIdentity?.sessionRunId === runId;
+  const designPodRelease = designPodState?.get("release");
+  if (isPinnedDesignPodRun && designPodRelease?.status !== "published") {
+    throw new Error("The pinned Design POD session cannot close until its current independently reviewed release is published");
+  }
+  if (!isPinnedDesignPodRun) return { pinned: false };
+  const releaseDigest = designPodRelease?.digest;
+  return {
+    pinned: true,
+    snapshot: JSON.stringify(
+      canonicalize({
+        manifest: designPodDefinition?.get("manifest"),
+        identity: designPodIdentity,
+        release: designPodRelease,
+        publication: typeof releaseDigest === "string" ? designPodState?.get(`publication:${releaseDigest}`) : void 0,
+        root: {
+          doc_id: getExistingYMap(yDoc, "root")?.get("doc_id"),
+          flowOwnerDid: getExistingYMap(yDoc, "root")?.get("flowOwnerDid")
+        }
+      })
+    )
+  };
+}
+async function authenticatePinnedDesignPodClosure(params) {
+  const captured = inspectPinnedDesignPodRunForClosure(params.yDoc, params.runId);
+  if (!captured.pinned) return captured;
+  if (!params.verifyDesignPodPublication) {
+    throw new Error("The pinned Design POD session requires authenticated publication verification before close or cancel");
+  }
+  const verification = await params.verifyDesignPodPublication({ yDoc: params.yDoc, runId: params.runId, flowUri: params.flowUri });
+  if (!verification.valid) {
+    throw new Error(`The pinned Design POD publication could not be authenticated${verification.error ? `: ${verification.error}` : ""}`);
+  }
+  return captured;
+}
+function incompleteBlocks(summary) {
+  return Object.entries(summary).filter(([, done]) => !done).map(([blockId]) => blockId);
+}
+function terminalSummary(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value);
+  if (entries.some(([, done]) => typeof done !== "boolean")) return void 0;
+  return Object.fromEntries(entries);
+}
+function terminalAuthorizationFromEvent(event) {
+  if (event.content.kind !== "run.closed" && event.content.kind !== "run.cancelled") return void 0;
+  const value = event.content.payload.authorization;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const proof = value;
+  const actionInputs = proof.actionInputs;
+  const capability = proof.capability;
+  if (typeof proof.invocationCid !== "string" || typeof proof.invocation !== "string" || typeof proof.actorDid !== "string" || proof.actionType !== "qi/flow.run.close" || typeof proof.actionBlockId !== "string" || typeof proof.inputDigest !== "string" || !actionInputs || typeof actionInputs !== "object" || Array.isArray(actionInputs) || !capability || typeof capability !== "object" || Array.isArray(capability) || typeof capability.can !== "string" || typeof capability.with !== "string" || !Array.isArray(proof.proofCids) || proof.proofCids.some((cid) => typeof cid !== "string")) {
+    return void 0;
+  }
+  return {
+    invocationCid: proof.invocationCid,
+    invocation: proof.invocation,
+    actorDid: proof.actorDid,
+    actionType: "qi/flow.run.close",
+    actionBlockId: proof.actionBlockId,
+    inputDigest: proof.inputDigest,
+    actionInputs,
+    capability,
+    proofCids: [...proof.proofCids]
+  };
+}
+function terminalReservationFromEvent(event, authorization) {
+  if (event.content.kind !== "run.closed" && event.content.kind !== "run.cancelled") return void 0;
+  const summary = terminalSummary(event.content.payload.summary);
+  if (!summary) return void 0;
+  return {
+    reservation: {
+      reservationId: `matrix:${event.eventId}`,
+      status: event.content.kind === "run.closed" ? "closed" : "cancelled",
+      at: event.originServerTs,
+      ...authorization?.actorDid || event.content.payload.actorDid ? { by: authorization?.actorDid || event.content.payload.actorDid } : {},
+      ...authorization?.invocationCid || event.content.payload.invocationCid ? { closeInvocationCid: authorization?.invocationCid || event.content.payload.invocationCid } : {},
+      ...event.content.kind === "run.cancelled" && event.content.payload.reason ? { reason: event.content.payload.reason } : {},
+      summary
+    },
+    eventId: event.eventId
+  };
+}
+function sameTerminalSummary(left, right) {
+  return JSON.stringify(canonicalize(left)) === JSON.stringify(canonicalize(right));
+}
+async function authenticatedTerminalFromEvent(event, params) {
+  if (event.content.runId !== params.runId || event.content.kind !== "run.closed" && event.content.kind !== "run.cancelled") return void 0;
+  const authorization = terminalAuthorizationFromEvent(event);
+  if (!authorization || event.content.payload.invocationCid !== authorization.invocationCid) return void 0;
+  if (await digestDesignPodValue(authorization.actionInputs) !== authorization.inputDigest) return void 0;
+  const cancelled = authorization.actionInputs.cancel === true;
+  const expectedStatus = cancelled ? "cancelled" : "closed";
+  const eventStatus = event.content.kind === "run.cancelled" ? "cancelled" : "closed";
+  if (eventStatus !== expectedStatus) return void 0;
+  const expectedReason = cancelled && typeof authorization.actionInputs.reason === "string" ? authorization.actionInputs.reason : void 0;
+  const eventReason = event.content.kind === "run.cancelled" ? event.content.payload.reason : void 0;
+  if (eventReason !== expectedReason) return void 0;
+  const terminal = terminalReservationFromEvent(event, authorization);
+  if (!terminal) return void 0;
+  const authorizedSummary = terminalSummary(authorization.actionInputs.terminalSummary);
+  if (!authorizedSummary || !sameTerminalSummary(terminal.reservation.summary, authorizedSummary)) return void 0;
+  const blockCapability = authorization.capability.can === "flow/block/execute" && authorization.capability.with === `${params.flowUri}:${authorization.actionBlockId}`;
+  const directCapability = authorization.capability.can === "flow/run.close" && authorization.capability.with === params.flowUri;
+  if (!blockCapability && !directCapability) return void 0;
+  const invocation = {
+    cid: authorization.invocationCid,
+    invocation: authorization.invocation,
+    invokerDid: authorization.actorDid,
+    capability: authorization.capability,
+    executedAt: event.originServerTs,
+    flowId: params.flowUri.replace(/^ixo:flow:/, ""),
+    sessionRunId: params.runId,
+    blockId: authorization.actionBlockId,
+    result: "success",
+    proofCids: authorization.proofCids,
+    facts: { actionType: authorization.actionType, inputDigest: authorization.inputDigest, sessionRunId: params.runId }
+  };
+  const verified = await params.verifyInvocation({
+    invocation,
+    expected: {
+      actorDid: authorization.actorDid,
+      actionType: authorization.actionType,
+      blockId: authorization.actionBlockId,
+      inputDigest: authorization.inputDigest,
+      flowUri: params.flowUri,
+      flowOwnerDid: params.flowOwnerDid,
+      sessionRunId: params.runId,
+      capability: authorization.capability
+    }
+  });
+  return verified.valid ? terminal : void 0;
+}
+async function readMatrixTerminalState(eventLog, params) {
+  if (!eventLog.read) throw new Error("Matrix ordered readback is required to elect a terminal transition");
+  let from;
+  const seenTokens = /* @__PURE__ */ new Set();
+  do {
+    const page = await eventLog.read(params.runId, { direction: "forward", limit: 100, ...from ? { from } : {} });
+    for (const event of page.events) {
+      if (event.content.kind !== "run.closed" && event.content.kind !== "run.cancelled") continue;
+      if (params.verifyInvocation) {
+        const authenticated = await authenticatedTerminalFromEvent(event, { ...params, verifyInvocation: params.verifyInvocation });
+        if (authenticated) return { terminal: authenticated };
+        if (terminalAuthorizationFromEvent(event)) continue;
+      }
+      if (!params.requireAuthenticated) {
+        const legacy = terminalReservationFromEvent(event);
+        if (legacy && (!params.legacyExpectedSummary || sameTerminalSummary(legacy.reservation.summary, params.legacyExpectedSummary))) return { terminal: legacy };
+      }
+    }
+    from = page.nextToken;
+    if (from && seenTokens.has(from)) throw new Error("Matrix repeated a terminal-event pagination token");
+    if (from) seenTokens.add(from);
+  } while (from);
+  return {};
+}
+function clearOwnTerminalReservation(yDoc, runId, reservationId) {
+  yDoc.transact(() => {
+    const pending = getExistingRunsTerminalPendingMap(yDoc)?.get(runId);
+    if (pending?.reservationId === reservationId) getRunsTerminalPendingMap(yDoc).delete(runId);
+  });
+}
+async function reconcileTerminalEvent(eventLog, event, reservation, params) {
+  let eventId;
+  let appendError;
+  try {
+    eventId = await eventLog.append(event);
+  } catch (error) {
+    appendError = error;
+  }
+  if (eventLog.read) {
+    const state = await readMatrixTerminalState(eventLog, {
+      runId: event.runId,
+      flowUri: params.flowUri,
+      flowOwnerDid: params.flowOwnerDid,
+      legacyExpectedSummary: reservation.summary,
+      verifyInvocation: params.verifyInvocation,
+      requireAuthenticated: params.requireAuthenticated
+    });
+    if (state.terminal) return state.terminal;
+    if (appendError) throw appendError;
+    throw new Error("Matrix did not retain an authoritative terminal event");
+  }
+  if (eventId) return { reservation, eventId };
+  throw appendError;
+}
+function prepareTerminalTransition(params, status, authorization, now, pinnedDesignPod, reason) {
+  let existing;
+  let reservation;
+  const matrixAuthoritative = pinnedDesignPod.pinned || Boolean(params.terminalAuthorization);
+  params.yDoc.transact(() => {
+    const current = getExistingRunsTerminalMap(params.yDoc)?.get(params.runId);
+    if (current && !matrixAuthoritative) {
+      existing = current;
+      return;
+    }
+    if (pinnedDesignPod.pinned) {
+      const current2 = inspectPinnedDesignPodRunForClosure(params.yDoc, params.runId);
+      if (current2.snapshot !== pinnedDesignPod.snapshot) {
+        throw new Error("The authenticated Design POD publication changed before its terminal transition could be reserved");
+      }
+    }
+    const finalSummary = computeRunSummary(params.yDoc, params.runId, params.actionTypes, {
+      flowId: params.flowUri,
+      actorDid: params.actorDid,
+      now
+    });
+    const incomplete = incompleteBlocks(finalSummary);
+    if (status === "closed" && incomplete.length > 0 && (!params.allowIncomplete || pinnedDesignPod.pinned)) {
+      throw new RunNotReadyError(incomplete);
+    }
+    reservation = {
+      reservationId: `${status}:${params.runId}:${createRunUlid(now)}`,
+      status,
+      at: now,
+      by: params.actorDid,
+      ...params.terminalAuthorization?.invocationCid || authorization.invocationCid ? { closeInvocationCid: params.terminalAuthorization?.invocationCid || authorization.invocationCid } : {},
+      ...reason ? { reason } : {},
+      summary: finalSummary
+    };
+  });
+  return { reservation, existing };
+}
+function installTerminalReservation(params, reservation, pinnedDesignPod) {
+  let existing;
+  const matrixAuthoritative = pinnedDesignPod.pinned || Boolean(params.terminalAuthorization);
+  params.yDoc.transact(() => {
+    const current = getExistingRunsTerminalMap(params.yDoc)?.get(params.runId);
+    if (current && !matrixAuthoritative) {
+      existing = current;
+      return;
+    }
+    if (pinnedDesignPod.pinned) {
+      const current2 = inspectPinnedDesignPodRunForClosure(params.yDoc, params.runId);
+      if (current2.snapshot !== pinnedDesignPod.snapshot) {
+        throw new Error("The authenticated Design POD publication changed before its terminal transition could be reserved");
+      }
+    }
+    const finalSummary = computeRunSummary(params.yDoc, params.runId, params.actionTypes, {
+      flowId: params.flowUri,
+      actorDid: params.actorDid,
+      now: reservation.at
+    });
+    const incomplete = incompleteBlocks(finalSummary);
+    if (reservation.status === "closed" && incomplete.length > 0 && (!params.allowIncomplete || pinnedDesignPod.pinned)) {
+      throw new RunNotReadyError(incomplete);
+    }
+    if (JSON.stringify(canonicalize(finalSummary)) !== JSON.stringify(canonicalize(reservation.summary))) {
+      throw new Error("The run completion summary changed while its terminal event was being prepared");
+    }
+    getRunsTerminalPendingMap(params.yDoc).set(params.runId, reservation);
+  });
+  return existing;
+}
+function finalizeTerminalTransition(yDoc, runId, reservation, eventId, matrixAuthoritative = false) {
+  const terminal = {
+    status: reservation.status,
+    at: reservation.at,
+    by: reservation.by,
+    terminalEventId: eventId,
+    ...reservation.closeInvocationCid ? { closeInvocationCid: reservation.closeInvocationCid } : {},
+    summary: reservation.summary
+  };
+  let created = false;
+  yDoc.transact(() => {
+    const terminalMap = getRunsTerminalMap(yDoc);
+    if (matrixAuthoritative || !terminalMap.has(runId)) {
+      created = !terminalMap.has(runId);
+      terminalMap.set(runId, terminal);
+    }
+    if (getExistingRunsTerminalPendingMap(yDoc)?.has(runId)) getRunsTerminalPendingMap(yDoc).delete(runId);
+  });
+  const winner = getRunsTerminalMap(yDoc).get(runId) || terminal;
+  return {
+    terminal: { ...winner, summary: winner.summary ? { ...winner.summary } : void 0 },
+    created,
+    eventId: winner.terminalEventId || eventId
+  };
+}
+async function closeRun(params) {
+  return withLifecycleLock(params.yDoc, params.runId, async () => {
+    const existing = getExistingRunsTerminalMap(params.yDoc)?.get(params.runId);
+    const initialPinnedState = inspectPinnedDesignPodRunForClosure(params.yDoc, params.runId);
+    if (existing && !initialPinnedState.pinned && !params.terminalAuthorization) {
+      return {
+        terminal: {
+          ...existing,
+          summary: existing.summary ? { ...existing.summary } : void 0
+        },
+        created: false,
+        ...existing.terminalEventId ? { eventId: existing.terminalEventId } : {}
+      };
+    }
+    const meta = getRunMeta(params.yDoc, params.runId);
+    if (!meta) throw new Error(`Unknown run "${params.runId}"`);
+    const authorization = await requireAuthorization(params.authorize, {
+      can: "flow/run.close",
+      with: params.flowUri,
+      actorDid: params.actorDid,
+      runId: params.runId
+    });
+    const now = params.now?.() ?? Date.now();
+    const summary = computeRunSummary(params.yDoc, params.runId, params.actionTypes, {
+      flowId: params.flowUri,
+      actorDid: params.actorDid,
+      now
+    });
+    const incomplete = incompleteBlocks(summary);
+    const pinnedDesignPod = await authenticatePinnedDesignPodClosure(params);
+    const authenticatedTerminalRequired = pinnedDesignPod.pinned || Boolean(params.terminalAuthorization);
+    if (authenticatedTerminalRequired && !params.eventLog.read) {
+      throw new Error("Matrix ordered readback is required to elect an authenticated terminal transition");
+    }
+    if (authenticatedTerminalRequired && (!params.terminalAuthorization || !params.verifyTerminalInvocation)) {
+      throw new Error("This terminal transition requires a cryptographically verified signed Flow invocation");
+    }
+    if (authenticatedTerminalRequired) {
+      const retained = await readMatrixTerminalState(params.eventLog, {
+        runId: params.runId,
+        flowUri: params.flowUri,
+        flowOwnerDid: String(getExistingYMap(params.yDoc, "root")?.get("flowOwnerDid") || ""),
+        verifyInvocation: params.verifyTerminalInvocation,
+        requireAuthenticated: true
+      });
+      if (retained.terminal) {
+        return finalizeTerminalTransition(params.yDoc, params.runId, retained.terminal.reservation, retained.terminal.eventId, true);
+      }
+    }
+    if (incomplete.length > 0 && (!params.allowIncomplete || pinnedDesignPod.pinned)) {
+      throw new RunNotReadyError(incomplete);
+    }
+    const transition = prepareTerminalTransition(params, "closed", authorization, now, pinnedDesignPod);
+    if (transition.existing) {
+      return {
+        terminal: { ...transition.existing, summary: transition.existing.summary ? { ...transition.existing.summary } : void 0 },
+        created: false,
+        ...transition.existing.terminalEventId ? { eventId: transition.existing.terminalEventId } : {}
+      };
+    }
+    const reservation = transition.reservation;
+    const installedTerminal = installTerminalReservation(params, reservation, pinnedDesignPod);
+    if (installedTerminal) {
+      return {
+        terminal: { ...installedTerminal, summary: installedTerminal.summary ? { ...installedTerminal.summary } : void 0 },
+        created: false,
+        ...installedTerminal.terminalEventId ? { eventId: installedTerminal.terminalEventId } : {}
+      };
+    }
+    const event = {
+      runId: params.runId,
+      kind: "run.closed",
+      payload: {
+        ...reservation.closeInvocationCid ? { invocationCid: reservation.closeInvocationCid } : {},
+        ...reservation.by ? { actorDid: reservation.by } : {},
+        summary: reservation.summary,
+        ...params.terminalAuthorization ? { authorization: toRunJsonValue(params.terminalAuthorization) } : {}
+      },
+      idempotencyKey: createRunEventIdempotencyKey("run.closed", params.runId, reservation.closeInvocationCid || reservation.reservationId),
+      ts: reservation.at
+    };
+    try {
+      const reconciled = await reconcileTerminalEvent(params.eventLog, event, reservation, {
+        flowUri: params.flowUri,
+        flowOwnerDid: String(getExistingYMap(params.yDoc, "root")?.get("flowOwnerDid") || ""),
+        verifyInvocation: params.verifyTerminalInvocation,
+        requireAuthenticated: authenticatedTerminalRequired
+      });
+      return finalizeTerminalTransition(params.yDoc, params.runId, reconciled.reservation, reconciled.eventId, authenticatedTerminalRequired);
+    } catch (error) {
+      clearOwnTerminalReservation(params.yDoc, params.runId, reservation.reservationId);
+      throw error;
+    }
+  });
+}
+async function cancelRun(params) {
+  return withLifecycleLock(params.yDoc, params.runId, async () => {
+    const existing = getExistingRunsTerminalMap(params.yDoc)?.get(params.runId);
+    const initialPinnedState = inspectPinnedDesignPodRunForClosure(params.yDoc, params.runId);
+    if (existing && !initialPinnedState.pinned && !params.terminalAuthorization) {
+      return {
+        terminal: {
+          ...existing,
+          summary: existing.summary ? { ...existing.summary } : void 0
+        },
+        created: false,
+        ...existing.terminalEventId ? { eventId: existing.terminalEventId } : {}
+      };
+    }
+    if (!getRunMeta(params.yDoc, params.runId)) {
+      throw new Error(`Unknown run "${params.runId}"`);
+    }
+    const authorization = await requireAuthorization(params.authorize, {
+      can: "flow/run.close",
+      with: params.flowUri,
+      actorDid: params.actorDid,
+      runId: params.runId
+    });
+    const now = params.now?.() ?? Date.now();
+    const pinnedDesignPod = await authenticatePinnedDesignPodClosure(params);
+    const authenticatedTerminalRequired = pinnedDesignPod.pinned || Boolean(params.terminalAuthorization);
+    if (authenticatedTerminalRequired && !params.eventLog.read) {
+      throw new Error("Matrix ordered readback is required to elect an authenticated terminal transition");
+    }
+    if (authenticatedTerminalRequired && (!params.terminalAuthorization || !params.verifyTerminalInvocation)) {
+      throw new Error("This terminal transition requires a cryptographically verified signed Flow invocation");
+    }
+    if (authenticatedTerminalRequired) {
+      const retained = await readMatrixTerminalState(params.eventLog, {
+        runId: params.runId,
+        flowUri: params.flowUri,
+        flowOwnerDid: String(getExistingYMap(params.yDoc, "root")?.get("flowOwnerDid") || ""),
+        verifyInvocation: params.verifyTerminalInvocation,
+        requireAuthenticated: true
+      });
+      if (retained.terminal) {
+        return finalizeTerminalTransition(params.yDoc, params.runId, retained.terminal.reservation, retained.terminal.eventId, true);
+      }
+    }
+    const transition = prepareTerminalTransition(params, "cancelled", authorization, now, pinnedDesignPod, params.reason);
+    if (transition.existing) {
+      return {
+        terminal: { ...transition.existing, summary: transition.existing.summary ? { ...transition.existing.summary } : void 0 },
+        created: false,
+        ...transition.existing.terminalEventId ? { eventId: transition.existing.terminalEventId } : {}
+      };
+    }
+    const reservation = transition.reservation;
+    const installedTerminal = installTerminalReservation(params, reservation, pinnedDesignPod);
+    if (installedTerminal) {
+      return {
+        terminal: { ...installedTerminal, summary: installedTerminal.summary ? { ...installedTerminal.summary } : void 0 },
+        created: false,
+        ...installedTerminal.terminalEventId ? { eventId: installedTerminal.terminalEventId } : {}
+      };
+    }
+    const event = {
+      runId: params.runId,
+      kind: "run.cancelled",
+      payload: {
+        ...reservation.closeInvocationCid ? { invocationCid: reservation.closeInvocationCid } : {},
+        ...reservation.by ? { actorDid: reservation.by } : {},
+        ...reservation.reason ? { reason: reservation.reason } : {},
+        summary: reservation.summary,
+        ...params.terminalAuthorization ? { authorization: toRunJsonValue(params.terminalAuthorization) } : {}
+      },
+      idempotencyKey: createRunEventIdempotencyKey("run.closed", params.runId, reservation.closeInvocationCid || reservation.reservationId),
+      ts: reservation.at
+    };
+    try {
+      const reconciled = await reconcileTerminalEvent(params.eventLog, event, reservation, {
+        flowUri: params.flowUri,
+        flowOwnerDid: String(getExistingYMap(params.yDoc, "root")?.get("flowOwnerDid") || ""),
+        verifyInvocation: params.verifyTerminalInvocation,
+        requireAuthenticated: authenticatedTerminalRequired
+      });
+      return finalizeTerminalTransition(params.yDoc, params.runId, reconciled.reservation, reconciled.eventId, authenticatedTerminalRequired);
+    } catch (error) {
+      clearOwnTerminalReservation(params.yDoc, params.runId, reservation.reservationId);
+      throw error;
+    }
+  });
+}
+function detectRunDefinitionDrift(yDoc, runId, definition) {
+  const manifest = getRunMeta(yDoc, runId)?.manifest;
+  if (!manifest) throw new RunNotMigratedError(runId);
+  const before = new Set(manifest.blockIds);
+  const after = new Set(definition.manifest.blockIds);
+  const changedBlockIds = [.../* @__PURE__ */ new Set([...before, ...after])].filter((id) => before.has(id) !== after.has(id));
+  return {
+    // With no frozen hash — a run the flow manager opened — the step list is
+    // the whole of what can be compared. It catches a step added or removed
+    // and misses one whose configuration was edited in place, which is less
+    // than the hash sees and more than a hash comparison against a differently
+    // computed value would be worth: that would read "changed" always, on
+    // every scheduled run, and mean nothing.
+    changed: manifest.defHash === void 0 ? changedBlockIds.length > 0 : manifest.defHash !== definition.manifest.defHash,
+    previousRevision: manifest.defHash,
+    revision: definition.manifest.defHash,
+    changedBlockIds
+  };
+}
+async function recordRunDefinitionDrift(yDoc, runId, definition, eventLog, now = Date.now()) {
+  const drift = detectRunDefinitionDrift(yDoc, runId, definition);
+  if (!drift.changed) return drift;
+  const eventId = await eventLog.append({
+    runId,
+    kind: "definition.changed",
+    payload: {
+      revision: drift.revision,
+      previousRevision: drift.previousRevision,
+      changedBlockIds: drift.changedBlockIds,
+      summary: "The live flow definition changed after this session started."
+    },
+    idempotencyKey: createRunEventIdempotencyKey("definition.changed", runId, drift.revision),
+    ts: now
+  });
+  return { ...drift, eventId };
+}
+function readRunActionStates(yDoc, runId, blockIds) {
+  return Object.fromEntries(blockIds.map((blockId) => [blockId, readActionState(yDoc, runId, blockId)]));
+}
+
+// src/core/lib/flowCompiler/resolveRefs.ts
+function resolveRuntimeRefs(nb, getNodeOutput2, triggerContext) {
+  return resolveValue(nb, getNodeOutput2, triggerContext);
+}
+function resolveValue(value, getNodeOutput2, triggerContext) {
+  if (isRuntimeRef(value)) {
+    return resolveRef(value.$ref, getNodeOutput2, triggerContext);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, getNodeOutput2, triggerContext));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = resolveValue(val, getNodeOutput2, triggerContext);
+    }
+    return result;
+  }
+  return value;
+}
+function resolveRef(ref, getNodeOutput2, triggerContext) {
+  if (ref.startsWith("trigger.payload.")) {
+    if (!triggerContext) {
+      throw new Error(`Trigger ref "${ref}" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);
+    }
+    const fieldPath2 = ref.slice("trigger.payload.".length);
+    return getNestedValue(triggerContext.payload, fieldPath2);
+  }
+  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
+    return triggerContext.refSnapshots[ref];
+  }
+  const outputIndex = ref.indexOf(".output.");
+  if (outputIndex === -1) {
+    throw new Error(`Invalid runtime reference "${ref}". Expected format: "nodeId.output.fieldPath" or "trigger.payload.fieldPath"`);
+  }
+  const nodeId = ref.slice(0, outputIndex);
+  const fieldPath = ref.slice(outputIndex + ".output.".length);
+  const output = getNodeOutput2(nodeId);
+  if (!output) {
+    return void 0;
+  }
+  return getNestedValue(output, fieldPath);
+}
+
+// src/core/lib/flowEngine/authorization.ts
+var isAuthorized = async (blockId, actorDid, ucanService, flowUri, schemaVersion, options = {}) => {
+  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
+  const requireUcan = options.requireSignedInvocation === true;
+  if (policy && !policy.ucanRequired && !requireUcan) {
+    return { authorized: true };
+  }
+  if (!ucanService) {
+    if (!policy && !requireUcan) {
+      return { authorized: true };
+    }
+    return {
+      authorized: false,
+      reason: requireUcan ? "UCAN service is not configured. This governed action requires a signed Flow invocation." : "UCAN service is not configured. This flow version requires UCAN authorization."
+    };
+  }
+  const capability = {
+    can: "flow/block/execute",
+    with: `${flowUri}:${blockId}`
+  };
+  const result = await ucanService.validateDelegationChain(actorDid, capability);
+  if (!result.valid) {
+    return {
+      authorized: false,
+      reason: result.error || "No valid capability chain found"
+    };
+  }
+  const proofCids = result.proofChain?.map((d) => d.cid) || [];
+  if (requireUcan && proofCids.length === 0) {
+    return {
+      authorized: false,
+      reason: "A signed invocation requires a non-empty UCAN delegation proof chain."
+    };
+  }
+  return {
+    authorized: true,
+    capabilityId: proofCids[0],
+    proofCids
+  };
+};
+
+// src/core/lib/flowEngine/executor.ts
+var updateRuntimeAfterSuccess = (node, actorDid, runtime, actionResult, invocationCid, now) => {
+  const updates = {
+    submittedByDid: actionResult.submittedByDid || actorDid,
+    evaluationStatus: actionResult.evaluationStatus || "pending",
+    executionTimestamp: now ? now() : Date.now(),
+    lastInvocationCid: invocationCid
+  };
+  if (actionResult.claimId) {
+    updates.claimId = actionResult.claimId;
+  }
+  runtime.update(node.id, updates);
+};
+var executeNode = async ({
+  node,
+  actorDid,
+  actorType,
+  entityRoomId,
+  context,
+  action,
+  invocationFacts = {},
+  requireSignedInvocation = false,
+  pin
+}) => {
+  const { runtime, ucanService, invocationStore, flowUri, flowId, sessionRunId, schemaVersion, now } = context;
+  const auth = await isAuthorized(node.id, actorDid, ucanService, flowUri, schemaVersion, { requireSignedInvocation });
+  if (!auth.authorized) {
+    return { success: false, stage: "authorization", error: auth.reason };
+  }
+  if (requireSignedInvocation && !invocationStore) {
+    return { success: false, stage: "authorization", error: "A persisted invocation store is required for this governed action." };
+  }
+  if (node.linkedClaim && !node.linkedClaim.collectionId) {
+    return { success: false, stage: "claim", error: "Linked claim collection is required but missing." };
+  }
+  let invocationCid;
+  let invocationData;
+  if (ucanService && auth.proofCids && auth.proofCids.length > 0) {
+    const capability = {
+      can: "flow/block/execute",
+      with: `${flowUri}:${node.id}`
+    };
+    try {
+      const invocationResult = await ucanService.createAndValidateInvocation(
+        {
+          invokerDid: actorDid,
+          invokerType: actorType,
+          entityRoomId,
+          capability,
+          proofs: auth.proofCids,
+          facts: invocationFacts,
+          pin
+        },
+        flowId,
+        node.id
+      );
+      if (!invocationResult.valid) {
+        return {
+          success: false,
+          stage: "authorization",
+          error: `Invocation validation failed: ${invocationResult.error}`
+        };
+      }
+      invocationCid = invocationResult.cid;
+      invocationData = invocationResult.invocation;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to create invocation";
+      return { success: false, stage: "authorization", error: message };
+    }
+  }
+  if (requireSignedInvocation && (!invocationCid || !invocationData)) {
+    return { success: false, stage: "authorization", error: "This governed action requires a signed Flow invocation." };
+  }
+  try {
+    const result = await action({
+      invocationCid,
+      invocation: invocationData,
+      capabilityId: auth.capabilityId,
+      proofCids: auth.proofCids || [],
+      capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+      facts: invocationFacts
+    });
+    if (node.linkedClaim && !result.claimId) {
+      if (invocationStore && invocationCid && invocationData) {
+        const storedInvocation = {
+          cid: invocationCid,
+          invocation: invocationData,
+          invokerDid: actorDid,
+          capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+          executedAt: now ? now() : Date.now(),
+          flowId,
+          sessionRunId,
+          blockId: node.id,
+          result: "failure",
+          error: "Execution did not return a claimId for linked claim requirement.",
+          proofCids: auth.proofCids || [],
+          facts: invocationFacts
+        };
+        invocationStore.add(storedInvocation);
+      }
+      return {
+        success: false,
+        stage: "claim",
+        error: "Execution did not return a claimId for linked claim requirement.",
+        invocationCid
+      };
+    }
+    if (invocationStore && invocationCid && invocationData) {
+      const storedInvocation = {
+        cid: invocationCid,
+        invocation: invocationData,
+        invokerDid: actorDid,
+        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+        executedAt: now ? now() : Date.now(),
+        flowId,
+        sessionRunId,
+        blockId: node.id,
+        result: "success",
+        proofCids: auth.proofCids || [],
+        facts: invocationFacts,
+        claimId: result.claimId
+      };
+      invocationStore.add(storedInvocation);
+    }
+    updateRuntimeAfterSuccess(node, actorDid, runtime, result, invocationCid || auth.capabilityId, now);
+    return {
+      success: true,
+      stage: "complete",
+      result,
+      capabilityId: auth.capabilityId,
+      invocationCid
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Execution failed";
+    if (invocationStore && invocationCid && invocationData) {
+      const storedInvocation = {
+        cid: invocationCid,
+        invocation: invocationData,
+        invokerDid: actorDid,
+        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+        executedAt: now ? now() : Date.now(),
+        flowId,
+        sessionRunId,
+        blockId: node.id,
+        result: "failure",
+        error: message,
+        proofCids: auth.proofCids || [],
+        facts: invocationFacts
+      };
+      invocationStore.add(storedInvocation);
+    }
+    return { success: false, stage: "action", error: message, invocationCid };
+  }
+};
+
+// src/core/lib/flowEngine/readBackReconciler.ts
+async function appendReadBackTimeline(eventLog, event, runtime, blockId, now) {
+  const result = await appendRunTimelineEvent({
+    eventLog,
+    event,
+    runtime,
+    blockId,
+    now
+  });
+  return result.ok;
+}
+function isYDoc(value) {
+  return isYDocLike(value);
+}
+function getYDoc(editorOrYDoc) {
+  if (!editorOrYDoc) return void 0;
+  if (isYDoc(editorOrYDoc)) return editorOrYDoc;
+  return editorOrYDoc._yDoc;
+}
+function getEditor(editorOrYDoc) {
+  return editorOrYDoc && !isYDoc(editorOrYDoc) ? editorOrYDoc : void 0;
+}
+function getRuntime(editorOrYDoc, runtime, runId) {
+  if (runtime) return runtime;
+  const yDoc = getYDoc(editorOrYDoc);
+  if (yDoc) return createRunScopedRuntimeManager(yDoc, resolveRunIdForExecution(yDoc, runId));
+  return createRuntimeStateManager(!isYDoc(editorOrYDoc) ? editorOrYDoc : void 0);
+}
+function getReconcileEditor(params, yDoc, editor) {
+  if (editor) return editor;
+  if (!yDoc || !params.document) return void 0;
+  return {
+    _yDoc: yDoc,
+    _yRuntime: createRunRuntimeReaderWithDoc(yDoc, resolveRunIdForExecution(yDoc, params.runId)),
+    document: params.document
+  };
+}
+function makeExecutionId(now) {
+  return `readback-${now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function asOutput(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+function boundActionEvents(events) {
+  return events.map((event) => ({
+    name: event.name,
+    payload: boundRunEventJson(event.payload)
+  }));
+}
+function errorRecord(error) {
+  if (!error) return void 0;
+  return typeof error === "string" ? { message: error } : { message: error.message, code: error.code };
+}
+function normalizeActionReadBackMetadata(params) {
+  const base = params.readBack && typeof params.readBack === "object" && !Array.isArray(params.readBack) ? { ...params.readBack } : {};
+  const kind = typeof base.kind === "string" && base.kind.trim() ? base.kind.trim() : params.actionType;
+  const normalized = {
+    ...base,
+    kind,
+    status: "pending",
+    requestedAt: typeof base.requestedAt === "string" ? base.requestedAt : new Date(params.requestedAt).toISOString(),
+    blockId: params.blockId,
+    actionType: params.actionType,
+    actorDid: params.actorDid,
+    invocationCid: params.invocationCid,
+    capabilityId: params.capabilityId
+  };
+  if (params.pendingInvocation) {
+    normalized.pendingInvocation = {
+      id: params.pendingInvocation.id,
+      triggeringBlockId: params.pendingInvocation.triggeringBlockId,
+      eventName: params.pendingInvocation.eventName,
+      sourceRunId: params.pendingInvocation.sourceRunId
+    };
+  }
+  return normalized;
+}
+function writeReconciliationRunRecord(params) {
+  if (!params.yDoc) return void 0;
+  const completedAt = params.now();
+  const executionId = makeExecutionId(params.now);
+  const pendingInvocation = params.readBack.pendingInvocation;
+  const details = {
+    runId: executionId,
+    sessionRunId: params.sessionRunId,
+    output: params.output,
+    events: params.events,
+    startedAt: params.readBack.requestedAt || new Date(completedAt).toISOString(),
+    completedAt: new Date(completedAt).toISOString(),
+    actorDid: params.actorDid,
+    invocationCid: params.readBack.invocationCid,
+    capabilityId: params.readBack.capabilityId,
+    error: params.error,
+    readBack: params.readBack,
+    reconciled: true
+  };
+  if (pendingInvocation) {
+    details.fromPendingInvocationId = pendingInvocation.id;
+    details.triggeredBy = {
+      sourceBlockId: pendingInvocation.triggeringBlockId,
+      eventName: pendingInvocation.eventName
+    };
+    details.sourceRunId = pendingInvocation.sourceRunId;
+  }
+  appendRunRecord(params.yDoc, params.blockId, details, params.actorDid);
+  if (params.editor && params.events.length > 0) {
+    reconcilePendingInvocations(params.editor, params.sessionRunId);
+  }
+  return executionId;
+}
+async function reconcileActionReadBack(params) {
+  const now = params.now || Date.now;
+  const yDoc = getYDoc(params.editorOrYDoc);
+  const editor = getEditor(params.editorOrYDoc);
+  const eventLog = params.runEventLog || editor?._runEventLog;
+  const sessionRunId = yDoc ? resolveRunIdForExecution(yDoc, params.runId) : params.runId;
+  const runtime = getRuntime(params.editorOrYDoc, params.runtime, sessionRunId);
+  const current = runtime.get(params.blockId);
+  const output = asOutput(current.output);
+  const readBack = current.readBack;
+  const timelineRequired = Boolean(yDoc && !usesLegacyRuntimeCompatibility(yDoc));
+  if (timelineRequired && !eventLog) {
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: "pending",
+      output,
+      events: [],
+      error: "Read-back was not reconciled because a canonical run event log is required.",
+      pendingInvocationRemoved: false,
+      readBack
+    };
+  }
+  if (current.state !== "awaiting_readback" || !readBack?.kind) {
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: current.state === "failed" ? "failed" : "pending",
+      output,
+      events: [],
+      error: `Block "${params.blockId}" is not awaiting read-back`,
+      pendingInvocationRemoved: false,
+      readBack
+    };
+  }
+  const resolver = params.resolver || params.resolvers?.[readBack.kind];
+  if (!resolver) {
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: "pending",
+      output,
+      events: [],
+      error: `No read-back resolver registered for "${readBack.kind}"`,
+      pendingInvocationRemoved: false,
+      readBack
+    };
+  }
+  const resolution = await resolver({
+    blockId: params.blockId,
+    runtime: current,
+    output,
+    readBack
+  });
+  const checkedAt = now();
+  const checkedIso = new Date(checkedAt).toISOString();
+  const nextReadBack = {
+    ...readBack,
+    ...resolution.readBack || {},
+    status: resolution.state,
+    lastCheckedAt: checkedIso
+  };
+  if (resolution.state === "pending") {
+    runtime.update(params.blockId, {
+      readBack: nextReadBack
+    });
+    return {
+      success: true,
+      blockId: params.blockId,
+      state: "pending",
+      output,
+      events: resolution.events || [],
+      pendingInvocationRemoved: false,
+      readBack: nextReadBack
+    };
+  }
+  const events = boundActionEvents(resolution.events || []);
+  const mergedOutput = {
+    ...output,
+    ...resolution.output || {}
+  };
+  const boundedOutput = boundRunActionOutput(mergedOutput);
+  const finalOutput = boundedOutput.output;
+  const actorDid = params.actorDid || readBack.actorDid || current.executedByDid || "system:readback";
+  if (resolution.state === "failed") {
+    const error = errorRecord(resolution.error) || { message: "External read-back failed" };
+    const failedReadBack = {
+      ...nextReadBack,
+      terminalAt: checkedIso
+    };
+    runtime.update(params.blockId, {
+      state: "failed",
+      output: finalOutput,
+      error: { ...error, at: checkedAt },
+      readBack: failedReadBack
+    });
+    const executionId2 = writeReconciliationRunRecord({
+      yDoc,
+      editor: getReconcileEditor(params, yDoc, editor),
+      sessionRunId,
+      blockId: params.blockId,
+      actorDid,
+      output: finalOutput,
+      events,
+      readBack: failedReadBack,
+      error,
+      now
+    });
+    if (sessionRunId && eventLog) {
+      const timelineExecutionId = current.executionId || executionId2 || readBack.requestedAt || `readback-${checkedAt}`;
+      await appendReadBackTimeline(
+        eventLog,
+        {
+          runId: sessionRunId,
+          blockId: params.blockId,
+          kind: "action.failed",
+          payload: {
+            attempt: current.attempt || 1,
+            executionId: timelineExecutionId,
+            ...current.executionStartedAt ? { durationMs: Math.max(0, checkedAt - current.executionStartedAt) } : {},
+            error: {
+              message: error.message,
+              ...error.code ? { code: error.code } : {}
+            }
+          },
+          idempotencyKey: createRunEventIdempotencyKey("action.failed", sessionRunId, params.blockId, timelineExecutionId, "readback"),
+          ts: checkedAt
+        },
+        runtime,
+        params.blockId,
+        now
+      );
+    }
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: "failed",
+      output: finalOutput,
+      events,
+      error: error.message,
+      runId: executionId2,
+      executionId: executionId2,
+      pendingInvocationRemoved: false,
+      readBack: failedReadBack
+    };
+  }
+  const readBackActionType = readBack.actionType || readBack.kind;
+  const actionDef = readBackActionType ? getAction(readBackActionType) : void 0;
+  if (actionDef) {
+    const proofCheck = validateActionProof(actionDef, mergedOutput);
+    if (!proofCheck.valid) {
+      const message = proofCheck.reason || "Read-back resolved completed without proof of execution.";
+      const proofFailedReadBack = {
+        ...nextReadBack,
+        terminalAt: checkedIso
+      };
+      runtime.update(params.blockId, {
+        state: actionDef.sideEffect ? "needs_verification" : "failed",
+        output: finalOutput,
+        error: { message, code: PROOF_MISSING_CODE, at: checkedAt },
+        readBack: proofFailedReadBack
+      });
+      const failedExecutionId = writeReconciliationRunRecord({
+        yDoc,
+        editor: getReconcileEditor(params, yDoc, editor),
+        sessionRunId,
+        blockId: params.blockId,
+        actorDid,
+        output: finalOutput,
+        events,
+        readBack: proofFailedReadBack,
+        error: { message, code: PROOF_MISSING_CODE },
+        now
+      });
+      if (sessionRunId && eventLog) {
+        const timelineExecutionId = current.executionId || failedExecutionId || readBack.requestedAt || `readback-${checkedAt}`;
+        await appendReadBackTimeline(
+          eventLog,
+          {
+            runId: sessionRunId,
+            blockId: params.blockId,
+            kind: "action.failed",
+            payload: {
+              attempt: current.attempt || 1,
+              executionId: timelineExecutionId,
+              ...current.executionStartedAt ? { durationMs: Math.max(0, checkedAt - current.executionStartedAt) } : {},
+              error: { message, code: PROOF_MISSING_CODE }
+            },
+            idempotencyKey: createRunEventIdempotencyKey("action.failed", sessionRunId, params.blockId, timelineExecutionId, "readback"),
+            ts: checkedAt
+          },
+          runtime,
+          params.blockId,
+          now
+        );
+      }
+      return {
+        success: false,
+        blockId: params.blockId,
+        state: "failed",
+        output: finalOutput,
+        events,
+        error: message,
+        runId: failedExecutionId,
+        executionId: failedExecutionId,
+        pendingInvocationRemoved: false,
+        readBack: proofFailedReadBack
+      };
+    }
+  }
+  if (boundedOutput.exceeded) {
+    const message = `Read-back output exceeded the ${MAX_RUN_ACTION_OUTPUT_BYTES / 1024} KiB run-head limit.`;
+    const oversizedReadBack = {
+      ...nextReadBack,
+      terminalAt: checkedIso
+    };
+    runtime.update(params.blockId, {
+      state: actionDef?.sideEffect === false ? "failed" : "needs_verification",
+      output: finalOutput,
+      error: {
+        message,
+        code: "RUN_OUTPUT_TOO_LARGE",
+        at: checkedAt,
+        data: { byteLength: boundedOutput.byteLength }
+      },
+      readBack: oversizedReadBack
+    });
+    const oversizedExecutionId = writeReconciliationRunRecord({
+      yDoc,
+      editor: getReconcileEditor(params, yDoc, editor),
+      sessionRunId,
+      blockId: params.blockId,
+      actorDid,
+      output: finalOutput,
+      events,
+      readBack: oversizedReadBack,
+      error: { message, code: "RUN_OUTPUT_TOO_LARGE" },
+      now
+    });
+    if (sessionRunId && eventLog) {
+      const attempt = current.attempt || 1;
+      const timelineExecutionId = current.executionId || oversizedExecutionId || readBack.requestedAt || `readback-${checkedAt}`;
+      await appendRunTimelineEvents({
+        eventLog,
+        events: [
+          {
+            runId: sessionRunId,
+            blockId: params.blockId,
+            kind: "action.output",
+            payload: {
+              attempt,
+              executionId: timelineExecutionId,
+              output: boundRunEventJson(finalOutput)
+            },
+            idempotencyKey: createRunEventIdempotencyKey("action.output", sessionRunId, params.blockId, timelineExecutionId, "readback"),
+            ts: checkedAt
+          },
+          {
+            runId: sessionRunId,
+            blockId: params.blockId,
+            kind: "action.failed",
+            payload: {
+              attempt,
+              executionId: timelineExecutionId,
+              ...current.executionStartedAt ? {
+                durationMs: Math.max(0, checkedAt - current.executionStartedAt)
+              } : {},
+              error: {
+                message,
+                code: "RUN_OUTPUT_TOO_LARGE",
+                details: {
+                  byteLength: boundedOutput.byteLength,
+                  maxBytes: MAX_RUN_ACTION_OUTPUT_BYTES
+                }
+              }
+            },
+            idempotencyKey: createRunEventIdempotencyKey("action.failed", sessionRunId, params.blockId, timelineExecutionId, "readback"),
+            ts: checkedAt
+          }
+        ],
+        runtime,
+        blockId: params.blockId,
+        now
+      });
+    }
+    return {
+      success: false,
+      blockId: params.blockId,
+      state: "failed",
+      output: finalOutput,
+      events,
+      error: message,
+      runId: oversizedExecutionId,
+      executionId: oversizedExecutionId,
+      pendingInvocationRemoved: false,
+      readBack: oversizedReadBack
+    };
+  }
+  const completedReadBack = {
+    ...nextReadBack,
+    terminalAt: checkedIso
+  };
+  runtime.update(params.blockId, {
+    state: "completed",
+    output: finalOutput,
+    executedAt: checkedAt,
+    error: void 0,
+    readBack: completedReadBack
+  });
+  const executionId = writeReconciliationRunRecord({
+    yDoc,
+    editor: getReconcileEditor(params, yDoc, editor),
+    sessionRunId,
+    blockId: params.blockId,
+    actorDid,
+    output: finalOutput,
+    events,
+    readBack: completedReadBack,
+    now
+  });
+  let timelineComplete = true;
+  if (sessionRunId && eventLog) {
+    const attempt = current.attempt || 1;
+    const timelineExecutionId = current.executionId || executionId || readBack.requestedAt || `readback-${checkedAt}`;
+    const timelineResult = await appendRunTimelineEvents({
+      eventLog,
+      events: [
+        {
+          runId: sessionRunId,
+          blockId: params.blockId,
+          kind: "action.output",
+          payload: {
+            attempt,
+            executionId: timelineExecutionId,
+            output: boundRunEventJson(finalOutput)
+          },
+          idempotencyKey: createRunEventIdempotencyKey("action.output", sessionRunId, params.blockId, timelineExecutionId, "readback"),
+          ts: checkedAt
+        },
+        {
+          runId: sessionRunId,
+          blockId: params.blockId,
+          kind: "action.done",
+          payload: {
+            attempt,
+            executionId: timelineExecutionId,
+            ...current.executionStartedAt ? {
+              durationMs: Math.max(0, checkedAt - current.executionStartedAt)
+            } : {}
+          },
+          idempotencyKey: createRunEventIdempotencyKey("action.done", sessionRunId, params.blockId, timelineExecutionId, "readback"),
+          ts: checkedAt
+        }
+      ],
+      runtime,
+      blockId: params.blockId,
+      now
+    });
+    timelineComplete = timelineResult.ok && timelineResult.remaining === 0;
+  }
+  const pendingInvocationRemoved = timelineComplete && Boolean(yDoc && completedReadBack.pendingInvocation?.id) && removePendingInvocation(yDoc, params.blockId, completedReadBack.pendingInvocation.id, sessionRunId);
+  return {
+    success: timelineComplete,
+    blockId: params.blockId,
+    state: "completed",
+    output: finalOutput,
+    events,
+    ...!timelineComplete ? { error: "Canonical run history replay remains incomplete." } : {},
+    runId: executionId,
+    executionId,
+    pendingInvocationRemoved,
+    readBack: completedReadBack
+  };
+}
+
+// src/core/lib/flowEngine/actionExecutor.ts
+var COMPACT_TIMELINE_ACTION_TYPES = new Set(DESIGN_POD_METHODS["design-yoma/v1"].operationalActions);
+function buildActionTimelineInput(actionType, inputs, inputDigest) {
+  if (actionType.startsWith("qi/blueprint.") || COMPACT_TIMELINE_ACTION_TYPES.has(actionType)) return { inputDigest };
+  return inputs;
+}
+function isYDoc2(value) {
+  return isYDocLike(value);
+}
+function getYDoc2(editorOrYDoc) {
+  if (!editorOrYDoc) return void 0;
+  if (isYDoc2(editorOrYDoc)) return editorOrYDoc;
+  return editorOrYDoc._yDoc;
+}
+function parseInputs2(value) {
+  if (value == null || value === "") return {};
+  if (typeof value === "object" && !Array.isArray(value)) return { ...value };
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    warnOnce(`executor-inputs-parse:${value}`, `[flow-config] saved block inputs are not valid JSON; treated as empty`);
+    return {};
+  }
+}
+function getRuntime2(editorOrYDoc, runtime, runId) {
+  if (runtime) return runtime;
+  const yDoc = getYDoc2(editorOrYDoc);
+  if (yDoc) {
+    return createRunScopedRuntimeManager(yDoc, resolveRunIdForExecution(yDoc, runId));
+  }
+  return createRuntimeStateManager(!isYDoc2(editorOrYDoc) ? editorOrYDoc : void 0);
+}
+function getEditor2(editorOrYDoc) {
+  return editorOrYDoc && !isYDoc2(editorOrYDoc) ? editorOrYDoc : void 0;
+}
+function findBlock(params) {
+  if (params.block) return params.block;
+  const blockId = params.blockId;
+  if (!blockId) return void 0;
+  const editor = getEditor2(params.editorOrYDoc);
+  const visit = (blocks) => {
+    for (const block of blocks) {
+      if (block?.id === blockId) return block;
+      const nested = block?.children;
+      if (Array.isArray(nested)) {
+        const found = visit(nested);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  };
+  return visit(params.document || editor?.document || []);
+}
+function getFlowMetadata(editor) {
+  const metadata = editor?.getFlowMetadata?.();
+  const flowId = metadata?.doc_id || "";
+  return {
+    flowId,
+    flowUri: flowId ? `ixo:flow:${flowId}` : "",
+    flowOwnerDid: editor?.getFlowOwnerDid?.() || metadata?.flowOwnerDid || "",
+    schemaVersion: metadata?.schema_version || "0.3"
+  };
+}
+function getPendingInvocation(yDoc, blockId, pendingInvocationId, sessionRunId) {
+  if (!pendingInvocationId) return void 0;
+  if (!yDoc) {
+    throw new Error(`Cannot load pending invocation "${pendingInvocationId}" without a Y.Doc`);
+  }
+  if (!blockId) {
+    throw new Error(`Cannot load pending invocation "${pendingInvocationId}" without a block id`);
+  }
+  const pending = readPendingInvocations(yDoc, blockId, sessionRunId).find((invocation) => invocation.id === pendingInvocationId);
+  if (!pending) {
+    throw new Error(`Pending invocation "${pendingInvocationId}" was not found for block "${blockId}"`);
+  }
+  return pending;
+}
+function getNodeOutput(runtime, nodeId) {
+  const state = runtime.get(nodeId);
+  const output = state.output;
+  return output && typeof output === "object" && !Array.isArray(output) ? output : void 0;
+}
+function buildActionRunInputs(params) {
+  const blockId = params.blockId || params.block?.id;
+  const yDoc = getYDoc2(params.editorOrYDoc);
+  const runtime = getRuntime2(params.editorOrYDoc, params.runtime, params.runId);
+  const savedInputs = parseInputs2(params.savedInputs ?? params.block?.props?.inputs);
+  const pendingInvocation = getPendingInvocation(yDoc, blockId, params.pendingInvocationId, params.runId);
+  const triggerContext = pendingInvocation ? {
+    payload: pendingInvocation.payload || {},
+    refSnapshots: pendingInvocation.refSnapshots || {}
+  } : void 0;
+  const mergedInputs = {
+    ...savedInputs,
+    ...pendingInvocation?.payload || {},
+    ...pendingInvocation?.refSnapshots || {},
+    ...params.runtimeInputs || {}
+  };
+  return {
+    inputs: resolveRuntimeRefs(mergedInputs, (nodeId) => getNodeOutput(runtime, nodeId), triggerContext),
+    savedInputs,
+    mergedInputs,
+    pendingInvocation,
+    triggerContext
+  };
+}
+function buildFailureResult(params) {
+  return {
+    success: false,
+    stage: params.stage,
+    blockId: params.blockId,
+    actionType: params.actionType,
+    events: [],
+    error: params.error,
+    completionState: "failed",
+    pendingInvocation: params.pendingInvocation
+  };
+}
+function updateRuntimeFailure(runtime, blockId, message, now) {
+  runtime.update(blockId, {
+    state: "failed",
+    error: { message, at: now() }
+  });
+}
+function makeExecutionId2(now) {
+  return `run-${now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function getReconcileEditor2(params, yDoc, editor) {
+  if (editor) return editor;
+  if (!yDoc || !params.document) return void 0;
+  return {
+    _yDoc: yDoc,
+    _yRuntime: createRunRuntimeReaderWithDoc(yDoc, resolveRunIdForExecution(yDoc, params.runId)),
+    document: params.document
+  };
+}
+function persistEvents(params) {
+  if (!params.yDoc || params.events.length === 0) return void 0;
+  const details = {
+    runId: params.executionId,
+    sessionRunId: params.sessionRunId,
+    output: params.output,
+    events: params.events,
+    startedAt: new Date(params.startedAt).toISOString(),
+    completedAt: new Date(params.completedAt).toISOString(),
+    actorDid: params.actorDid,
+    invocationCid: params.invocationCid,
+    capabilityId: params.capabilityId
+  };
+  if (params.pendingInvocation) {
+    details.fromPendingInvocationId = params.pendingInvocation.id;
+    details.triggeredBy = {
+      sourceBlockId: params.pendingInvocation.triggeringBlockId,
+      eventName: params.pendingInvocation.eventName
+    };
+    details.sourceRunId = params.pendingInvocation.sourceRunId;
+  }
+  appendRunRecord(params.yDoc, params.blockId, details, params.actorDid);
+  if (params.editor) {
+    reconcilePendingInvocations(params.editor, params.sessionRunId);
+  }
+  return params.executionId;
+}
+function cleanupCompletedPendingInvocation(yDoc, blockId, pendingInvocation, sessionRunId) {
+  if (!yDoc || !pendingInvocation) return false;
+  return removePendingInvocation(yDoc, blockId, pendingInvocation.id, sessionRunId || pendingInvocation.sessionRunId);
+}
+async function executeActionBlock(params) {
+  const block = findBlock(params);
+  const blockId = params.blockId || block?.id;
+  const editor = getEditor2(params.editorOrYDoc);
+  const yDoc = getYDoc2(params.editorOrYDoc);
+  const now = params.now || Date.now;
+  const eventLog = params.runEventLog || editor?._runEventLog;
+  if (!block || !blockId) {
+    return buildFailureResult({
+      blockId: blockId || "",
+      stage: "input",
+      error: blockId ? `Block "${blockId}" was not found` : "executeActionBlock requires a blockId or block"
+    });
+  }
+  let sessionRunId = params.runId;
+  try {
+    if (yDoc) {
+      sessionRunId = resolveRunIdForExecution(yDoc, params.runId);
+      assertRunActionExecutionAllowed(yDoc, sessionRunId, block);
+    }
+  } catch (error) {
+    return buildFailureResult({
+      blockId,
+      stage: "input",
+      error: error instanceof Error ? error.message : "The requested session run cannot execute this action."
+    });
+  }
+  const runtime = getRuntime2(params.editorOrYDoc, params.runtime, sessionRunId);
+  const actionType = typeof block.props?.actionType === "string" ? block.props.actionType : void 0;
+  if (!actionType) {
+    updateRuntimeFailure(runtime, blockId, "Action block is missing props.actionType", now);
+    return buildFailureResult({
+      blockId,
+      stage: "input",
+      error: "Action block is missing props.actionType"
+    });
+  }
+  const action = getAction(actionType);
+  if (!action) {
+    const message = `No registered action found for ${actionType}`;
+    updateRuntimeFailure(runtime, blockId, message, now);
+    return buildFailureResult({ blockId, actionType, stage: "action_lookup", error: message });
+  }
+  if (yDoc && sessionRunId) {
+    const document = params.document || editor?.document || [block];
+    let eligibility;
+    try {
+      eligibility = evaluateBlockExecutionEligibilityForRun(parseConditionConfigStrict(block.props?.conditions), document, yDoc, sessionRunId);
+    } catch (error) {
+      return buildFailureResult({
+        blockId,
+        actionType,
+        stage: "input",
+        error: error instanceof Error ? error.message : "Block conditions are invalid."
+      });
+    }
+    if (!eligibility.eligible) {
+      return buildFailureResult({
+        blockId,
+        actionType,
+        stage: "input",
+        error: eligibility.message || "Block conditions are not satisfied."
+      });
+    }
+  }
+  let inputBuild;
+  try {
+    inputBuild = buildActionRunInputs({ ...params, block, blockId, runtime });
+    if (actionType.startsWith("qi/blueprint.") && !["qi/blueprint.workspace-start", "qi/blueprint.journey-resume", "qi/blueprint.guided-authoring", "qi/blueprint.phase-confirm"].includes(actionType)) {
+      const authority = params.designPodAuthority;
+      if (!authority || !sessionRunId || authority.sessionRunId !== sessionRunId) {
+        throw new Error("Portal-owned Design Project entity, Flow room, and session authority are required");
+      }
+      if (!yDoc) throw new Error("Portal-native Design POD actions require the active Flow Y.Doc");
+      const manifest = readDesignPodDefinition(yDoc);
+      const state = readDesignPodState(yDoc);
+      const registeredManifest = manifest && DESIGN_POD_METHODS[manifest.methodId];
+      if (!manifest || !state || !registeredManifest || canonicalDesignPodJson(manifest) !== canonicalDesignPodJson(registeredManifest)) {
+        throw new Error("The active Design POD method is not the registered Portal method");
+      }
+      inputBuild.inputs = {
+        ...inputBuild.inputs,
+        designProjectEntityDid: authority.designProjectEntityDid,
+        flowRoomId: authority.flowRoomId,
+        sessionRunId: authority.sessionRunId,
+        methodManifestDigest: await digestDesignPodValue(registeredManifest)
+      };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to build action inputs";
+    updateRuntimeFailure(runtime, blockId, message, now);
+    return buildFailureResult({ blockId, actionType, stage: "input", error: message });
+  }
+  const flowNode = buildFlowNodeFromBlock(block);
+  const metadata = getFlowMetadata(editor);
+  const flowId = params.designPodAuthority?.flowRoomId || params.flowId || metadata.flowId || blockId;
+  const flowUri = params.designPodAuthority ? `ixo:flow:${params.designPodAuthority.flowRoomId}` : params.flowUri || metadata.flowUri || `ixo:flow:${flowId}`;
+  const flowOwnerDid = params.designPodAuthority?.flowOwnerDid || params.flowOwnerDid || metadata.flowOwnerDid;
+  const schemaVersion = params.schemaVersion || metadata.schemaVersion;
+  if (actionType === "qi/flow.run.close" && yDoc && sessionRunId) {
+    const document = params.document || editor?.document || [block];
+    inputBuild.inputs = {
+      ...inputBuild.inputs,
+      // Bind the exact completion projection into the signed invocation. The
+      // lifecycle re-computes it before append and rejects any Matrix event
+      // whose payload differs from these signed inputs.
+      terminalSummary: computeRunSummary(yDoc, sessionRunId, buildRunDefinitionSnapshot(document).actionTypes, {
+        flowId: flowUri,
+        actorDid: params.actorDid,
+        now: now()
+      })
+    };
+  }
+  const events = [];
+  let completionState = "completed";
+  let readBack;
+  let rawReadBack;
+  let requestedAwaitingReadBack = false;
+  let proofFailureReason = null;
+  let proofFailureOutput;
+  let topicRecords = [];
+  let terminalRaceError = null;
+  const startedAt = now();
+  const previousState = runtime.get(blockId);
+  const attempt = (previousState.attempt || 0) + 1;
+  const executionId = makeExecutionId2(now);
+  const inputDigest = await digestDesignPodValue(inputBuild.inputs);
+  const invocationFacts = {
+    actionType,
+    inputDigest,
+    ...sessionRunId ? { sessionRunId } : {}
+  };
+  const recordTopicPhase = async (status, options = {}) => {
+    if (!params.topic || !params.topicBridge) return void 0;
+    try {
+      return await params.topicBridge.recordFlowPhase({
+        topic: params.topic,
+        actionType,
+        actorDid: params.actorDid,
+        executorDid: params.executorDid || params.actorDid,
+        executionId,
+        status,
+        input: inputBuild.inputs,
+        output: options.output,
+        semanticRecords: topicRecords,
+        flowUri,
+        sessionRunId,
+        nodeId: blockId,
+        invocationReference: options.invocationReference,
+        traceReference: sessionRunId ? `${flowUri}/session/${sessionRunId}/execution/${executionId}` : `${flowUri}/execution/${executionId}`,
+        error: options.error
+      });
+    } catch (error) {
+      return { state: "queued", error: error instanceof Error ? error.message : "Topic receipt bridge failed" };
+    }
+  };
+  const timelineRequired = !!yDoc && !usesLegacyRuntimeCompatibility(yDoc);
+  if (sessionRunId && (eventLog || timelineRequired)) {
+    const startedLogged = await appendRunTimelineEvent({
+      eventLog,
+      event: {
+        runId: sessionRunId,
+        blockId,
+        kind: "action.started",
+        payload: {
+          attempt,
+          executionId,
+          input: boundRunEventJson(buildActionTimelineInput(actionType, inputBuild.inputs, inputDigest))
+        },
+        idempotencyKey: createRunEventIdempotencyKey("action.started", sessionRunId, blockId, executionId),
+        ts: startedAt
+      },
+      runtime,
+      blockId,
+      retainOnFailure: false,
+      now
+    });
+    if (!startedLogged.ok) {
+      const message = "Action was not executed because its run timeline could not be opened.";
+      runtime.update(blockId, {
+        state: "failed",
+        error: {
+          message,
+          code: "RUN_EVENT_APPEND_FAILED",
+          at: now(),
+          data: startedLogged.error
+        }
+      });
+      return {
+        ...buildFailureResult({ blockId, actionType, stage: "action", error: message, pendingInvocation: inputBuild.pendingInvocation }),
+        executionId,
+        runId: executionId
+      };
+    }
+  }
+  if (yDoc && sessionRunId) {
+    try {
+      assertRunActionExecutionAllowed(yDoc, sessionRunId, block);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "The requested session became terminal before this action could execute.";
+      return {
+        ...buildFailureResult({ blockId, actionType, stage: "action", error: message, pendingInvocation: inputBuild.pendingInvocation }),
+        executionId,
+        runId: executionId
+      };
+    }
+  }
+  runtime.update(blockId, {
+    state: "running",
+    output: void 0,
+    error: void 0,
+    executedByDid: params.actorDid,
+    attempt,
+    executionId,
+    executionStartedAt: startedAt
+  });
+  const runningWriteBack = await recordTopicPhase("running");
+  if (runningWriteBack?.state === "rejected") {
+    const message = runningWriteBack.error || "Topic Action execution was rejected by the receipt bridge.";
+    updateRuntimeFailure(runtime, blockId, message, now);
+    return {
+      ...buildFailureResult({ blockId, actionType, stage: "authorization", error: message, pendingInvocation: inputBuild.pendingInvocation }),
+      executionId,
+      runId: executionId,
+      topicWriteBack: runningWriteBack
+    };
+  }
+  const actionServices = action.type.startsWith("qi/topic.") ? params.services || {} : { ...params.services || {}, topic: void 0 };
+  const outcome = await executeNode({
+    node: flowNode,
+    actorDid: params.actorDid,
+    actorType: params.actorType,
+    entityRoomId: params.entityRoomId,
+    context: {
+      runtime,
+      ucanService: params.ucanService || editor?.getUcanService?.() || void 0,
+      invocationStore: params.invocationStore || editor?._invocationStore,
+      flowUri,
+      flowId,
+      sessionRunId,
+      flowOwnerDid,
+      schemaVersion,
+      now
+    },
+    invocationFacts,
+    requireSignedInvocation: action.requiresSignedInvocation === true,
+    action: async (executionProof) => {
+      if (yDoc && sessionRunId) {
+        try {
+          assertRunActionExecutionAllowed(yDoc, sessionRunId, block);
+        } catch (error) {
+          terminalRaceError = error instanceof Error ? error.message : "The requested session became terminal before this action could execute.";
+          throw error;
+        }
+      }
+      const result = await action.run(inputBuild.inputs, {
+        actorDid: params.actorDid,
+        flowId,
+        sessionRunId,
+        designPodAuthority: params.designPodAuthority,
+        flowUri,
+        nodeId: blockId,
+        flowNode,
+        runtime,
+        services: actionServices,
+        runEventLog: params.runEventLog,
+        handlers: params.handlers,
+        editor,
+        yDoc,
+        pendingInvocation: inputBuild.pendingInvocation,
+        topic: params.topic,
+        flowRevision: params.flowRevision,
+        ...executionProof.invocationCid ? {
+          executionProof: {
+            invocationCid: executionProof.invocationCid,
+            invocation: executionProof.invocation,
+            capabilityId: executionProof.capabilityId,
+            proofCids: executionProof.proofCids,
+            capability: executionProof.capability,
+            facts: executionProof.facts,
+            inputDigest
+          }
+        } : {}
+      });
+      if (result.events?.length) events.push(...result.events);
+      if (result.topicRecords?.length) topicRecords = result.topicRecords;
+      if (result.completion?.state === "awaiting_readback") {
+        requestedAwaitingReadBack = true;
+        rawReadBack = result.completion.readBack;
+      } else {
+        const proofCheck = validateActionProof(action, result.output || {});
+        if (!proofCheck.valid) {
+          proofFailureReason = proofCheck.reason || "Action returned success without proof of execution.";
+          proofFailureOutput = result.output || {};
+          throw new Error(proofFailureReason);
+        }
+      }
+      return {
+        payload: result.output,
+        submittedByDid: params.actorDid || void 0
+      };
+    },
+    pin: params.pin || ""
+  });
+  if (!outcome.success) {
+    const message = outcome.error || "Action execution failed";
+    if (terminalRaceError) {
+      return {
+        ...buildFailureResult({ blockId, actionType, stage: outcome.stage, error: terminalRaceError, pendingInvocation: inputBuild.pendingInvocation }),
+        invocationCid: outcome.invocationCid,
+        capabilityId: outcome.capabilityId,
+        executionId,
+        runId: executionId
+      };
+    }
+    if (proofFailureReason) {
+      const proofFailureState = action.sideEffect ? "needs_verification" : "failed";
+      const boundedProofFailure = boundRunActionOutput(proofFailureOutput || {});
+      runtime.update(blockId, {
+        state: proofFailureState,
+        output: boundedProofFailure.output,
+        error: { message, code: PROOF_MISSING_CODE, at: now() }
+      });
+      if (sessionRunId && (eventLog || timelineRequired)) {
+        await appendRunTimelineEvent({
+          eventLog,
+          event: {
+            runId: sessionRunId,
+            blockId,
+            kind: "action.failed",
+            payload: {
+              attempt,
+              executionId,
+              durationMs: Math.max(0, now() - startedAt),
+              error: { message, code: PROOF_MISSING_CODE }
+            },
+            idempotencyKey: createRunEventIdempotencyKey("action.failed", sessionRunId, blockId, executionId),
+            ts: now()
+          },
+          runtime,
+          blockId,
+          now
+        });
+      }
+      return {
+        ...buildFailureResult({
+          blockId,
+          actionType,
+          stage: outcome.stage,
+          error: message,
+          pendingInvocation: inputBuild.pendingInvocation
+        }),
+        completionState: proofFailureState === "needs_verification" ? "needs_verification" : "failed",
+        output: proofFailureOutput,
+        invocationCid: outcome.invocationCid,
+        capabilityId: outcome.capabilityId,
+        executionId,
+        runId: executionId,
+        topicWriteBack: await recordTopicPhase(proofFailureState === "needs_verification" ? "needs_verification" : "failed", {
+          output: proofFailureOutput,
+          error: { code: PROOF_MISSING_CODE, message },
+          invocationReference: outcome.invocationCid || outcome.capabilityId
+        })
+      };
+    }
+    if (outcome.stage === "authorization") {
+      runtime.update(blockId, {
+        state: previousState.state,
+        output: previousState.output,
+        error: previousState.error,
+        executedByDid: previousState.executedByDid,
+        attempt: previousState.attempt,
+        executionId: previousState.executionId,
+        executionStartedAt: previousState.executionStartedAt
+      });
+      return {
+        ...buildFailureResult({
+          blockId,
+          actionType,
+          stage: outcome.stage,
+          error: message,
+          pendingInvocation: inputBuild.pendingInvocation
+        }),
+        invocationCid: outcome.invocationCid,
+        capabilityId: outcome.capabilityId,
+        executionId,
+        runId: executionId
+      };
+    }
+    updateRuntimeFailure(runtime, blockId, message, now);
+    if (sessionRunId && (eventLog || timelineRequired)) {
+      await appendRunTimelineEvent({
+        eventLog,
+        event: {
+          runId: sessionRunId,
+          blockId,
+          kind: "action.failed",
+          payload: {
+            attempt,
+            executionId,
+            durationMs: Math.max(0, now() - startedAt),
+            error: { message }
+          },
+          idempotencyKey: createRunEventIdempotencyKey("action.failed", sessionRunId, blockId, executionId),
+          ts: now()
+        },
+        runtime,
+        blockId,
+        now
+      });
+    }
+    const topicWriteBack2 = await recordTopicPhase("failed", {
+      error: { message },
+      invocationReference: outcome.invocationCid || outcome.capabilityId
+    });
+    return {
+      ...buildFailureResult({
+        blockId,
+        actionType,
+        stage: outcome.stage,
+        error: message,
+        pendingInvocation: inputBuild.pendingInvocation
+      }),
+      invocationCid: outcome.invocationCid,
+      capabilityId: outcome.capabilityId,
+      executionId,
+      runId: executionId,
+      topicWriteBack: topicWriteBack2
+    };
+  }
+  const output = outcome.result?.payload || {};
+  const boundedOutput = boundRunActionOutput(output);
+  const completedAt = now();
+  if (requestedAwaitingReadBack) {
+    completionState = "awaiting_readback";
+    readBack = normalizeActionReadBackMetadata({
+      readBack: rawReadBack,
+      blockId,
+      actionType,
+      actorDid: params.actorDid,
+      invocationCid: outcome.invocationCid,
+      capabilityId: outcome.capabilityId,
+      requestedAt: startedAt,
+      pendingInvocation: inputBuild.pendingInvocation
+    });
+  }
+  if (boundedOutput.exceeded) {
+    completionState = action.sideEffect ? "needs_verification" : "failed";
+  }
+  runtime.update(blockId, {
+    state: completionState,
+    output: boundedOutput.output,
+    executedByDid: params.actorDid,
+    executedAt: completedAt,
+    lastInvocationCid: outcome.invocationCid || outcome.capabilityId,
+    readBack,
+    ...boundedOutput.exceeded ? {
+      error: {
+        message: `Action output exceeded the ${MAX_RUN_ACTION_OUTPUT_BYTES / 1024} KiB run-head limit.`,
+        code: "RUN_OUTPUT_TOO_LARGE",
+        at: completedAt,
+        data: { byteLength: boundedOutput.byteLength }
+      }
+    } : { error: void 0 }
+  });
+  persistEvents({
+    yDoc,
+    editor: getReconcileEditor2(params, yDoc, editor),
+    sessionRunId,
+    blockId,
+    actorDid: params.actorDid,
+    output: boundedOutput.output,
+    events,
+    invocationCid: outcome.invocationCid,
+    capabilityId: outcome.capabilityId,
+    pendingInvocation: inputBuild.pendingInvocation,
+    startedAt,
+    completedAt,
+    now,
+    executionId
+  });
+  if (sessionRunId && (eventLog || timelineRequired)) {
+    const timelineEvents = [
+      {
+        runId: sessionRunId,
+        blockId,
+        kind: "action.output",
+        payload: {
+          attempt,
+          executionId,
+          output: boundRunEventJson(boundedOutput.output)
+        },
+        idempotencyKey: createRunEventIdempotencyKey("action.output", sessionRunId, blockId, executionId, 1),
+        ts: completedAt
+      }
+    ];
+    if (completionState === "completed") {
+      timelineEvents.push({
+        runId: sessionRunId,
+        blockId,
+        kind: "action.done",
+        payload: {
+          attempt,
+          executionId,
+          durationMs: Math.max(0, completedAt - startedAt)
+        },
+        idempotencyKey: createRunEventIdempotencyKey("action.done", sessionRunId, blockId, executionId),
+        ts: completedAt
+      });
+    } else if (boundedOutput.exceeded) {
+      timelineEvents.push({
+        runId: sessionRunId,
+        blockId,
+        kind: "action.failed",
+        payload: {
+          attempt,
+          executionId,
+          durationMs: Math.max(0, completedAt - startedAt),
+          error: {
+            message: `Action output exceeded the ${MAX_RUN_ACTION_OUTPUT_BYTES / 1024} KiB run-head limit.`,
+            code: "RUN_OUTPUT_TOO_LARGE",
+            details: {
+              byteLength: boundedOutput.byteLength,
+              maxBytes: MAX_RUN_ACTION_OUTPUT_BYTES
+            }
+          }
+        },
+        idempotencyKey: createRunEventIdempotencyKey("action.failed", sessionRunId, blockId, executionId),
+        ts: completedAt
+      });
+    }
+    await appendRunTimelineEvents({
+      eventLog,
+      events: timelineEvents,
+      runtime,
+      blockId,
+      now
+    });
+  }
+  const pendingInvocationRemoved = completionState === "completed" ? cleanupCompletedPendingInvocation(yDoc, blockId, inputBuild.pendingInvocation, sessionRunId) : false;
+  const topicWriteBack = await recordTopicPhase(completionState === "completed" ? "succeeded" : completionState === "needs_verification" ? "needs_verification" : "failed", {
+    output,
+    ...boundedOutput.exceeded ? { error: { code: "RUN_OUTPUT_TOO_LARGE", message: `Action output exceeded the ${MAX_RUN_ACTION_OUTPUT_BYTES / 1024} KiB run-head limit.` } } : {},
+    invocationReference: outcome.invocationCid || outcome.capabilityId
+  });
+  return {
+    success: !boundedOutput.exceeded,
+    stage: outcome.stage,
+    blockId,
+    actionType,
+    output,
+    ...boundedOutput.exceeded ? {
+      error: `Action output exceeded the ${MAX_RUN_ACTION_OUTPUT_BYTES / 1024} KiB run-head limit.`
+    } : {},
+    events,
+    invocationCid: outcome.invocationCid,
+    capabilityId: outcome.capabilityId,
+    // Both names, same value — see the field docs on ExecuteActionBlockResult.
+    runId: executionId,
+    executionId,
+    pendingInvocationRemoved,
+    completionState,
+    pendingInvocation: inputBuild.pendingInvocation,
+    topicWriteBack
+  };
+}
+
+// src/core/lib/flowEngine/verifiedCompletion.ts
+var RUN_PROJECTIONS_MAP_KEY = "qi.flow.runProjections";
+function runLedgerAttestations(yDoc) {
+  let index = null;
+  const build = () => {
+    const found = /* @__PURE__ */ new Map();
+    if (!yDoc) return found;
+    const projections = yDoc.getMap(RUN_PROJECTIONS_MAP_KEY);
+    projections.forEach((raw) => {
+      const projection = raw;
+      if (!projection || typeof projection !== "object") return;
+      const runId = typeof projection.runId === "string" ? projection.runId : void 0;
+      const attempts = projection.attempts;
+      if (!attempts || typeof attempts !== "object") return;
+      for (const [attemptId, value] of Object.entries(attempts)) {
+        const attempt = value;
+        if (!attempt || typeof attempt !== "object") continue;
+        const existing = found.get(attemptId);
+        if (existing?.disposition === "succeeded") continue;
+        found.set(attemptId, {
+          attemptId,
+          ...runId ? { runId } : {},
+          ...typeof attempt.stepId === "string" ? { stepId: attempt.stepId } : {},
+          ...typeof attempt.disposition === "string" ? { disposition: attempt.disposition } : {}
+        });
+      }
+    });
+    return found;
+  };
+  return (attemptId) => (index ?? (index = build())).get(attemptId);
+}
+function verifyCompletion(params) {
+  const { runtime, blockId, actionType, getInvocation, getRunAttestation, schemaVersion } = params;
+  if (!runtime || runtime.state !== "completed") {
+    return { status: "not_completed" };
+  }
+  if (runtime.manuallyVerified === true) {
+    return { status: "verified" };
+  }
+  if (actionType) {
+    const action = getAction(actionType);
+    if (action) {
+      const proofCheck = validateActionProof(action, runtime.output || {});
+      if (!proofCheck.valid) {
+        return { status: "unverified", reason: proofCheck.reason || "Completed without proof of execution." };
+      }
+    }
+  }
+  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
+  if (!policy?.ucanRequired) {
+    return { status: "verified" };
+  }
+  const attemptId = typeof runtime.attemptId === "string" ? runtime.attemptId : void 0;
+  const attestation = attemptId ? getRunAttestation?.(attemptId) : void 0;
+  if (attestation) {
+    if (attestation.disposition !== "succeeded") {
+      return {
+        status: "unverified",
+        reason: `The run ledger records attempt ${attemptId} as ${attestation.disposition ?? "unfinished"}, not succeeded.`
+      };
+    }
+    if (attestation.stepId && attestation.stepId !== blockId) {
+      return { status: "unverified", reason: "The run ledger records this attempt against a different block." };
+    }
+    return { status: "verified" };
+  }
+  const invocationCid = runtime.lastInvocationCid;
+  if (!invocationCid) {
+    return {
+      status: "unverified",
+      reason: attemptId ? `Completed with no invocation record and no run-ledger attestation for attempt ${attemptId}.` : "Completed without an invocation record on a UCAN-enforced flow."
+    };
+  }
+  if (!getInvocation) {
+    return { status: "unverified", reason: "No invocation store available to verify the completion." };
+  }
+  const invocation = getInvocation(invocationCid);
+  if (!invocation) {
+    return { status: "unverified", reason: `Invocation ${invocationCid} not found in the invocation store.` };
+  }
+  if (invocation.result !== "success") {
+    return { status: "unverified", reason: "Completion references a failed invocation." };
+  }
+  if (invocation.blockId && invocation.blockId !== blockId) {
+    return { status: "unverified", reason: "Completion references an invocation for a different block." };
+  }
+  return { status: "verified" };
+}
+function isVerifiedCompletion(params) {
+  return verifyCompletion(params).status === "verified";
+}
+
+// src/core/lib/invocationStore.ts
+var createInvocationStore = (yMap) => {
+  const add = (invocation) => {
+    yMap.set(invocation.cid, invocation);
+  };
+  const get = (cid) => {
+    const raw = yMap.get(cid);
+    if (!raw || typeof raw !== "object") return null;
+    return raw;
+  };
+  const remove = (cid) => {
+    yMap.delete(cid);
+  };
+  const getAll = () => {
+    const invocations = [];
+    yMap.forEach((value) => {
+      if (value && typeof value === "object" && "cid" in value) {
+        invocations.push(value);
+      }
+    });
+    return invocations.sort((a, b) => b.executedAt - a.executedAt);
+  };
+  const getByInvoker = (invokerDid) => {
+    return getAll().filter((i) => i.invokerDid === invokerDid);
+  };
+  const getByFlow = (flowId) => {
+    return getAll().filter((i) => i.flowId === flowId);
+  };
+  const getByBlock = (flowId, blockId) => {
+    return getAll().filter((i) => i.flowId === flowId && i.blockId === blockId);
+  };
+  const getByCapability = (can, withUri) => {
+    return getAll().filter((i) => i.capability.can === can && i.capability.with === withUri);
+  };
+  const hasBeenInvoked = (cid) => {
+    return yMap.has(cid);
+  };
+  const getInDateRange = (startMs, endMs) => {
+    return getAll().filter((i) => i.executedAt >= startMs && i.executedAt <= endMs);
+  };
+  const getSuccessful = () => {
+    return getAll().filter((i) => i.result === "success");
+  };
+  const getFailures = () => {
+    return getAll().filter((i) => i.result === "failure");
+  };
+  const getPendingSubmission = () => {
+    return getAll().filter((i) => i.result === "success" && !i.transactionHash);
+  };
+  const markSubmitted = (cid, transactionHash) => {
+    const invocation = get(cid);
+    if (invocation) {
+      const updated = {
+        ...invocation,
+        transactionHash
+      };
+      yMap.set(cid, updated);
+    }
+  };
+  const getCount = () => {
+    return getAll().length;
+  };
+  const getCountByResult = () => {
+    const all = getAll();
+    return {
+      success: all.filter((i) => i.result === "success").length,
+      failure: all.filter((i) => i.result === "failure").length
+    };
+  };
+  return {
+    add,
+    get,
+    remove,
+    getAll,
+    getByInvoker,
+    getByFlow,
+    getByBlock,
+    getByCapability,
+    hasBeenInvoked,
+    getInDateRange,
+    getSuccessful,
+    getFailures,
+    getPendingSubmission,
+    markSubmitted,
+    getCount,
+    getCountByResult
+  };
+};
+var createMemoryInvocationStore = () => {
+  const store = /* @__PURE__ */ new Map();
+  const add = (invocation) => {
+    store.set(invocation.cid, invocation);
+  };
+  const get = (cid) => {
+    return store.get(cid) || null;
+  };
+  const remove = (cid) => {
+    store.delete(cid);
+  };
+  const getAll = () => {
+    const invocations = Array.from(store.values());
+    return invocations.sort((a, b) => b.executedAt - a.executedAt);
+  };
+  const getByInvoker = (invokerDid) => {
+    return getAll().filter((i) => i.invokerDid === invokerDid);
+  };
+  const getByFlow = (flowId) => {
+    return getAll().filter((i) => i.flowId === flowId);
+  };
+  const getByBlock = (flowId, blockId) => {
+    return getAll().filter((i) => i.flowId === flowId && i.blockId === blockId);
+  };
+  const getByCapability = (can, withUri) => {
+    return getAll().filter((i) => i.capability.can === can && i.capability.with === withUri);
+  };
+  const hasBeenInvoked = (cid) => {
+    return store.has(cid);
+  };
+  const getInDateRange = (startMs, endMs) => {
+    return getAll().filter((i) => i.executedAt >= startMs && i.executedAt <= endMs);
+  };
+  const getSuccessful = () => {
+    return getAll().filter((i) => i.result === "success");
+  };
+  const getFailures = () => {
+    return getAll().filter((i) => i.result === "failure");
+  };
+  const getPendingSubmission = () => {
+    return getAll().filter((i) => i.result === "success" && !i.transactionHash);
+  };
+  const markSubmitted = (cid, transactionHash) => {
+    const invocation = get(cid);
+    if (invocation) {
+      store.set(cid, { ...invocation, transactionHash });
+    }
+  };
+  const getCount = () => {
+    return store.size;
+  };
+  const getCountByResult = () => {
+    const all = getAll();
+    return {
+      success: all.filter((i) => i.result === "success").length,
+      failure: all.filter((i) => i.result === "failure").length
+    };
+  };
+  return {
+    add,
+    get,
+    remove,
+    getAll,
+    getByInvoker,
+    getByFlow,
+    getByBlock,
+    getByCapability,
+    hasBeenInvoked,
+    getInDateRange,
+    getSuccessful,
+    getFailures,
+    getPendingSubmission,
+    markSubmitted,
+    getCount,
+    getCountByResult
+  };
+};
+
+// src/core/lib/flowEngine/blockPhase.ts
+function deriveBlockPhase(params) {
+  const { runtime, actionType, pendingInvocationCount = 0, runCount, done = false } = params;
+  const repeatable = isRepeatableAction(actionType);
+  const state = runtime?.state ?? "idle";
+  const base = { repeatable, ...repeatable && runCount !== void 0 ? { runCount } : {} };
+  switch (state) {
+    case "idle":
+      if (pendingInvocationCount > 0) {
+        return { ...base, phase: "active", detail: "queued", safeToRetry: true };
+      }
+      return { ...base, phase: "pending", detail: "idle", safeToRetry: true };
+    case "running":
+      return { ...base, phase: "active", detail: "running", safeToRetry: false };
+    case "pending":
+      return { ...base, phase: "active", detail: "pending", safeToRetry: false };
+    case "retry_scheduled":
+      return { ...base, phase: "active", detail: "retry_scheduled", safeToRetry: false };
+    case "awaiting_readback":
+      return { ...base, phase: "active", detail: "awaiting_readback", safeToRetry: false };
+    case "awaiting_human":
+      return { ...base, phase: "failed", detail: "awaiting_human", safeToRetry: false };
+    case "completed":
+      if (repeatable) {
+        if (done && pendingInvocationCount === 0) {
+          return { ...base, phase: "complete", detail: "drained", safeToRetry: true };
+        }
+        return { ...base, phase: "active", detail: "standing", safeToRetry: true };
+      }
+      return { ...base, phase: "complete", detail: "completed", safeToRetry: false };
+    case "cancelled":
+      return { ...base, phase: "complete", detail: "cancelled", safeToRetry: false };
+    case "failed":
+      return { ...base, phase: "failed", detail: "failed", safeToRetry: true };
+    case "needs_verification":
+      return { ...base, phase: "failed", detail: "needs_verification", safeToRetry: false };
+    default:
+      return { ...base, phase: "failed", detail: "needs_verification", safeToRetry: false };
+  }
+}
+function countSuccessfulRuns(yDoc, blockId) {
+  return readRunRecords(yDoc, blockId).filter((record) => !record.error).length;
+}
+
+// src/core/lib/flowEngine/validateBlockConfig.ts
+function validateBlockConfig(block) {
+  const issues = [];
+  if (!block?.props) return issues;
+  const checkJson = (propName, value, expectObject = true) => {
+    if (value == null || value === "") return;
+    if (typeof value !== "string") return;
+    try {
+      const parsed = JSON.parse(value);
+      if (expectObject && (parsed == null || typeof parsed !== "object")) {
+        issues.push(`${propName} is valid JSON but not an object`);
+      }
+    } catch {
+      issues.push(`${propName} is not valid JSON`);
+    }
+  };
+  checkJson("inputs", block.props.inputs);
+  checkJson("trigger", block.props.trigger);
+  checkJson("assignment", block.props.assignment);
+  checkJson("conditions", block.props.conditions);
+  return issues;
+}
+
+// src/core/lib/flowEngine/migration.ts
+var MIGRATION_REGISTRY = {};
+function registerMigration(definition) {
+  const key = `${definition.from}->${definition.to}`;
+  MIGRATION_REGISTRY[key] = definition;
+}
+
+// src/core/lib/flowEngine/migrations/v0_3_to_v1_0_0.ts
+var NON_EXECUTABLE_BLOCK_TYPES = /* @__PURE__ */ new Set(["paragraph", "heading", "bulletListItem", "numberedListItem", "image", "table"]);
+function hasDelegationForBlock(ctx, blockId) {
+  const delegations = ctx.ucanService.getAllDelegations();
+  const resourceUri = `${ctx.flowUri}:${blockId}`;
+  return delegations.some((d) => d.capabilities.some((c) => c.can === "flow/block/execute" && c.with === resourceUri));
+}
+var migration_0_3_to_1_0_0 = {
+  from: "0.3",
+  to: "1.0.0",
+  preconditions: [
+    {
+      id: "has_flow_owner",
+      description: "Flow must have a flowOwnerDid set",
+      check: (ctx) => {
+        const ownerDid = ctx.editor.getFlowOwnerDid?.() || ctx.flowOwnerDid;
+        return !!ownerDid;
+      },
+      blocking: true
+    },
+    {
+      id: "is_owner",
+      description: "Only the flow owner can initiate migration",
+      check: (ctx) => {
+        const ownerDid = ctx.editor.getFlowOwnerDid?.() || ctx.flowOwnerDid;
+        return ctx.actorDid === ownerDid;
+      },
+      blocking: true
+    },
+    {
+      id: "ucan_service_available",
+      description: "UCAN service must be configured",
+      check: (ctx) => {
+        return !!ctx.ucanService && ctx.ucanService.isConfigured();
+      },
+      blocking: true
+    }
+  ],
+  async analyze(ctx) {
+    const items = [];
+    const blocks = ctx.editor.document;
+    const rootDelegation = ctx.ucanService.getRootDelegation();
+    if (!rootDelegation) {
+      items.push({
+        id: "__root_delegation__",
+        nodeId: "",
+        type: "create_root_delegation",
+        status: "pending",
+        requiresUserAction: true,
+        description: "Create root delegation for flow owner"
+      });
+    }
+    if (blocks) {
+      for (const block of blocks) {
+        if (NON_EXECUTABLE_BLOCK_TYPES.has(block.type)) continue;
+        if (!hasDelegationForBlock(ctx, block.id)) {
+          items.push({
+            id: `node_delegation_${block.id}`,
+            nodeId: block.id,
+            type: "create_node_delegation",
+            status: "pending",
+            requiresUserAction: true,
+            description: `Create delegation for block "${block.type}" (${block.id})`
+          });
+        }
+      }
+    }
+    return items;
+  },
+  async executeItem(ctx, item) {
+    try {
+      switch (item.type) {
+        case "create_root_delegation": {
+          await ctx.ucanService.createRootDelegation({
+            flowOwnerDid: ctx.flowOwnerDid,
+            issuerType: ctx.actorType,
+            entityRoomId: ctx.entityRoomId,
+            flowUri: ctx.flowUri,
+            pin: ctx.pin
+          });
+          return { success: true };
+        }
+        case "create_node_delegation":
+        case "backfill_capability": {
+          const capability = {
+            can: "flow/block/execute",
+            with: `${ctx.flowUri}:${item.nodeId}`
+          };
+          await ctx.ucanService.createDelegation({
+            issuerDid: ctx.flowOwnerDid,
+            issuerType: ctx.actorType,
+            entityRoomId: ctx.entityRoomId,
+            audience: ctx.flowOwnerDid,
+            // Owner delegates to self initially; actors get sub-delegations
+            capabilities: [capability],
+            pin: ctx.pin
+          });
+          return { success: true };
+        }
+        default:
+          return { success: false, error: `Unknown work item type: ${item.type}` };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, error: message };
+    }
+  },
+  async postValidate(ctx) {
+    const errors = [];
+    const blocks = ctx.editor.document;
+    const rootDelegation = ctx.ucanService.getRootDelegation();
+    if (!rootDelegation) {
+      errors.push("Root delegation is missing after migration");
+    }
+    if (blocks) {
+      for (const block of blocks) {
+        if (NON_EXECUTABLE_BLOCK_TYPES.has(block.type)) continue;
+        const requiredCapability = {
+          can: "flow/block/execute",
+          with: `${ctx.flowUri}:${block.id}`
+        };
+        const validation = await ctx.ucanService.validateDelegationChain(ctx.flowOwnerDid, requiredCapability);
+        if (!validation.valid) {
+          errors.push(`Block "${block.type}" (${block.id}): delegation chain invalid \u2014 ${validation.error || "unknown error"}`);
+        }
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  finalize(ctx) {
+    const root = ctx.editor._yRoot;
+    if (!root) {
+      throw new Error("Cannot finalize: editor _yRoot not available");
+    }
+    root.set("schema_version", "1.0.0");
+    root.set("@context", "https://ixo.world/flow/1.0");
+  }
+};
+registerMigration(migration_0_3_to_1_0_0);
+
+export {
+  isRuntimeRef,
+  RUN_RECORD_AUDIT_TYPE,
+  computePendingInvocationId,
+  snapshotInputRefs,
+  getPendingInvocationsMap,
+  countPendingInvocations,
+  getOrCreateBlockPendingMap,
+  readPendingInvocations,
+  queuePendingInvocation,
+  removePendingInvocation,
+  appendRunRecord,
+  readRunRecords,
+  findFailedListenersForSourceRun,
+  replayFailedListenerRun,
+  VERSION_MANIFEST,
+  LATEST_VERSION,
+  getVersionPolicy,
+  isVersionAtLeast,
+  reconcilePendingInvocations,
+  dispatchFlowStartTriggers,
+  getActionForBlock,
+  writeRunRecordAndReconcile,
+  resolveEditorYDoc,
+  createRuntimeStateManager,
+  createYDocRuntimeManager,
+  clearRuntimeForTemplateClone,
+  normalizeCondition,
+  normalizeConditions,
+  parseConditionConfig,
+  InvalidConditionConfigError,
+  parseConditionConfigStrict,
+  resolveConditionSourceValue,
+  evaluateCondition,
+  evaluateBlockConditions,
+  evaluateBlockConditionsForRun,
+  evaluateBlockExecutionEligibilityForRun,
+  buildAuthzFromProps,
+  buildFlowNodeFromBlock,
+  PROOF_MISSING_CODE,
+  validateActionProof,
+  isActionDone,
+  isActionTypeDone,
+  reconcileCompletion,
+  reconcileCheckableCompletions,
+  createIntentHash,
+  parseJsonProp,
+  getBlockActionType,
+  getBlockTitle,
+  getBlockType,
+  getBlockProps,
+  getBlockId,
+  getAssigneeDid,
+  getDueAt,
+  capabilityForCommand,
+  getFlowAgentMaps,
+  computeAgentCommandId,
+  queueAgentCommand,
+  readAgentCommands,
+  readQueuedAgentCommands,
+  readFlowAgentLeases,
+  updateAgentCommand,
+  appendAgentLedgerEvent,
+  readAgentLedgerEvents,
+  RunLifecycleAuthorizationError,
+  RunNotReadyError,
+  FlowNotMigratedError,
+  RunNotMigratedError,
+  computeRunDefinitionHash,
+  toRunJsonValue,
+  buildRunDefinitionSnapshot,
+  createRunUlid,
+  createRunId,
+  listRuns,
+  listOpenRuns,
+  setAdvisoryActiveRunId,
+  startRun,
+  migrateFlowToSessions,
+  computeRunSummary,
+  closeRun,
+  cancelRun,
+  detectRunDefinitionDrift,
+  recordRunDefinitionDrift,
+  readRunActionStates,
+  resolveRuntimeRefs,
+  isAuthorized,
+  executeNode,
+  normalizeActionReadBackMetadata,
+  reconcileActionReadBack,
+  buildActionRunInputs,
+  executeActionBlock,
+  runLedgerAttestations,
+  verifyCompletion,
+  isVerifiedCompletion,
+  deriveBlockPhase,
+  countSuccessfulRuns,
+  validateBlockConfig,
+  createInvocationStore,
+  createMemoryInvocationStore
+};
+//# sourceMappingURL=chunk-HRRI4BLF.js.map