@ixo/editor 6.33.0 → 6.35.0

package/dist/chunk-RRYBAE6E.js

@@ -0,0 +1,2449 @@
+import {
+  verifyActionManifestV2
+} from "./chunk-N3ORMGAI.js";
+import {
+  isYMapLike
+} from "./chunk-NCSGIRRQ.js";
+
+// src/core/lib/flowEngine/vnext/legacy.ts
+var LegacyFlowFrozenError = class extends Error {
+  constructor(operation) {
+    super(`Legacy Flow operation ${operation} is frozen; explicitly republish authored meaning as a new vNext revision`);
+    this.operation = operation;
+    this.name = "LegacyFlowFrozenError";
+  }
+};
+function assertLegacyFlowOperationAllowed(gate, operation) {
+  if (gate?.legacyMode === "read_only") throw new LegacyFlowFrozenError(operation);
+}
+
+// src/core/lib/flowEngine/vnext/canonical.ts
+function deepFreezeJson(value) {
+  if (!value || typeof value !== "object") return value;
+  for (const nested of Object.values(value)) deepFreezeJson(nested);
+  return Object.freeze(value);
+}
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertValidUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit >= 55296 && codeUnit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) {
+        throw new TypeError("Canonical JSON contains an unpaired Unicode surrogate");
+      }
+      index += 1;
+    } else if (codeUnit >= 56320 && codeUnit <= 57343) {
+      throw new TypeError("Canonical JSON contains an unpaired Unicode surrogate");
+    }
+  }
+}
+function canonicalizeJson(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const serialize = (candidate) => {
+    if (candidate === null || typeof candidate === "boolean") return JSON.stringify(candidate);
+    if (typeof candidate === "string") {
+      assertValidUnicode(candidate);
+      return JSON.stringify(candidate);
+    }
+    if (typeof candidate === "number") {
+      if (!Number.isFinite(candidate)) throw new TypeError("Canonical JSON numbers must be finite");
+      return JSON.stringify(candidate);
+    }
+    if (typeof candidate !== "object") {
+      throw new TypeError(`Canonical JSON contains a non-JSON value: ${typeof candidate}`);
+    }
+    if (ancestors.has(candidate)) throw new TypeError("Canonical JSON contains a circular reference");
+    ancestors.add(candidate);
+    try {
+      if (Array.isArray(candidate)) return `[${candidate.map((entry) => serialize(entry)).join(",")}]`;
+      if (!isPlainObject(candidate)) throw new TypeError("Canonical JSON contains a non-plain object");
+      return `{${Object.keys(candidate).sort().map((key) => {
+        assertValidUnicode(key);
+        return `${JSON.stringify(key)}:${serialize(candidate[key])}`;
+      }).join(",")}}`;
+    } finally {
+      ancestors.delete(candidate);
+    }
+  };
+  return serialize(value);
+}
+async function digestCanonicalJson(value) {
+  if (!globalThis.crypto?.subtle) throw new Error("Web Crypto is required to digest a Flow contract");
+  const bytes = new TextEncoder().encode(canonicalizeJson(value));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `sha256:${hex}`;
+}
+
+// src/core/lib/flowEngine/vnext/contracts.ts
+var FlowDefinitionVerificationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FlowDefinitionVerificationError";
+  }
+};
+var DEFINITION_SIGNATURE_DOMAIN = "qi.flow.definition.v1\0";
+var EXECUTION_POLICY_SIGNATURE_DOMAIN = "qi.flow.execution-policy.v1\0";
+function asCanonical(value) {
+  return value;
+}
+function signatureInput(digest) {
+  return new TextEncoder().encode(`${DEFINITION_SIGNATURE_DOMAIN}${digest}`);
+}
+function policySignatureInput(digest) {
+  return new TextEncoder().encode(`${EXECUTION_POLICY_SIGNATURE_DOMAIN}${digest}`);
+}
+function assertExecutionPolicyPayload(payload) {
+  if (payload.kind !== "qi.flow.execution-policy" || payload.schemaVersion !== "1.0") throw new Error("Unsupported Flow execution policy");
+  if (payload.mode !== "enabled" && payload.mode !== "pause_new_effects") throw new Error("Unsupported Flow execution policy mode");
+  if (!payload.definition.digest || !payload.issuedBy || !payload.issuedAt) throw new Error("Execution policy identity, issuer, and timestamp are required");
+  if (payload.expiresAt && Date.parse(payload.expiresAt) <= Date.parse(payload.issuedAt)) throw new Error("Execution policy expiry must be after issuance");
+}
+async function computeExecutionPolicyDigest(payload) {
+  assertExecutionPolicyPayload(payload);
+  return await digestCanonicalJson(asCanonical(payload));
+}
+async function signExecutionPolicy(payload, signer) {
+  const snapshot = JSON.parse(canonicalizeJson(asCanonical(payload)));
+  assertExecutionPolicyPayload(snapshot);
+  if (signer.issuerDid !== snapshot.issuedBy || !signer.verificationMethod.startsWith(`${snapshot.issuedBy}#`)) {
+    throw new Error("Execution policy signer does not match the issuer");
+  }
+  const digest = await computeExecutionPolicyDigest(snapshot);
+  const signature = await signer.sign(policySignatureInput(digest));
+  if (!signature) throw new Error("Execution policy signer returned an empty signature");
+  return {
+    ...snapshot,
+    integrity: {
+      canonicalization: "RFC8785",
+      digest: { algorithm: "SHA-256", value: digest },
+      signature: { algorithm: signer.algorithm, verificationMethod: signer.verificationMethod, value: signature }
+    }
+  };
+}
+async function verifyExecutionPolicy(candidate, policy, now = /* @__PURE__ */ new Date()) {
+  const snapshot = JSON.parse(canonicalizeJson(asCanonical(candidate)));
+  const { integrity, ...payload } = snapshot;
+  assertExecutionPolicyPayload(payload);
+  const digest = await computeExecutionPolicyDigest(payload);
+  if (digest !== integrity.digest.value) throw new Error("Execution policy digest does not match its content");
+  if (!policy.trustedIssuerDids.includes(payload.issuedBy)) throw new Error(`Execution policy issuer is not trusted: ${payload.issuedBy}`);
+  if (policy.revokedIssuerDids?.includes(payload.issuedBy)) throw new Error(`Execution policy issuer is revoked: ${payload.issuedBy}`);
+  if (!policy.allowedSignatureAlgorithms.includes(integrity.signature.algorithm))
+    throw new Error(`Execution policy signature algorithm is not allowed: ${integrity.signature.algorithm}`);
+  if (!integrity.signature.verificationMethod.startsWith(`${payload.issuedBy}#`)) throw new Error("Execution policy verification method does not belong to the issuer");
+  if (payload.expiresAt && Date.parse(payload.expiresAt) <= now.getTime()) throw new Error("Execution policy is expired");
+  const valid = await policy.verifySignature({
+    issuerDid: payload.issuedBy,
+    verificationMethod: integrity.signature.verificationMethod,
+    algorithm: integrity.signature.algorithm,
+    data: policySignatureInput(digest),
+    signature: integrity.signature.value
+  });
+  if (!valid) throw new Error("Execution policy signature verification failed");
+  return deepFreezeJson(snapshot);
+}
+function assertDefinitionPayload(payload) {
+  if (payload.kind !== "qi.flow.definition-revision" || payload.schemaVersion !== "1.0") {
+    throw new FlowDefinitionVerificationError("INVALID_DEFINITION", "Unsupported Flow definition contract");
+  }
+  if (!payload.ref.flowId || !payload.ref.revision || !payload.publishedBy || payload.steps.length === 0) {
+    throw new FlowDefinitionVerificationError("INVALID_DEFINITION", "Flow definition identity, publisher, and steps are required");
+  }
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const step of payload.steps) {
+    if (!step.stepId || !step.blockId || !step.action.contractDigest || !step.action.manifestDigest) {
+      throw new FlowDefinitionVerificationError("INVALID_DEFINITION", "Every Flow step must pin its identity and Action contract");
+    }
+    if (step.action.manifestDigest !== payload.actionManifestDigest) {
+      throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Flow step ${step.stepId} does not use the revision Action manifest`);
+    }
+    if (stepIds.has(step.stepId)) throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Duplicate Flow step id: ${step.stepId}`);
+    if (step.trigger.kind === "schedule") {
+      if (!step.trigger.scheduleRef || step.trigger.scheduleRevision !== void 0 && (!Number.isInteger(step.trigger.scheduleRevision) || step.trigger.scheduleRevision < 1)) {
+        throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Flow step ${step.stepId} has an invalid schedule binding`);
+      }
+    }
+    if (step.trigger.kind === "topic.request" && !step.trigger.requestKind.trim()) {
+      throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Flow step ${step.stepId} has an invalid Topic request kind`);
+    }
+    if (step.ttlMs !== void 0 && (!Number.isFinite(step.ttlMs) || step.ttlMs < 0)) {
+      throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Flow step ${step.stepId} has an invalid ttlMs`);
+    }
+    if (step.ttl?.absoluteDueDate && !Number.isFinite(Date.parse(step.ttl.absoluteDueDate))) {
+      throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Flow step ${step.stepId} has an invalid absolute TTL`);
+    }
+    for (const duration of [step.ttl?.fromEnablement, step.ttl?.fromCommitment]) {
+      const match = duration ? /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?)?$/u.exec(duration) : void 0;
+      if (duration && (!match || !match.slice(1).some((part) => Number(part ?? 0) > 0))) {
+        throw new FlowDefinitionVerificationError("INVALID_DEFINITION", `Flow step ${step.stepId} has an invalid relative TTL`);
+      }
+    }
+    stepIds.add(step.stepId);
+  }
+}
+async function computeFlowDefinitionDigest(payload) {
+  assertDefinitionPayload(payload);
+  return await digestCanonicalJson(asCanonical(payload));
+}
+async function signFlowDefinitionRevision(payload, signer) {
+  const snapshot = JSON.parse(canonicalizeJson(asCanonical(payload)));
+  assertDefinitionPayload(snapshot);
+  if (signer.issuerDid !== snapshot.publishedBy || !signer.verificationMethod.startsWith(`${snapshot.publishedBy}#`)) {
+    throw new FlowDefinitionVerificationError("SIGNER_MISMATCH", "Flow definition signer does not match the publisher");
+  }
+  const digest = await computeFlowDefinitionDigest(snapshot);
+  const signature = await signer.sign(signatureInput(digest));
+  if (!signature) throw new FlowDefinitionVerificationError("INVALID_SIGNATURE", "Flow definition signer returned an empty signature");
+  return {
+    ...snapshot,
+    integrity: {
+      canonicalization: "RFC8785",
+      digest: { algorithm: "SHA-256", value: digest },
+      signature: { algorithm: signer.algorithm, verificationMethod: signer.verificationMethod, value: signature }
+    }
+  };
+}
+async function verifyFlowDefinitionRevision(candidate, policy) {
+  const snapshot = JSON.parse(canonicalizeJson(asCanonical(candidate)));
+  const { integrity, ...payload } = snapshot;
+  assertDefinitionPayload(payload);
+  const digest = await computeFlowDefinitionDigest(payload);
+  if (digest !== integrity.digest.value) throw new FlowDefinitionVerificationError("DIGEST_MISMATCH", "Flow definition digest does not match its content");
+  if (!policy.trustedIssuerDids.includes(payload.publishedBy)) {
+    throw new FlowDefinitionVerificationError("UNTRUSTED_ISSUER", `Flow definition issuer is not trusted: ${payload.publishedBy}`);
+  }
+  if (policy.revokedIssuerDids?.includes(payload.publishedBy)) {
+    throw new FlowDefinitionVerificationError("REVOKED_ISSUER", `Flow definition issuer is revoked: ${payload.publishedBy}`);
+  }
+  if (!policy.allowedSignatureAlgorithms.includes(integrity.signature.algorithm)) {
+    throw new FlowDefinitionVerificationError("DISALLOWED_SIGNATURE_ALGORITHM", `Flow definition signature algorithm is not allowed: ${integrity.signature.algorithm}`);
+  }
+  if (!integrity.signature.verificationMethod.startsWith(`${payload.publishedBy}#`)) {
+    throw new FlowDefinitionVerificationError("SIGNER_MISMATCH", "Flow definition verification method does not belong to the publisher");
+  }
+  const verified = await policy.verifySignature({
+    issuerDid: payload.publishedBy,
+    verificationMethod: integrity.signature.verificationMethod,
+    algorithm: integrity.signature.algorithm,
+    data: signatureInput(digest),
+    signature: integrity.signature.value
+  });
+  if (!verified) throw new FlowDefinitionVerificationError("INVALID_SIGNATURE", "Flow definition signature verification failed");
+  return deepFreezeJson(snapshot);
+}
+var FLOW_CAPABILITIES = {
+  definitionRead: "flow/definition.read",
+  definitionWrite: "flow/definition.write",
+  definitionPublish: "flow/definition.publish",
+  definitionClone: "flow/definition.clone",
+  runStart: "flow/run.start",
+  runClose: "flow/run.close",
+  runCancel: "flow/run.cancel",
+  actionExecute: "flow/action.execute",
+  topicBindFlow: "topic/bind-flow",
+  topicRequestAction: "topic/request-action",
+  topicRecordAction: "topic/record-action"
+};
+function segment(value) {
+  return encodeURIComponent(value);
+}
+function buildFlowResourceUri(definition, target) {
+  const root = `ixo:flow:${segment(definition.flowId)}@${segment(definition.revision)}`;
+  if (!target) return root;
+  if (target.kind === "run") return `${root}/runs/${segment(target.runId)}`;
+  const run = target.runId ? `/runs/${segment(target.runId)}` : "";
+  return `${root}${run}/steps/${segment(target.stepId)}`;
+}
+
+// src/core/lib/flowEngine/vnext/ids.ts
+async function deriveId(namespace, parts) {
+  const digest = await digestCanonicalJson({ namespace, parts });
+  return `${namespace}:${digest.slice("sha256:".length)}`;
+}
+function deriveRunId(definition, launchKind, launchNonce) {
+  return deriveId("run", [definition.digest, launchKind, launchNonce]);
+}
+function deriveAttemptId(params) {
+  return deriveId("attempt", [params.runId, params.stepId, params.idempotencyKey, params.inputDigest]);
+}
+function deriveEventId(unsignedEvent) {
+  return deriveId("event", unsignedEvent);
+}
+function deriveReceiptId(params) {
+  return deriveId("receipt", [params.topicRequestId, params.attemptId, params.phase, params.eventId]);
+}
+function deriveEffectClaimKey(params) {
+  return digestCanonicalJson([
+    params.definition.digest,
+    params.runId,
+    params.stepId,
+    params.attemptId,
+    params.actorDid,
+    params.inputDigest,
+    params.action.contractDigest,
+    params.topicBindingId ?? null
+  ]);
+}
+
+// src/core/lib/flowEngine/vnext/events.ts
+var EVENT_SIGNATURE_DOMAIN = "qi.flow.event.v1\0";
+var FlowEventValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FlowEventValidationError";
+  }
+};
+function signatureInput2(eventId) {
+  return new TextEncoder().encode(`${EVENT_SIGNATURE_DOMAIN}${eventId}`);
+}
+function flowEventSnapshot(value) {
+  let snapshot;
+  try {
+    snapshot = JSON.parse(canonicalizeJson(value));
+  } catch {
+    throw new FlowEventValidationError("Flow event content cannot be canonicalized");
+  }
+  if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) throw new FlowEventValidationError("Flow event envelope is malformed");
+  return snapshot;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function hasDefinitionRefShape(value) {
+  return isRecord(value) && typeof value.flowId === "string" && typeof value.revision === "string" && typeof value.digest === "string";
+}
+function hasAttemptShape(payload) {
+  return typeof payload.attemptId === "string" && typeof payload.stepId === "string";
+}
+function assertVerifiedEnvelopeShape(snapshot) {
+  if (snapshot.kind !== "qi.flow.event" || snapshot.schemaVersion !== "1.0" || typeof snapshot.eventId !== "string" || typeof snapshot.runId !== "string" || !hasDefinitionRefShape(snapshot.definition) || typeof snapshot.producer !== "string" || typeof snapshot.actor !== "string" || typeof snapshot.occurredAt !== "string" || !isStringArray(snapshot.parents) || snapshot.causationId !== void 0 && typeof snapshot.causationId !== "string" || typeof snapshot.correlationId !== "string" || typeof snapshot.idempotencyKey !== "string" || typeof snapshot.commandFingerprint !== "string" || !isStringArray(snapshot.proofReferences) || !isRecord(snapshot.signature) || typeof snapshot.signature.algorithm !== "string" || typeof snapshot.signature.verificationMethod !== "string" || typeof snapshot.signature.value !== "string" || !isRecord(snapshot.payload) || typeof snapshot.payload.kind !== "string") {
+    throw new FlowEventValidationError("Flow event envelope is malformed");
+  }
+  const payload = snapshot.payload;
+  switch (payload.kind) {
+    case "run.started": {
+      const genesis = payload.genesis;
+      if (!isRecord(genesis) || genesis.kind !== "qi.flow.run-genesis" || genesis.schemaVersion !== "1.0" || typeof genesis.runId !== "string" || !hasDefinitionRefShape(genesis.definition) || !["manual", "topic.request", "schedule", "event"].includes(String(genesis.launchKind)) || typeof genesis.launchNonce !== "string" || !isStringArray(genesis.requiredStepIds) || typeof genesis.startedBy !== "string" || typeof genesis.startedAt !== "string" || genesis.topicBindingId !== void 0 && typeof genesis.topicBindingId !== "string") {
+        throw new FlowEventValidationError("Flow run genesis is malformed");
+      }
+      break;
+    }
+    case "run.cancel_requested":
+      if (payload.reason !== void 0 && typeof payload.reason !== "string") throw new FlowEventValidationError("Flow cancellation reason is malformed");
+      break;
+    case "action.requested":
+      if (!hasAttemptShape(payload) || typeof payload.inputDigest !== "string") throw new FlowEventValidationError("Flow Action request is malformed");
+      break;
+    case "action.approval_proposed":
+      if (!hasAttemptShape(payload) || typeof payload.proposalDigest !== "string") throw new FlowEventValidationError("Flow Action approval proposal is malformed");
+      break;
+    case "action.started":
+      if (!hasAttemptShape(payload)) throw new FlowEventValidationError("Flow Action start is malformed");
+      break;
+    case "action.effect_armed":
+      if (!hasAttemptShape(payload) || typeof payload.claimKey !== "string" || !Number.isSafeInteger(payload.fencingEpoch) || Number(payload.fencingEpoch) < 1) {
+        throw new FlowEventValidationError("Flow Action fence is malformed");
+      }
+      break;
+    case "action.succeeded":
+      if (!hasAttemptShape(payload) || typeof payload.outputDigest !== "string" || payload.providerCorrelation !== void 0 && typeof payload.providerCorrelation !== "string" || payload.claimKey !== void 0 && typeof payload.claimKey !== "string" || payload.fencingEpoch !== void 0 && (!Number.isSafeInteger(payload.fencingEpoch) || Number(payload.fencingEpoch) < 1) || payload.outcomes !== void 0 && !Array.isArray(payload.outcomes)) {
+        throw new FlowEventValidationError("Flow Action success is malformed");
+      }
+      break;
+    case "action.outcome_emitted":
+      if (!hasAttemptShape(payload)) throw new FlowEventValidationError("Flow Action outcome is malformed");
+      break;
+    case "action.failed_before_effect":
+      if (!hasAttemptShape(payload) || !isRecord(payload.error)) throw new FlowEventValidationError("Flow Action failure is malformed");
+      break;
+    case "action.needs_verification":
+      if (!hasAttemptShape(payload) || typeof payload.reason !== "string" || payload.providerCorrelation !== void 0 && typeof payload.providerCorrelation !== "string") {
+        throw new FlowEventValidationError("Flow Action verification state is malformed");
+      }
+      break;
+    case "receipt.persisted":
+      if (typeof payload.attemptId !== "string" || typeof payload.receiptId !== "string" || typeof payload.receiptDigest !== "string") {
+        throw new FlowEventValidationError("Flow receipt evidence is malformed");
+      }
+      break;
+    case "run.finalized": {
+      const summary = payload.summary;
+      if (!["completed", "failed", "cancelled"].includes(String(payload.status)) || !isRecord(summary) || summary.kind !== "qi.flow.run-finalization-summary" || summary.schemaVersion !== "1.0" || summary.status !== payload.status || typeof summary.cancelRequested !== "boolean" || !isStringArray(summary.requiredStepIds) || !isStringArray(summary.frontierEventIds) || !Array.isArray(summary.attempts) || !summary.attempts.every(
+        (attempt) => isRecord(attempt) && typeof attempt.attemptId === "string" && typeof attempt.stepId === "string" && ["not_started", "armed", "succeeded", "failed_before_effect", "needs_verification"].includes(String(attempt.disposition)) && isStringArray(attempt.receiptIds)
+      ) || typeof payload.summaryDigest !== "string") {
+        throw new FlowEventValidationError("Flow run finalization is malformed");
+      }
+      break;
+    }
+    case "log":
+      if (!["debug", "info", "warn", "error"].includes(String(payload.level)) || typeof payload.message !== "string") {
+        throw new FlowEventValidationError("Flow log event is malformed");
+      }
+      break;
+    default:
+      throw new FlowEventValidationError(`Unsupported Flow event payload: ${String(payload.kind)}`);
+  }
+}
+async function signFlowEvent(unsigned, signer) {
+  const snapshot = flowEventSnapshot(unsigned);
+  const { eventId: _eventId, signature: _signature, ...unsignedSnapshot } = snapshot;
+  if (unsignedSnapshot.producer !== signer.producerDid || !signer.verificationMethod.startsWith(`${unsignedSnapshot.producer}#`)) {
+    throw new Error("Flow event signer does not match the producer");
+  }
+  const eventId = await deriveEventId(unsignedSnapshot);
+  const signature = await signer.sign(signatureInput2(eventId));
+  if (!signature) throw new Error("Flow event signer returned an empty signature");
+  return {
+    ...unsignedSnapshot,
+    eventId,
+    signature: { algorithm: signer.algorithm, verificationMethod: signer.verificationMethod, value: signature }
+  };
+}
+async function verifyFlowEvent(event, policy) {
+  const snapshot = flowEventSnapshot(event);
+  assertVerifiedEnvelopeShape(snapshot);
+  const { eventId, signature, ...unsigned } = snapshot;
+  const expectedId = await deriveEventId(unsigned);
+  if (expectedId !== eventId) throw new FlowEventValidationError("Flow event content does not match its event id");
+  const outcomes = snapshot.payload.kind === "action.succeeded" ? snapshot.payload.outcomes ?? [] : snapshot.payload.kind === "action.outcome_emitted" ? [snapshot.payload] : [];
+  const seenOutcomes = /* @__PURE__ */ new Set();
+  for (const outcome of outcomes) {
+    if (typeof outcome.name !== "string" || !outcome.name.trim()) throw new FlowEventValidationError("Flow event outcome name is required");
+    if (!outcome.payload || typeof outcome.payload !== "object" || Array.isArray(outcome.payload) || typeof outcome.payloadDigest !== "string") {
+      throw new FlowEventValidationError(`Flow event outcome payload is malformed: ${outcome.name}`);
+    }
+    const actualDigest = await digestCanonicalJson(outcome.payload);
+    if (actualDigest !== outcome.payloadDigest) throw new FlowEventValidationError(`Flow event outcome payload digest mismatch: ${outcome.name}`);
+    const identity = `${outcome.name}\0${outcome.payloadDigest}`;
+    if (seenOutcomes.has(identity)) throw new FlowEventValidationError(`Flow event contains a duplicate outcome: ${outcome.name}`);
+    seenOutcomes.add(identity);
+  }
+  if (snapshot.payload.kind === "run.finalized") {
+    if (!snapshot.payload.summary || typeof snapshot.payload.summary !== "object" || Array.isArray(snapshot.payload.summary)) {
+      throw new FlowEventValidationError("Flow run finalization summary is malformed");
+    }
+    const actualDigest = await digestCanonicalJson(snapshot.payload.summary);
+    if (actualDigest !== snapshot.payload.summaryDigest) throw new FlowEventValidationError("Flow run finalization summary digest mismatch");
+  }
+  if (!signature.verificationMethod.startsWith(`${snapshot.producer}#`)) throw new FlowEventValidationError("Flow event verification method does not belong to the producer");
+  if (!policy.allowedSignatureAlgorithms.includes(signature.algorithm)) {
+    throw new FlowEventValidationError(`Flow event signature algorithm is not allowed: ${signature.algorithm}`);
+  }
+  if (!await policy.isTrustedProducer(snapshot.producer, signature.verificationMethod)) {
+    throw new FlowEventValidationError(`Flow event producer is not trusted: ${snapshot.producer}`);
+  }
+  if (!await policy.verifySignature({
+    producerDid: snapshot.producer,
+    verificationMethod: signature.verificationMethod,
+    algorithm: signature.algorithm,
+    data: signatureInput2(eventId),
+    signature: signature.value
+  })) {
+    throw new FlowEventValidationError("Flow event signature verification failed");
+  }
+  return deepFreezeJson(snapshot);
+}
+function matrixFlowEventTransactionId(event) {
+  return `qi-flow-v1-${event.eventId}`;
+}
+function eventHasAncestor(event, ancestor, byId, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(event.eventId)) return false;
+  seen.add(event.eventId);
+  for (const parent of event.parents) {
+    if (parent === ancestor) return true;
+    const parentEvent = byId.get(parent);
+    if (parentEvent && eventHasAncestor(parentEvent, ancestor, byId, seen)) return true;
+  }
+  return false;
+}
+function causalOrder(events, byId) {
+  const indegree = new Map(events.map((event) => [event.eventId, 0]));
+  const children = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    for (const parent of event.parents) {
+      if (!byId.has(parent)) continue;
+      indegree.set(event.eventId, (indegree.get(event.eventId) ?? 0) + 1);
+      children.set(parent, [...children.get(parent) ?? [], event.eventId]);
+    }
+  }
+  const ready = events.filter((event) => indegree.get(event.eventId) === 0).map((event) => event.eventId).sort();
+  const ordered = [];
+  while (ready.length > 0) {
+    const eventId = ready.shift();
+    const event = byId.get(eventId);
+    if (!event) continue;
+    ordered.push(event);
+    for (const childId of (children.get(eventId) ?? []).sort()) {
+      const next = (indegree.get(childId) ?? 0) - 1;
+      indegree.set(childId, next);
+      if (next === 0) {
+        ready.push(childId);
+        ready.sort();
+      }
+    }
+  }
+  const orderedIds = new Set(ordered.map((event) => event.eventId));
+  return { ordered, cyclic: new Set(events.filter((event) => !orderedIds.has(event.eventId)).map((event) => event.eventId)) };
+}
+function hasAcceptedAncestor(event, byId, accepted, predicate) {
+  const pending = [...event.parents];
+  const seen = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const eventId = pending.pop();
+    if (seen.has(eventId)) continue;
+    seen.add(eventId);
+    const candidate = byId.get(eventId);
+    if (!candidate || !accepted.has(eventId)) continue;
+    if (predicate(candidate)) return true;
+    pending.push(...candidate.parents);
+  }
+  return false;
+}
+function attemptChainError(event, byId, accepted) {
+  const payload = event.payload;
+  if (!("attemptId" in payload) || payload.kind === "action.requested") return void 0;
+  if (payload.kind === "receipt.persisted") {
+    return hasAcceptedAncestor(event, byId, accepted, (candidate) => candidate.payload.kind === "action.succeeded" && candidate.payload.attemptId === payload.attemptId) ? void 0 : "missing_success_ancestor";
+  }
+  if (!("stepId" in payload)) return void 0;
+  const sameAttemptAndStep = (candidate) => {
+    const candidatePayload = candidate.payload;
+    return "attemptId" in candidatePayload && "stepId" in candidatePayload && candidatePayload.attemptId === payload.attemptId && candidatePayload.stepId === payload.stepId;
+  };
+  if (payload.kind === "action.outcome_emitted") {
+    return hasAcceptedAncestor(event, byId, accepted, (candidate) => {
+      if (!sameAttemptAndStep(candidate) || candidate.payload.kind !== "action.succeeded") return false;
+      return (candidate.payload.outcomes ?? []).some(
+        (outcome) => outcome.name === payload.name && outcome.payloadDigest === payload.payloadDigest && canonicalizeJson(outcome.payload) === canonicalizeJson(payload.payload)
+      );
+    }) ? void 0 : "missing_declaring_success_ancestor";
+  }
+  if (payload.kind === "action.started" || payload.kind === "action.effect_armed" || payload.kind === "action.approval_proposed") {
+    return hasAcceptedAncestor(event, byId, accepted, (candidate) => sameAttemptAndStep(candidate) && candidate.payload.kind === "action.requested") ? void 0 : "missing_request_ancestor";
+  }
+  if (payload.kind === "action.failed_before_effect") {
+    return hasAcceptedAncestor(event, byId, accepted, (candidate) => sameAttemptAndStep(candidate) && candidate.payload.kind === "action.started") ? void 0 : "missing_started_ancestor";
+  }
+  if (payload.kind === "action.succeeded") {
+    const hasStarted = hasAcceptedAncestor(event, byId, accepted, (candidate) => sameAttemptAndStep(candidate) && candidate.payload.kind === "action.started");
+    const hasArmed = hasAcceptedAncestor(event, byId, accepted, (candidate) => sameAttemptAndStep(candidate) && candidate.payload.kind === "action.effect_armed");
+    const hasClaimKey = payload.claimKey !== void 0;
+    const hasFencingEpoch = payload.fencingEpoch !== void 0;
+    if (hasClaimKey !== hasFencingEpoch) return "incomplete_fence_evidence";
+    if (hasClaimKey && hasFencingEpoch) {
+      return hasAcceptedAncestor(
+        event,
+        byId,
+        accepted,
+        (candidate) => sameAttemptAndStep(candidate) && candidate.payload.kind === "action.effect_armed" && candidate.payload.claimKey === payload.claimKey && candidate.payload.fencingEpoch === payload.fencingEpoch
+      ) ? void 0 : "missing_matching_fence_ancestor";
+    }
+    if (hasArmed && !hasStarted) return "missing_fence_evidence";
+    return hasStarted ? void 0 : "missing_execution_ancestor";
+  }
+  if (payload.kind === "action.needs_verification") {
+    return hasAcceptedAncestor(
+      event,
+      byId,
+      accepted,
+      (candidate) => sameAttemptAndStep(candidate) && (candidate.payload.kind === "action.started" || candidate.payload.kind === "action.effect_armed")
+    ) ? void 0 : "missing_execution_ancestor";
+  }
+  return void 0;
+}
+var DISPOSITION_RANK = {
+  not_started: 0,
+  armed: 1,
+  failed_before_effect: 2,
+  needs_verification: 3,
+  succeeded: 4
+};
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort(compareCodeUnits);
+}
+function sameStringSet(left, right) {
+  return canonicalizeJson(sortedUnique(left)) === canonicalizeJson(sortedUnique(right));
+}
+function acceptedFrontier(events, accepted) {
+  const acceptedEvents = events.filter((event) => accepted.has(event.eventId));
+  const referencedParents = new Set(acceptedEvents.flatMap((event) => event.parents.filter((parent) => accepted.has(parent))));
+  return acceptedEvents.map((event) => event.eventId).filter((eventId) => !referencedParents.has(eventId)).sort(compareCodeUnits);
+}
+function reduceFlowEvents(genesis, input) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const event of input) if (!unique.has(event.eventId)) unique.set(event.eventId, event);
+  const events = [...unique.values()];
+  const canonicalDefinition = canonicalizeJson(genesis.definition);
+  const belongsToRun = (event) => event.runId === genesis.runId && canonicalizeJson(event.definition) === canonicalDefinition;
+  const runEvents = events.filter(belongsToRun);
+  const byId = new Map(events.map((event) => [event.eventId, event]));
+  const { ordered, cyclic } = causalOrder(events, byId);
+  const commandFingerprints = /* @__PURE__ */ new Map();
+  const attemptSteps = /* @__PURE__ */ new Map();
+  const runGenesisValues = new Set(
+    runEvents.filter((event) => event.payload.kind === "run.started").map((event) => event.payload.kind === "run.started" ? canonicalizeJson(event.payload.genesis) : "")
+  );
+  const canonicalGenesis = canonicalizeJson(genesis);
+  for (const event of runEvents) {
+    const fingerprints = commandFingerprints.get(event.idempotencyKey) ?? /* @__PURE__ */ new Set();
+    fingerprints.add(event.commandFingerprint);
+    commandFingerprints.set(event.idempotencyKey, fingerprints);
+    if ("attemptId" in event.payload && "stepId" in event.payload) {
+      const steps = attemptSteps.get(event.payload.attemptId) ?? /* @__PURE__ */ new Set();
+      steps.add(event.payload.stepId);
+      attemptSteps.set(event.payload.attemptId, steps);
+    }
+  }
+  const attempts = /* @__PURE__ */ new Map();
+  const accepted = [];
+  const acceptedSet = /* @__PURE__ */ new Set();
+  const invalid = [];
+  const invalidReasons = /* @__PURE__ */ new Map();
+  const cancelEvents = [];
+  const finalizationEvents = [];
+  const cycleEvents = events.filter((event) => cyclic.has(event.eventId)).sort((left, right) => compareCodeUnits(left.eventId, right.eventId));
+  for (const event of [...ordered, ...cycleEvents]) {
+    let reason;
+    if (!belongsToRun(event)) reason = "run_or_definition_mismatch";
+    if (!reason && event.payload.kind === "run.started" && runGenesisValues.size > 1) reason = "run_genesis_conflict";
+    if (!reason && event.payload.kind === "run.started" && canonicalizeJson(event.payload.genesis) !== canonicalGenesis) {
+      reason = "run_genesis_mismatch";
+    }
+    if (!reason && (commandFingerprints.get(event.idempotencyKey)?.size ?? 0) > 1) reason = "idempotency_fingerprint_conflict";
+    if (!reason && event.parents.some((parent) => !byId.has(parent))) reason = "missing_parent";
+    if (!reason && cyclic.has(event.eventId)) reason = "causal_cycle";
+    if (!reason && "attemptId" in event.payload && (attemptSteps.get(event.payload.attemptId)?.size ?? 0) > 1) reason = "attempt_step_conflict";
+    if (!reason && event.parents.some((parent) => invalidReasons.has(parent))) reason = "invalid_parent";
+    if (!reason) reason = attemptChainError(event, byId, acceptedSet);
+    if (!reason && event.payload.kind !== "log" && hasAcceptedAncestor(event, byId, acceptedSet, (candidate) => candidate.payload.kind === "run.finalized")) {
+      reason = "event_descends_from_finalization";
+    }
+    if (!reason && event.payload.kind === "action.requested") {
+      const causallyCancelled = cancelEvents.some((cancel) => eventHasAncestor(event, cancel.eventId, byId));
+      if (causallyCancelled) reason = "action_descends_from_cancellation";
+    }
+    if (reason) {
+      invalid.push({ eventId: event.eventId, reason });
+      invalidReasons.set(event.eventId, reason);
+      continue;
+    }
+    accepted.push(event.eventId);
+    acceptedSet.add(event.eventId);
+    const payload = event.payload;
+    if (payload.kind === "run.cancel_requested") cancelEvents.push(event);
+    if (payload.kind === "run.finalized") finalizationEvents.push(event);
+    if (!("attemptId" in payload)) continue;
+    const current = attempts.get(payload.attemptId) ?? {
+      attemptId: payload.attemptId,
+      stepId: "stepId" in payload ? payload.stepId : "",
+      disposition: "not_started",
+      receiptIds: [],
+      outcomes: []
+    };
+    let next = current;
+    if (payload.kind === "action.effect_armed" && DISPOSITION_RANK[current.disposition] < DISPOSITION_RANK.armed) {
+      next = { ...current, stepId: payload.stepId, disposition: "armed" };
+    }
+    if (payload.kind === "action.succeeded") {
+      next = { ...current, stepId: payload.stepId, disposition: "succeeded", outputDigest: payload.outputDigest, providerCorrelation: payload.providerCorrelation };
+    }
+    if (payload.kind === "action.failed_before_effect" && DISPOSITION_RANK[current.disposition] < DISPOSITION_RANK.failed_before_effect) {
+      next = { ...current, stepId: payload.stepId, disposition: "failed_before_effect" };
+    }
+    if (payload.kind === "action.needs_verification" && DISPOSITION_RANK[current.disposition] < DISPOSITION_RANK.needs_verification) {
+      next = { ...current, stepId: payload.stepId, disposition: "needs_verification", providerCorrelation: payload.providerCorrelation };
+    }
+    if (payload.kind === "receipt.persisted") {
+      next = { ...current, receiptIds: [.../* @__PURE__ */ new Set([...current.receiptIds, payload.receiptId])].sort() };
+    }
+    if (payload.kind === "action.outcome_emitted") {
+      const outcomes = [...current.outcomes, { name: payload.name, payload: payload.payload, payloadDigest: payload.payloadDigest }];
+      next = {
+        ...current,
+        outcomes: outcomes.filter((outcome, index) => outcomes.findIndex((candidate) => candidate.name === outcome.name && candidate.payloadDigest === outcome.payloadDigest) === index).sort((left, right) => compareCodeUnits(left.name, right.name) || compareCodeUnits(left.payloadDigest, right.payloadDigest))
+      };
+    }
+    attempts.set(payload.attemptId, next);
+  }
+  const values = [...attempts.values()];
+  const unresolved = values.some((attempt) => attempt.disposition === "armed" || attempt.disposition === "needs_verification");
+  const completedSteps = new Set(values.filter((attempt) => attempt.disposition === "succeeded").map((attempt) => attempt.stepId));
+  const completed = genesis.requiredStepIds.every((stepId) => completedSteps.has(stepId));
+  const failed = values.some((attempt) => attempt.disposition === "failed_before_effect");
+  const cancelRequested = cancelEvents.length > 0;
+  const active = values.some((attempt) => attempt.disposition === "not_started" || attempt.disposition === "armed");
+  const acceptedStateEvents = new Set(
+    accepted.filter((eventId) => {
+      const kind = byId.get(eventId)?.payload.kind;
+      return kind !== "run.finalized" && kind !== "log";
+    })
+  );
+  const frontierEventIds = acceptedFrontier(events, acceptedStateEvents);
+  const hasAcceptedStart = [...acceptedStateEvents].some((eventId) => byId.get(eventId)?.payload.kind === "run.started");
+  const missingTopicReceipt = genesis.topicBindingId !== void 0 && values.some((attempt) => attempt.disposition === "succeeded" && attempt.receiptIds.length === 0);
+  const missingDeclaredOutcome = accepted.some((eventId) => {
+    const success = byId.get(eventId);
+    if (success?.payload.kind !== "action.succeeded") return false;
+    const successPayload = success.payload;
+    return (successPayload.outcomes ?? []).some(
+      (declared) => !accepted.some((candidateId) => {
+        const candidate = byId.get(candidateId);
+        return candidate?.payload.kind === "action.outcome_emitted" && candidate.payload.attemptId === successPayload.attemptId && candidate.payload.stepId === successPayload.stepId && candidate.payload.name === declared.name && candidate.payload.payloadDigest === declared.payloadDigest && canonicalizeJson(candidate.payload.payload) === canonicalizeJson(declared.payload) && eventHasAncestor(candidate, success.eventId, byId);
+      })
+    );
+  });
+  let finalizableStatus;
+  if (hasAcceptedStart && !unresolved && !missingTopicReceipt && !missingDeclaredOutcome) {
+    if (completed) finalizableStatus = "completed";
+    else if (cancelRequested && !active) finalizableStatus = "cancelled";
+    else if (failed && !active) finalizableStatus = "failed";
+  }
+  const finalizationSummary = finalizableStatus ? {
+    kind: "qi.flow.run-finalization-summary",
+    schemaVersion: "1.0",
+    status: finalizableStatus,
+    cancelRequested,
+    requiredStepIds: sortedUnique(genesis.requiredStepIds),
+    frontierEventIds,
+    attempts: values.map((attempt) => ({
+      attemptId: attempt.attemptId,
+      stepId: attempt.stepId,
+      disposition: attempt.disposition,
+      receiptIds: sortedUnique(attempt.receiptIds)
+    })).sort((left, right) => compareCodeUnits(left.attemptId, right.attemptId))
+  } : void 0;
+  const validFinalizationIds = [];
+  for (const event of finalizationEvents) {
+    if (invalidReasons.has(event.eventId) || event.payload.kind !== "run.finalized") continue;
+    let reason;
+    if (!sameStringSet(event.parents, frontierEventIds)) reason = "incomplete_finalization_frontier";
+    else if (!finalizableStatus || !finalizationSummary) reason = "run_not_finalizable";
+    else if (event.payload.status !== finalizableStatus) reason = "finalization_status_mismatch";
+    else if (canonicalizeJson(event.payload.summary) !== canonicalizeJson(finalizationSummary)) {
+      reason = "finalization_summary_mismatch";
+    }
+    if (reason) {
+      invalid.push({ eventId: event.eventId, reason });
+      invalidReasons.set(event.eventId, reason);
+    } else {
+      validFinalizationIds.push(event.eventId);
+    }
+  }
+  let status = acceptedStateEvents.size === 0 ? "queued" : "running";
+  if (unresolved) status = "needs_verification";
+  else if (validFinalizationIds.length > 0 && finalizableStatus) status = finalizableStatus;
+  else if (cancelRequested) status = "cancelling";
+  const validAccepted = accepted.filter((eventId) => !invalidReasons.has(eventId));
+  return {
+    runId: genesis.runId,
+    definition: genesis.definition,
+    status,
+    attempts: Object.fromEntries([...attempts.entries()].sort(([left], [right]) => compareCodeUnits(left, right))),
+    cancelRequested,
+    frontierEventIds,
+    ...finalizableStatus && finalizationSummary ? { finalizationCandidate: { status: finalizableStatus, summary: finalizationSummary } } : {},
+    finalizedEventIds: validFinalizationIds.sort(compareCodeUnits),
+    acceptedEventIds: validAccepted.sort(compareCodeUnits),
+    invalidEvents: invalid.sort((left, right) => compareCodeUnits(left.eventId, right.eventId))
+  };
+}
+async function fingerprintFlowCommand(command) {
+  return await digestCanonicalJson(command);
+}
+
+// src/core/lib/flowEngine/vnext/effectClaims.ts
+var EffectClaimTransitionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EffectClaimTransitionError";
+  }
+};
+function claimEffect(existing, request, now) {
+  if (existing?.fingerprint !== void 0 && existing.fingerprint !== request.admission.commandFingerprint) {
+    return { outcome: "conflict", record: existing, reason: "Idempotency key already belongs to a different command fingerprint" };
+  }
+  if (existing && existing.providerIdempotencyKey !== request.providerIdempotencyKey) {
+    return { outcome: "conflict", record: existing, reason: "Effect claim already belongs to a different provider idempotency key" };
+  }
+  if (existing) {
+    const recovery = existing.status === "armed" || existing.status === "needs_verification" || existing.status === "success_prepared";
+    if (recovery) {
+      if (existing.leaseExpiresAt > now) return { outcome: "existing", record: existing };
+      return {
+        outcome: "claimed",
+        record: {
+          ...existing,
+          leaseOwner: request.leaseOwner,
+          // A prepared success has already consumed the effect fence. Recovery
+          // only drains its immutable result evidence into Matrix.
+          fencingEpoch: existing.status === "success_prepared" ? existing.fencingEpoch : existing.fencingEpoch + 1,
+          leaseExpiresAt: now + request.leaseTtlMs,
+          policyDigest: request.policyDigest,
+          updatedAt: now
+        }
+      };
+    }
+    if (existing.status !== "claimed") {
+      return { outcome: "existing", record: existing };
+    }
+    if (existing.leaseExpiresAt > now) return { outcome: "existing", record: existing };
+    if (request.admission.policy.mode !== "enabled") {
+      return {
+        outcome: "claimed",
+        record: {
+          ...existing,
+          leaseOwner: request.leaseOwner,
+          fencingEpoch: existing.fencingEpoch + 1,
+          leaseExpiresAt: now + request.leaseTtlMs,
+          policyDigest: request.policyDigest,
+          updatedAt: now
+        }
+      };
+    }
+  }
+  if (request.admission.policy.mode !== "enabled") return { outcome: "paused", record: existing ?? void 0, reason: "Execution policy pauses new effects" };
+  return {
+    outcome: "claimed",
+    record: {
+      kind: "qi.flow.effect-claim",
+      schemaVersion: "1.0",
+      claimKey: request.claimKey,
+      fingerprint: request.admission.commandFingerprint,
+      status: "claimed",
+      leaseOwner: request.leaseOwner,
+      fencingEpoch: (existing?.fencingEpoch ?? 0) + 1,
+      leaseExpiresAt: now + request.leaseTtlMs,
+      providerIdempotencyKey: request.providerIdempotencyKey,
+      policyDigest: request.policyDigest,
+      updatedAt: now
+    }
+  };
+}
+function assertFence(record, owner, epoch, now) {
+  if (record.leaseOwner !== owner || record.fencingEpoch !== epoch) {
+    throw new EffectClaimTransitionError("STALE_FENCE", "Effect claim owner or fencing epoch is stale");
+  }
+  if (record.leaseExpiresAt <= now) throw new EffectClaimTransitionError("STALE_FENCE", "Effect claim lease has expired");
+}
+function renewEffectClaim(record, owner, epoch, leaseTtlMs, now) {
+  assertFence(record, owner, epoch, now);
+  if (record.status !== "claimed") throw new EffectClaimTransitionError("INVALID_TRANSITION", "Only an unarmed claim can renew its lease");
+  return { ...record, leaseExpiresAt: now + leaseTtlMs, updatedAt: now };
+}
+function armEffectClaim(record, owner, epoch, now, providerCorrelation) {
+  assertFence(record, owner, epoch, now);
+  if (record.status === "armed" && record.providerCorrelation === providerCorrelation) return record;
+  if (record.status !== "claimed") throw new EffectClaimTransitionError("INVALID_TRANSITION", "Only a claimed effect can be armed");
+  return { ...record, status: "armed", ...providerCorrelation !== void 0 ? { providerCorrelation } : {}, updatedAt: now };
+}
+function prepareEffectSuccess(record, owner, epoch, outputDigest2, outcomesDigest, now, providerCorrelation) {
+  assertFence(record, owner, epoch, now);
+  if (record.status === "success_prepared") {
+    if (record.outputDigest !== outputDigest2 || record.outcomesDigest !== outcomesDigest) {
+      throw new EffectClaimTransitionError("INVALID_TRANSITION", "Prepared effect success has different result evidence");
+    }
+    return record;
+  }
+  if (record.status !== "armed" && record.status !== "needs_verification") {
+    throw new EffectClaimTransitionError("INVALID_TRANSITION", "Only an armed or verified effect can prepare success");
+  }
+  const nextCorrelation = providerCorrelation ?? record.providerCorrelation;
+  return {
+    ...record,
+    status: "success_prepared",
+    outputDigest: outputDigest2,
+    outcomesDigest,
+    ...nextCorrelation !== void 0 ? { providerCorrelation: nextCorrelation } : {},
+    updatedAt: now
+  };
+}
+function resolveEffectClaim(record, owner, epoch, outcome, now, providerCorrelation, successEventId) {
+  if (outcome === "failed_before_effect" && successEventId !== void 0) {
+    throw new EffectClaimTransitionError("INVALID_TRANSITION", "Failed-before-effect resolution cannot include success evidence");
+  }
+  if (record.status === outcome) {
+    const expectedCorrelation = providerCorrelation ?? record.providerCorrelation;
+    const sameCorrelation = record.providerCorrelation === expectedCorrelation;
+    const sameSuccess = outcome !== "succeeded" || record.successEventId === successEventId;
+    if (record.leaseOwner === owner && record.fencingEpoch === epoch && sameCorrelation && sameSuccess) return record;
+    throw new EffectClaimTransitionError("INVALID_TRANSITION", "Resolved effect evidence does not match the existing terminal record");
+  }
+  assertFence(record, owner, epoch, now);
+  if (outcome === "failed_before_effect" && record.status !== "claimed") {
+    throw new EffectClaimTransitionError("INVALID_TRANSITION", "An armed effect cannot be reported as failed before effect");
+  }
+  if (outcome === "succeeded" && (record.status !== "success_prepared" || !record.outputDigest || !record.outcomesDigest)) {
+    throw new EffectClaimTransitionError("INVALID_TRANSITION", "Effect success must be prepared before it can be finalized");
+  }
+  if (outcome === "succeeded" && !successEventId) {
+    throw new EffectClaimTransitionError("INVALID_TRANSITION", "Effect success requires its durable Matrix event id");
+  }
+  const nextCorrelation = providerCorrelation ?? record.providerCorrelation;
+  return {
+    ...record,
+    status: outcome,
+    ...nextCorrelation !== void 0 ? { providerCorrelation: nextCorrelation } : {},
+    ...successEventId ? { successEventId } : {},
+    updatedAt: now
+  };
+}
+function markEffectNeedsVerification(record, owner, epoch, now, providerCorrelation) {
+  assertFence(record, owner, epoch, now);
+  if (record.status === "needs_verification" && record.providerCorrelation === (providerCorrelation ?? record.providerCorrelation)) return record;
+  if (record.status !== "armed") throw new EffectClaimTransitionError("INVALID_TRANSITION", "Only an armed effect can become ambiguous");
+  const nextCorrelation = providerCorrelation ?? record.providerCorrelation;
+  return { ...record, status: "needs_verification", ...nextCorrelation !== void 0 ? { providerCorrelation: nextCorrelation } : {}, updatedAt: now };
+}
+
+// src/core/lib/flowEngine/vnext/actionContracts.ts
+var ActionContractResolutionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ActionContractResolutionError";
+  }
+};
+var SAFETY_CLASSES = /* @__PURE__ */ new Set(["pure", "provider_idempotent", "fenced", "approval_only"]);
+var DATA_CLASSIFICATIONS = /* @__PURE__ */ new Set(["public", "shared", "confidential", "restricted"]);
+var PROCEDURES = /* @__PURE__ */ new Set(["required", "supported", "unavailable"]);
+function object(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${field} must be a JSON object`);
+  }
+  return value;
+}
+function strings(value, field) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${field} must be an array of non-empty strings`);
+  }
+  return [...value];
+}
+function requiredString(action, field) {
+  const value = action[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type}.${field} must be a non-empty string`);
+  }
+  return value;
+}
+function parseActionContract(action, manifestDigest) {
+  const can = requiredString(action, "can");
+  const safety = requiredString(action, "safety");
+  if (!SAFETY_CLASSES.has(safety)) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type}.safety is not a supported safety class`);
+  }
+  const dataClassification = requiredString(action, "dataClassification");
+  if (!DATA_CLASSIFICATIONS.has(dataClassification)) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type}.dataClassification is not supported`);
+  }
+  const providerIdempotency = object(action.providerIdempotency, `${action.type}.providerIdempotency`);
+  if (typeof providerIdempotency.supported !== "boolean") {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type}.providerIdempotency.supported must be boolean`);
+  }
+  const readback = requiredString(action, "readbackProcedure");
+  const compensation = requiredString(action, "compensationProcedure");
+  if (!PROCEDURES.has(readback) || !PROCEDURES.has(compensation)) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type} readback and compensation procedures must be explicit`);
+  }
+  if ((safety === "provider_idempotent" || safety === "fenced") && readback === "unavailable") {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type} cannot perform external effects without a readback procedure`);
+  }
+  if (safety === "provider_idempotent" && providerIdempotency.supported !== true) {
+    throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `${action.type} declares provider idempotency without provider support`);
+  }
+  return {
+    kind: "qi.action.contract",
+    schemaVersion: "1.0",
+    type: action.type,
+    can,
+    contractVersion: action.contractVersion,
+    manifestDigest,
+    inputSchema: object(action.inputSchema, `${action.type}.inputSchema`),
+    outputSchema: object(action.outputSchema, `${action.type}.outputSchema`),
+    safety,
+    handlerVersion: requiredString(action, "handlerVersion"),
+    dataClassification,
+    requiredServices: strings(action.requiredServices, `${action.type}.requiredServices`),
+    idempotency: {
+      providerKey: providerIdempotency.supported,
+      readback,
+      compensation
+    }
+  };
+}
+async function computeActionContractDigest(contract) {
+  return await digestCanonicalJson(contract);
+}
+var HistoricalManifestActionContractResolver = class {
+  constructor(repository, trustPolicy) {
+    this.repository = repository;
+    this.trustPolicy = trustPolicy;
+    this.verifiedManifests = /* @__PURE__ */ new Map();
+  }
+  async resolve(ref) {
+    const manifest = await this.loadManifest(ref.manifestDigest);
+    const action = manifest.actions.find((candidate) => candidate.type === ref.type);
+    if (!action) throw new ActionContractResolutionError("ACTION_NOT_FOUND", `Action ${ref.type} is not present in ${ref.manifestDigest}`);
+    if (action.contractVersion !== ref.contractVersion) {
+      throw new ActionContractResolutionError("ACTION_VERSION_MISMATCH", `Action ${ref.type} contract version does not match its Flow revision`);
+    }
+    const unsigned = parseActionContract(action, ref.manifestDigest);
+    const contractDigest = await computeActionContractDigest(unsigned);
+    if (contractDigest !== ref.contractDigest) {
+      throw new ActionContractResolutionError("ACTION_CONTRACT_DIGEST_MISMATCH", `Action ${ref.type} contract bytes do not match the pinned digest`);
+    }
+    if (unsigned.can !== ref.can) {
+      throw new ActionContractResolutionError("INVALID_ACTION_CONTRACT", `Action ${ref.type} capability does not match the Flow revision`);
+    }
+    return Object.freeze({ ...unsigned, contractDigest });
+  }
+  loadManifest(digest) {
+    const cached = this.verifiedManifests.get(digest);
+    if (cached) return cached;
+    const pending = this.verifyManifest(digest);
+    this.verifiedManifests.set(digest, pending);
+    pending.catch(() => this.verifiedManifests.delete(digest));
+    return pending;
+  }
+  async verifyManifest(digest) {
+    const signed = await this.repository.getByDigest(digest);
+    if (!signed) throw new ActionContractResolutionError("MANIFEST_NOT_FOUND", `Historical Action manifest is unavailable: ${digest}`);
+    const verified = await verifyActionManifestV2(signed, this.trustPolicy);
+    if (verified.integrity.digest.value !== digest) {
+      throw new ActionContractResolutionError("MANIFEST_DIGEST_MISMATCH", `Historical manifest repository returned the wrong digest for ${digest}`);
+    }
+    return verified;
+  }
+};
+
+// src/core/lib/flowEngine/vnext/peerExecutor.ts
+import Ajv2020 from "ajv/dist/2020.js";
+var UNIVERSAL_ACTION_COMPLETED_OUTCOME = "step.completed";
+var PeerExecutionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PeerExecutionError";
+  }
+};
+function definitionRef(definition) {
+  return { ...definition.ref, digest: definition.integrity.digest.value };
+}
+function proofReferences(authorization) {
+  const invocations = "flow" in authorization ? [authorization.flow, authorization.action, authorization.topic, authorization.provider, authorization.effectClaim?.invocation] : [authorization];
+  return [...new Set(invocations.flatMap((invocation) => invocation ? [invocation.cid, ...invocation.proofCids] : []))].sort();
+}
+function assertInvocation(invocation, expected) {
+  if (invocation.audience !== expected.audience || invocation.can !== expected.can || invocation.with !== expected.with || invocation.definitionDigest !== expected.definitionDigest || invocation.actionContractDigest !== expected.actionContractDigest || invocation.idempotencyKey !== expected.idempotencyKey) {
+    throw new PeerExecutionError("AUTHORIZATION_MISMATCH", `Verified invocation does not authorize ${expected.can} on ${expected.with}`);
+  }
+}
+function outputDigest(output) {
+  return digestCanonicalJson(output);
+}
+function compareCodeUnits2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+async function actionOutcomes(output, provided = []) {
+  const inputs = [
+    { name: UNIVERSAL_ACTION_COMPLETED_OUTCOME, payload: { outputDigest: output } },
+    ...provided.filter((outcome) => outcome.name.trim() !== UNIVERSAL_ACTION_COMPLETED_OUTCOME)
+  ];
+  const outcomes = await Promise.all(
+    inputs.map(async ({ name, payload }) => {
+      const normalizedName = name.trim();
+      if (!normalizedName) throw new PeerExecutionError("EVENT_CONFLICT", "Action outcome name cannot be empty");
+      const snapshot = JSON.parse(canonicalizeJson(payload));
+      return { name: normalizedName, payload: snapshot, payloadDigest: await digestCanonicalJson(snapshot) };
+    })
+  );
+  return outcomes.filter((outcome, index) => outcomes.findIndex((candidate) => candidate.name === outcome.name && candidate.payloadDigest === outcome.payloadDigest) === index).sort((left, right) => compareCodeUnits2(left.name, right.name) || compareCodeUnits2(left.payloadDigest, right.payloadDigest));
+}
+function actionOutcomesDigest(outcomes) {
+  return digestCanonicalJson(outcomes);
+}
+function canonicalSnapshot(value) {
+  return deepFreezeJson(JSON.parse(canonicalizeJson(value)));
+}
+function snapshotStartCommand(command) {
+  return canonicalSnapshot({
+    definition: command.definition,
+    launchKind: command.launchKind,
+    launchNonce: command.launchNonce,
+    actor: command.actor,
+    issuedAt: command.issuedAt,
+    idempotencyKey: command.idempotencyKey,
+    authorization: command.authorization,
+    ...command.topicBindingId !== void 0 ? { topicBindingId: command.topicBindingId } : {}
+  });
+}
+function snapshotAttemptCommand(command) {
+  return canonicalSnapshot({
+    definition: command.definition,
+    genesis: command.genesis,
+    stepId: command.stepId,
+    actor: command.actor,
+    issuedAt: command.issuedAt,
+    idempotencyKey: command.idempotencyKey,
+    inputs: command.inputs,
+    authorization: command.authorization,
+    policy: command.policy,
+    ...command.topicBinding ? { topicBinding: command.topicBinding } : {},
+    ...command.topicRequest ? { topicRequest: command.topicRequest } : {}
+  });
+}
+function snapshotCancelCommand(command) {
+  return canonicalSnapshot({
+    definition: command.definition,
+    genesis: command.genesis,
+    actor: command.actor,
+    issuedAt: command.issuedAt,
+    idempotencyKey: command.idempotencyKey,
+    authorization: command.authorization,
+    ...command.reason !== void 0 ? { reason: command.reason } : {}
+  });
+}
+function snapshotFinalizeCommand(command) {
+  return canonicalSnapshot({
+    definition: command.definition,
+    genesis: command.genesis,
+    actor: command.actor,
+    issuedAt: command.issuedAt,
+    idempotencyKey: command.idempotencyKey,
+    authorization: command.authorization
+  });
+}
+function durationMs(value) {
+  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?)?$/u.exec(value);
+  if (!match) return void 0;
+  const [, days, hours, minutes] = match;
+  const total = Number(days ?? 0) * 864e5 + Number(hours ?? 0) * 36e5 + Number(minutes ?? 0) * 6e4;
+  return total > 0 ? total : void 0;
+}
+function assertStepWithinTtl(step, genesis, now) {
+  const startedAt = Date.parse(genesis.startedAt);
+  const deadlines = [];
+  if (step.ttlMs !== void 0) {
+    if (!Number.isFinite(startedAt)) throw new PeerExecutionError("STEP_EXPIRED", "Run start time is unavailable for the signed step TTL");
+    deadlines.push(startedAt + step.ttlMs);
+  }
+  if (step.ttl?.absoluteDueDate) deadlines.push(Date.parse(step.ttl.absoluteDueDate));
+  for (const relative of [step.ttl?.fromEnablement, step.ttl?.fromCommitment]) {
+    if (!relative) continue;
+    const relativeMs = durationMs(relative);
+    if (!Number.isFinite(startedAt) || relativeMs === void 0) {
+      throw new PeerExecutionError("STEP_EXPIRED", "The signed relative step TTL cannot be proven unexpired");
+    }
+    deadlines.push(startedAt + relativeMs);
+  }
+  if (deadlines.some((deadline) => !Number.isFinite(deadline) || now >= deadline)) {
+    throw new PeerExecutionError("STEP_EXPIRED", `Flow step ${step.stepId} is outside its signed execution window`);
+  }
+}
+function assertCommandTime(issuedAtValue, executionNow) {
+  const issuedAt = Date.parse(issuedAtValue);
+  if (!Number.isFinite(issuedAt) || issuedAt > executionNow) {
+    throw new PeerExecutionError("COMMAND_TIME_INVALID", "Command time must be valid and no later than executor time");
+  }
+}
+async function assertRunGenesis(definitionRevision, genesis) {
+  const definition = definitionRef(definitionRevision);
+  const expectedRunId = await deriveRunId(definition, genesis.launchKind, genesis.launchNonce);
+  const expectedStepIds = definitionRevision.steps.map((candidate) => candidate.stepId);
+  if (genesis.runId !== expectedRunId || canonicalizeJson(genesis.definition) !== canonicalizeJson(definition) || canonicalizeJson(genesis.requiredStepIds) !== canonicalizeJson(expectedStepIds) || !Number.isFinite(Date.parse(genesis.startedAt))) {
+    throw new PeerExecutionError("DEFINITION_MISMATCH", "Run genesis does not match the immutable Flow definition");
+  }
+  return definition;
+}
+function createPeerExecutor(options) {
+  const schemaCompiler = new Ajv2020({ allErrors: true, strict: false });
+  const validators = /* @__PURE__ */ new Map();
+  function contractValidators(contract) {
+    let resolved = validators.get(contract.contractDigest);
+    if (!resolved) {
+      try {
+        const input = schemaCompiler.compile(contract.inputSchema);
+        const output = schemaCompiler.compile(contract.outputSchema);
+        if (input.$async || output.$async) {
+          throw new Error("Asynchronous JSON Schema validation is not supported by the peer executor");
+        }
+        resolved = { input, output };
+      } catch (error) {
+        throw new PeerExecutionError("ACTION_CONTRACT_INVALID", `Pinned Action schema is invalid: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      validators.set(contract.contractDigest, resolved);
+    }
+    return resolved;
+  }
+  function assertValidInputs(contract, inputs) {
+    const validate = contractValidators(contract).input;
+    if (!validate(inputs)) {
+      throw new PeerExecutionError("INPUT_SCHEMA_INVALID", `Action inputs do not match the pinned schema: ${schemaCompiler.errorsText(validate.errors)}`);
+    }
+  }
+  async function validatedOutputDigest(contract, candidate) {
+    const output = canonicalSnapshot(candidate);
+    const validate = contractValidators(contract).output;
+    if (!validate(output)) {
+      throw new PeerExecutionError("OUTPUT_SCHEMA_INVALID", `Action output does not match the pinned schema: ${schemaCompiler.errorsText(validate.errors)}`);
+    }
+    return outputDigest(output);
+  }
+  function assertExecutionWindow(command, step) {
+    const executionNow = options.now?.() ?? Date.now();
+    if (command.policy.expiresAt && (!Number.isFinite(Date.parse(command.policy.expiresAt)) || executionNow >= Date.parse(command.policy.expiresAt))) {
+      throw new PeerExecutionError("POLICY_EXPIRED", "Signed execution policy has expired");
+    }
+    assertStepWithinTtl(step, command.genesis, executionNow);
+  }
+  const append = async (envelope) => {
+    const event = await signFlowEvent(envelope, options.signer);
+    try {
+      const result = await options.events.append(event, matrixFlowEventTransactionId(event));
+      if (result.outcome === "conflict") throw new PeerExecutionError("EVENT_CONFLICT", `Matrix transaction conflicts for ${event.eventId}`);
+    } catch (error) {
+      if (error instanceof PeerExecutionError) throw error;
+      throw new PeerExecutionError("EVENT_UNAVAILABLE", `Matrix could not durably append ${event.payload.kind}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return event;
+  };
+  const eventBase = (params) => ({
+    kind: "qi.flow.event",
+    schemaVersion: "1.0",
+    runId: params.runId,
+    definition: params.definition,
+    producer: options.executorDid,
+    actor: params.actor,
+    occurredAt: params.issuedAt,
+    parents: params.parents,
+    correlationId: params.idempotencyKey,
+    idempotencyKey: params.idempotencyKey,
+    commandFingerprint: params.commandFingerprint,
+    proofReferences: params.proofs
+  });
+  const readAnchoredRun = async (definition, genesis) => {
+    let runEvents;
+    try {
+      runEvents = await options.events.read(genesis.runId);
+    } catch (error) {
+      throw new PeerExecutionError("EVENT_UNAVAILABLE", `Matrix could not inspect run state: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const reducedRun = reduceFlowEvents(genesis, runEvents);
+    const acceptedEventIds = new Set(reducedRun.acceptedEventIds);
+    const canonicalGenesis = canonicalizeJson(genesis);
+    if (!runEvents.some(
+      (event) => acceptedEventIds.has(event.eventId) && event.payload.kind === "run.started" && canonicalizeJson(event.payload.genesis) === canonicalGenesis
+    )) {
+      throw new PeerExecutionError("DEFINITION_MISMATCH", "Run genesis is not anchored by a verified run-start event");
+    }
+    if (canonicalizeJson(reducedRun.definition) !== canonicalizeJson(definition)) {
+      throw new PeerExecutionError("DEFINITION_MISMATCH", "Reduced run definition does not match the immutable Flow definition");
+    }
+    return { runEvents, reducedRun, acceptedEventIds };
+  };
+  async function startRun(command) {
+    command = snapshotStartCommand(command);
+    const definition = definitionRef(command.definition);
+    const runId = await deriveRunId(definition, command.launchKind, command.launchNonce);
+    const executionNow = options.now?.() ?? Date.now();
+    assertCommandTime(command.issuedAt, executionNow);
+    if (command.launchKind === "topic.request" && !command.topicBindingId?.trim()) {
+      throw new PeerExecutionError("TOPIC_BINDING_REQUIRED", "Topic run start requires a non-empty binding");
+    }
+    const genesis = {
+      kind: "qi.flow.run-genesis",
+      schemaVersion: "1.0",
+      runId,
+      definition,
+      launchKind: command.launchKind,
+      launchNonce: command.launchNonce,
+      requiredStepIds: command.definition.steps.map((step) => step.stepId),
+      startedBy: command.actor,
+      startedAt: command.issuedAt,
+      ...command.topicBindingId ? { topicBindingId: command.topicBindingId } : {}
+    };
+    let runEvents;
+    try {
+      runEvents = await options.events.read(runId);
+    } catch (error) {
+      throw new PeerExecutionError("EVENT_UNAVAILABLE", `Matrix could not inspect existing run starts: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const canonicalDefinition = canonicalizeJson(definition);
+    const canonicalGenesis = canonicalizeJson(genesis);
+    const existingStarts = runEvents.filter(
+      (event) => event.runId === runId && canonicalizeJson(event.definition) === canonicalDefinition && event.payload.kind === "run.started"
+    );
+    if (existingStarts.some((event) => event.payload.kind === "run.started" && canonicalizeJson(event.payload.genesis) !== canonicalGenesis)) {
+      throw new PeerExecutionError("EVENT_CONFLICT", `Run ${runId} already has different signed genesis evidence`);
+    }
+    if (existingStarts.length > 0) {
+      const reducedRun = reduceFlowEvents(genesis, runEvents);
+      const acceptedEventIds = new Set(reducedRun.acceptedEventIds);
+      const acceptedStart = existingStarts.find((event) => acceptedEventIds.has(event.eventId));
+      if (acceptedStart?.payload.kind === "run.started") return acceptedStart.payload.genesis;
+      throw new PeerExecutionError("EVENT_CONFLICT", `Run ${runId} has invalid signed genesis evidence`);
+    }
+    const invocation = await options.authorizer.authorizeRunStart({
+      authorization: command.authorization,
+      executorDid: options.executorDid,
+      definition,
+      runId,
+      actor: command.actor,
+      issuedAt: command.issuedAt,
+      idempotencyKey: command.idempotencyKey
+    });
+    assertInvocation(invocation, {
+      audience: options.executorDid,
+      can: FLOW_CAPABILITIES.runStart,
+      with: buildFlowResourceUri(definition, { kind: "run", runId }),
+      definitionDigest: definition.digest,
+      idempotencyKey: command.idempotencyKey
+    });
+    const fingerprint = await fingerprintFlowCommand(genesis);
+    await append({
+      ...eventBase({
+        runId,
+        definition,
+        actor: command.actor,
+        issuedAt: command.issuedAt,
+        idempotencyKey: command.idempotencyKey,
+        commandFingerprint: fingerprint,
+        parents: [],
+        proofs: proofReferences(invocation)
+      }),
+      payload: { kind: "run.started", genesis }
+    });
+    return genesis;
+  }
+  async function cancelRun(command) {
+    command = snapshotCancelCommand(command);
+    const definition = await assertRunGenesis(command.definition, command.genesis);
+    assertCommandTime(command.issuedAt, options.now?.() ?? Date.now());
+    const { runEvents, reducedRun, acceptedEventIds } = await readAnchoredRun(definition, command.genesis);
+    if (reducedRun.finalizedEventIds.length > 0) throw new PeerExecutionError("RUN_FINALIZED", `Run ${command.genesis.runId} is already finalized`);
+    const commandFingerprint = await fingerprintFlowCommand({
+      definitionDigest: definition.digest,
+      runId: command.genesis.runId,
+      kind: "run.cancel_requested",
+      reason: command.reason ?? null
+    });
+    const sameKey = runEvents.filter((event) => event.idempotencyKey === command.idempotencyKey);
+    const existing = sameKey.find(
+      (event) => acceptedEventIds.has(event.eventId) && event.commandFingerprint === commandFingerprint && event.payload.kind === "run.cancel_requested" && event.payload.reason === command.reason
+    );
+    if (existing) return existing;
+    if (sameKey.length > 0) throw new PeerExecutionError("EVENT_CONFLICT", "The cancellation command key is already bound to different evidence");
+    const invocation = await options.authorizer.authorizeRunControl({
+      authorization: command.authorization,
+      executorDid: options.executorDid,
+      definition,
+      runId: command.genesis.runId,
+      actor: command.actor,
+      issuedAt: command.issuedAt,
+      idempotencyKey: command.idempotencyKey,
+      can: FLOW_CAPABILITIES.runCancel
+    });
+    assertInvocation(invocation, {
+      audience: options.executorDid,
+      can: FLOW_CAPABILITIES.runCancel,
+      with: buildFlowResourceUri(definition, { kind: "run", runId: command.genesis.runId }),
+      definitionDigest: definition.digest,
+      idempotencyKey: command.idempotencyKey
+    });
+    return append({
+      ...eventBase({
+        runId: command.genesis.runId,
+        definition,
+        actor: command.actor,
+        issuedAt: command.issuedAt,
+        idempotencyKey: command.idempotencyKey,
+        commandFingerprint,
+        parents: reducedRun.frontierEventIds,
+        proofs: proofReferences(invocation)
+      }),
+      payload: { kind: "run.cancel_requested", ...command.reason !== void 0 ? { reason: command.reason } : {} }
+    });
+  }
+  async function finalizeRun(command) {
+    command = snapshotFinalizeCommand(command);
+    const definition = await assertRunGenesis(command.definition, command.genesis);
+    assertCommandTime(command.issuedAt, options.now?.() ?? Date.now());
+    const { runEvents, reducedRun, acceptedEventIds } = await readAnchoredRun(definition, command.genesis);
+    const existingFinalization = runEvents.find(
+      (event) => acceptedEventIds.has(event.eventId) && reducedRun.finalizedEventIds.includes(event.eventId) && event.payload.kind === "run.finalized"
+    );
+    if (existingFinalization) return existingFinalization;
+    const candidate = reducedRun.finalizationCandidate;
+    if (!candidate) throw new PeerExecutionError("RUN_NOT_FINALIZABLE", `Run ${command.genesis.runId} has no causally complete terminal state`);
+    const summaryDigest = await digestCanonicalJson(candidate.summary);
+    const commandFingerprint = await fingerprintFlowCommand({
+      definitionDigest: definition.digest,
+      runId: command.genesis.runId,
+      kind: "run.finalized",
+      status: candidate.status,
+      summaryDigest
+    });
+    const sameKey = runEvents.filter((event) => event.idempotencyKey === command.idempotencyKey);
+    if (sameKey.length > 0) throw new PeerExecutionError("EVENT_CONFLICT", "The finalization command key is already bound to stale or different evidence");
+    const invocation = await options.authorizer.authorizeRunControl({
+      authorization: command.authorization,
+      executorDid: options.executorDid,
+      definition,
+      runId: command.genesis.runId,
+      actor: command.actor,
+      issuedAt: command.issuedAt,
+      idempotencyKey: command.idempotencyKey,
+      can: FLOW_CAPABILITIES.runClose
+    });
+    assertInvocation(invocation, {
+      audience: options.executorDid,
+      can: FLOW_CAPABILITIES.runClose,
+      with: buildFlowResourceUri(definition, { kind: "run", runId: command.genesis.runId }),
+      definitionDigest: definition.digest,
+      idempotencyKey: command.idempotencyKey
+    });
+    return append({
+      ...eventBase({
+        runId: command.genesis.runId,
+        definition,
+        actor: command.actor,
+        issuedAt: command.issuedAt,
+        idempotencyKey: command.idempotencyKey,
+        commandFingerprint,
+        parents: candidate.summary.frontierEventIds,
+        proofs: proofReferences(invocation)
+      }),
+      payload: { kind: "run.finalized", status: candidate.status, summary: candidate.summary, summaryDigest }
+    });
+  }
+  async function executeAttempt(command) {
+    command = snapshotAttemptCommand(command);
+    const inputs = command.inputs;
+    const definition = await assertRunGenesis(command.definition, command.genesis);
+    const executionNow = options.now?.() ?? Date.now();
+    assertCommandTime(command.issuedAt, executionNow);
+    if (command.policy.definition.digest !== definition.digest) throw new PeerExecutionError("POLICY_MISMATCH", "Execution policy is for a different Flow definition");
+    const { runEvents, reducedRun, acceptedEventIds } = await readAnchoredRun(definition, command.genesis);
+    if (reducedRun.finalizedEventIds.length > 0) throw new PeerExecutionError("RUN_FINALIZED", `Run ${command.genesis.runId} is already finalized`);
+    const step = command.definition.steps.find((candidate) => candidate.stepId === command.stepId);
+    if (!step) throw new PeerExecutionError("STEP_NOT_FOUND", `Flow step is not in the immutable definition: ${command.stepId}`);
+    if (step.trigger.kind !== "manual" && step.trigger.kind !== "topic.request" || step.conditions.length > 0) {
+      throw new PeerExecutionError("ELIGIBILITY_EVIDENCE_REQUIRED", `Flow step ${step.stepId} requires signed eligibility evidence`);
+    }
+    const hasSignedTopicContext = step.trigger.kind === "topic.request" || command.genesis.launchKind === "topic.request" || command.genesis.topicBindingId !== void 0;
+    if (hasSignedTopicContext && (!command.genesis.topicBindingId || !command.topicBinding || command.topicBinding.bindingId !== command.genesis.topicBindingId) || !hasSignedTopicContext && command.topicBinding) {
+      throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Topic execution requires the exact binding recorded by the signed step and run genesis");
+    }
+    if (step.trigger.kind === "topic.request" && (!command.topicRequest || command.topicRequest.requestKind !== step.trigger.requestKind || !command.topicRequest.requestId.trim() || !/^sha256:[0-9a-f]{64}$/u.test(command.topicRequest.requestDigest)) || !hasSignedTopicContext && command.topicRequest) {
+      throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Topic execution requires signed request evidence for the immutable request kind");
+    }
+    const contract = await options.contracts.resolve(step.action);
+    assertValidInputs(contract, inputs);
+    const inputDigest = await digestCanonicalJson(command.inputs);
+    const attemptId = await deriveAttemptId({ runId: command.genesis.runId, stepId: command.stepId, idempotencyKey: command.idempotencyKey, inputDigest });
+    const resource = buildFlowResourceUri(definition, { kind: "step", stepId: command.stepId, runId: command.genesis.runId });
+    const authorization = await options.authorizer.authorizeAttempt({
+      authorization: command.authorization,
+      executorDid: options.executorDid,
+      definition,
+      runId: command.genesis.runId,
+      stepId: command.stepId,
+      action: contract,
+      actor: command.actor,
+      idempotencyKey: command.idempotencyKey,
+      effectClaimAudience: options.effectClaimAudience,
+      topicBinding: command.topicBinding,
+      topicRequest: command.topicRequest
+    });
+    const invocationExpectation = {
+      audience: options.executorDid,
+      with: resource,
+      definitionDigest: definition.digest,
+      actionContractDigest: contract.contractDigest,
+      idempotencyKey: command.idempotencyKey
+    };
+    assertInvocation(authorization.flow, { ...invocationExpectation, can: FLOW_CAPABILITIES.actionExecute });
+    assertInvocation(authorization.action, { ...invocationExpectation, can: contract.can });
+    if (hasSignedTopicContext) {
+      if (!authorization.topic) throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Topic-bound execution requires a verified Topic invocation");
+      assertInvocation(authorization.topic, {
+        ...invocationExpectation,
+        can: FLOW_CAPABILITIES.topicRequestAction,
+        with: command.topicBinding.topicResource
+      });
+      if (command.topicRequest && (!authorization.topic.topicRequest || canonicalizeJson(authorization.topic.topicRequest) !== canonicalizeJson(command.topicRequest))) {
+        throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Verified Topic invocation does not bind the requested Topic request evidence");
+      }
+    }
+    const commandFingerprint = await fingerprintFlowCommand({
+      definitionDigest: definition.digest,
+      runId: command.genesis.runId,
+      stepId: command.stepId,
+      attemptId,
+      actor: command.actor,
+      inputDigest,
+      actionContractDigest: contract.contractDigest,
+      topicBindingId: command.topicBinding?.bindingId ?? null,
+      topicRequest: command.topicRequest ?? null
+    });
+    const base = {
+      runId: command.genesis.runId,
+      definition,
+      actor: command.actor,
+      issuedAt: command.issuedAt,
+      idempotencyKey: command.idempotencyKey,
+      commandFingerprint,
+      proofs: proofReferences(authorization)
+    };
+    let claimAdmission;
+    if (contract.safety === "fenced") {
+      if (!options.effectClaimAudience || !authorization.effectClaim) {
+        throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Fenced execution requires a peer-issued invocation addressed to the effect claim ledger");
+      }
+      assertInvocation(authorization.effectClaim.invocation, {
+        ...invocationExpectation,
+        audience: options.effectClaimAudience,
+        can: FLOW_CAPABILITIES.actionExecute
+      });
+      if (authorization.effectClaim.invocation.issuer !== options.executorDid) {
+        throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Effect claim invocation must be issued by the peer that owns the lease");
+      }
+      claimAdmission = {
+        authorization: authorization.effectClaim.authorization,
+        invocation: authorization.effectClaim.invocation,
+        policy: command.policy,
+        commandFingerprint
+      };
+    }
+    const existingRequest = runEvents.find(
+      (event) => acceptedEventIds.has(event.eventId) && event.payload.kind === "action.requested" && event.payload.attemptId === attemptId && event.payload.stepId === command.stepId
+    );
+    if (existingRequest && (existingRequest.commandFingerprint !== commandFingerprint || existingRequest.payload.kind === "action.requested" && existingRequest.payload.inputDigest !== inputDigest)) {
+      throw new PeerExecutionError("EVENT_CONFLICT", "The reserved attempt has different command evidence");
+    }
+    if (reducedRun.cancelRequested && !existingRequest) {
+      throw new PeerExecutionError("RUN_CANCELLING", "Run cancellation was observed before this attempt was reserved");
+    }
+    const existingAttempt = reducedRun.attempts[attemptId];
+    const existingSuccesses = runEvents.filter(
+      (event) => acceptedEventIds.has(event.eventId) && event.payload.kind === "action.succeeded" && event.payload.attemptId === attemptId && event.payload.stepId === command.stepId
+    );
+    const acceptedEvents = runEvents.filter((event) => acceptedEventIds.has(event.eventId));
+    if (existingRequest && contract.safety !== "fenced" && existingAttempt?.stepId === command.stepId) {
+      if (existingAttempt.disposition === "succeeded") {
+        if (!existingAttempt.outputDigest) throw new PeerExecutionError("EVENT_CONFLICT", "Accepted Action success is missing its output digest");
+        if (existingSuccesses.length === 0) throw new PeerExecutionError("EVENT_CONFLICT", "Reduced Action success has no accepted event");
+        for (const success of existingSuccesses) await persistActionOutcomeEvents(success, acceptedEvents);
+        return {
+          outcome: "succeeded",
+          attemptId,
+          outputDigest: existingAttempt.outputDigest,
+          providerCorrelation: existingAttempt.providerCorrelation
+        };
+      }
+      if (existingAttempt.disposition === "failed_before_effect") return { outcome: "failed_before_effect", attemptId };
+    }
+    const effectMayHaveStarted = runEvents.some(
+      (event) => acceptedEventIds.has(event.eventId) && (event.payload.kind === "action.started" || event.payload.kind === "action.effect_armed") && event.payload.attemptId === attemptId && event.payload.stepId === command.stepId
+    );
+    if (!existingRequest && contract.safety !== "fenced") assertExecutionWindow(command, step);
+    if (command.policy.mode === "pause_new_effects" && contract.safety === "provider_idempotent" && !effectMayHaveStarted) {
+      throw new PeerExecutionError("POLICY_PAUSED", "Signed execution policy pauses new external effects");
+    }
+    const requested = existingRequest ?? await append({
+      ...eventBase({ ...base, parents: reducedRun.frontierEventIds }),
+      payload: { kind: "action.requested", attemptId, stepId: command.stepId, inputDigest }
+    });
+    if (contract.safety === "approval_only") {
+      assertExecutionWindow(command, step);
+      const proposalDigest = await digestCanonicalJson({ attemptId, inputs: command.inputs, action: contract.contractDigest });
+      await append({
+        ...eventBase({ ...base, parents: [requested.eventId] }),
+        payload: { kind: "action.approval_proposed", attemptId, stepId: command.stepId, proposalDigest }
+      });
+      return { outcome: "approval_required", attemptId, proposalDigest };
+    }
+    const providerIdempotencyKey = `provider:${attemptId}`;
+    let claim;
+    let attemptParent = requested;
+    if (contract.safety === "fenced") {
+      if (!claimAdmission) throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Effect claim authorization is unavailable");
+      const claimKey = await deriveEffectClaimKey({
+        definition,
+        runId: command.genesis.runId,
+        stepId: command.stepId,
+        attemptId,
+        actorDid: command.actor,
+        inputDigest,
+        action: step.action,
+        topicBindingId: command.topicBinding?.bindingId
+      });
+      const claimed = await options.effectClaims.claim({
+        claimKey,
+        leaseOwner: options.executorDid,
+        leaseTtlMs: 3e4,
+        providerIdempotencyKey,
+        policyDigest: command.policy.integrity.digest.value,
+        admission: claimAdmission
+      });
+      if (claimed.outcome === "paused") throw new PeerExecutionError("POLICY_PAUSED", claimed.reason);
+      if (claimed.outcome === "conflict") throw new PeerExecutionError("CLAIM_CONFLICT", claimed.reason);
+      if (!claimed.record) throw new PeerExecutionError("CLAIM_CONFLICT", "Effect claim ledger returned no claim record");
+      const claimedRecord = claimed.record;
+      claim = claimedRecord;
+      const claimSuccess = claimedRecord.successEventId ? existingSuccesses.find((event) => event.eventId === claimedRecord.successEventId) : existingSuccesses.find(
+        (event) => event.payload.kind === "action.succeeded" && event.payload.claimKey === claimedRecord.claimKey && event.payload.fencingEpoch === claimedRecord.fencingEpoch
+      );
+      if (claimedRecord.status === "succeeded") {
+        return reconcileFenced(command, contract, authorization, attemptId, providerIdempotencyKey, claimedRecord, claimAdmission, base, requested, claimSuccess, acceptedEvents);
+      }
+      if (claimed.outcome === "existing" && claimedRecord.leaseOwner !== options.executorDid) {
+        return { outcome: "deferred", attemptId, reason: `Effect claim is owned by ${claimedRecord.leaseOwner}` };
+      }
+      if (claimedRecord.status === "armed" || claimedRecord.status === "needs_verification" || claimedRecord.status === "success_prepared") {
+        return reconcileFenced(command, contract, authorization, attemptId, providerIdempotencyKey, claimedRecord, claimAdmission, base, requested, claimSuccess, acceptedEvents);
+      }
+      claim = await options.effectClaims.arm(claimedRecord.claimKey, options.executorDid, claimedRecord.fencingEpoch, claimAdmission);
+      try {
+        attemptParent = await append({
+          ...eventBase({ ...base, parents: [requested.eventId] }),
+          payload: { kind: "action.effect_armed", attemptId, stepId: command.stepId, claimKey, fencingEpoch: claim.fencingEpoch }
+        });
+      } catch (error) {
+        await options.effectClaims.markNeedsVerification(claim.claimKey, options.executorDid, claim.fencingEpoch, claimAdmission, claim.providerCorrelation);
+        throw error;
+      }
+    } else {
+      attemptParent = await append({
+        ...eventBase({ ...base, parents: [requested.eventId] }),
+        payload: { kind: "action.started", attemptId, stepId: command.stepId }
+      });
+    }
+    if (!effectMayHaveStarted) {
+      try {
+        assertExecutionWindow(command, step);
+      } catch (error) {
+        if (!claim) throw error;
+        if (!claimAdmission) throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Effect claim authorization is unavailable");
+        const reason = error instanceof Error ? error.message : String(error);
+        await options.effectClaims.markNeedsVerification(claim.claimKey, options.executorDid, claim.fencingEpoch, claimAdmission, claim.providerCorrelation);
+        await append({
+          ...eventBase({ ...base, parents: [attemptParent.eventId] }),
+          payload: {
+            kind: "action.needs_verification",
+            attemptId,
+            stepId: command.stepId,
+            ...claim.providerCorrelation ? { providerCorrelation: claim.providerCorrelation } : {},
+            reason
+          }
+        });
+        return { outcome: "needs_verification", attemptId, providerCorrelation: claim.providerCorrelation };
+      }
+    }
+    const provider = await options.actions.invoke({
+      contract,
+      inputs: command.inputs,
+      providerIdempotencyKey,
+      invocation: authorization,
+      assertEffectAllowed: () => assertExecutionWindow(command, step)
+    });
+    if (provider.outcome === "succeeded") {
+      const digest = await validatedOutputDigest(contract, provider.output);
+      return persistSuccess(command, attemptId, digest, provider.outcomes, provider.providerCorrelation, claim, claimAdmission, base, attemptParent);
+    }
+    if (provider.outcome === "failed_before_effect" && !claim) {
+      await append({
+        ...eventBase({ ...base, parents: [attemptParent.eventId] }),
+        payload: { kind: "action.failed_before_effect", attemptId, stepId: command.stepId, error: provider.error }
+      });
+      return { outcome: "failed_before_effect", attemptId };
+    }
+    const ambiguous = provider.outcome === "ambiguous" ? provider : { outcome: "ambiguous", reason: "Provider reported failure after the effect was armed; readback is required" };
+    return reconcileAmbiguity(command, contract, authorization, attemptId, providerIdempotencyKey, claim, claimAdmission, base, attemptParent, ambiguous);
+  }
+  async function reconcileFenced(command, contract, authorization, attemptId, providerIdempotencyKey, claim, admission, base, requested, existingSuccess, existingEvents = []) {
+    if (existingSuccess?.payload.kind === "action.succeeded") {
+      const success = existingSuccess.payload;
+      const outcomesMatch = claim.outcomesDigest === void 0 ? success.outcomes === void 0 : await actionOutcomesDigest(success.outcomes ?? []) === claim.outcomesDigest;
+      if (success.claimKey !== claim.claimKey || success.fencingEpoch !== claim.fencingEpoch || success.outputDigest !== claim.outputDigest || !outcomesMatch) {
+        throw new PeerExecutionError("EVENT_CONFLICT", "Accepted fenced success does not match the durable prepared evidence");
+      }
+      if (claim.status === "success_prepared") {
+        await options.effectClaims.resolve(claim.claimKey, options.executorDid, claim.fencingEpoch, "succeeded", admission, success.providerCorrelation, existingSuccess.eventId);
+      } else if (claim.status !== "succeeded" || claim.successEventId !== existingSuccess.eventId) {
+        throw new PeerExecutionError("EVENT_CONFLICT", "Accepted fenced success has no prepared or finalized effect claim");
+      }
+      await persistActionOutcomeEvents(existingSuccess, existingEvents);
+      return {
+        outcome: "succeeded",
+        attemptId,
+        outputDigest: success.outputDigest,
+        ...success.providerCorrelation !== void 0 ? { providerCorrelation: success.providerCorrelation } : {}
+      };
+    }
+    if (claim.status === "succeeded") {
+      throw new PeerExecutionError("EVENT_CONFLICT", "Finalized effect claim references a Matrix success event that is unavailable");
+    }
+    const armed = await append({
+      ...eventBase({ ...base, parents: [requested.eventId] }),
+      payload: {
+        kind: "action.effect_armed",
+        attemptId,
+        stepId: command.stepId,
+        claimKey: claim.claimKey,
+        fencingEpoch: claim.fencingEpoch
+      }
+    });
+    if (claim.status === "success_prepared" && claim.outputDigest && claim.outcomesDigest) {
+      const readback = await options.actions.readback({
+        contract,
+        inputs: command.inputs,
+        providerIdempotencyKey,
+        providerCorrelation: claim.providerCorrelation,
+        invocation: authorization
+      });
+      if (readback.outcome === "succeeded") {
+        const digest = await validatedOutputDigest(contract, readback.output);
+        const outcomes = await actionOutcomes(digest, readback.outcomes);
+        if (digest === claim.outputDigest && await actionOutcomesDigest(outcomes) === claim.outcomesDigest) {
+          return persistSuccess(command, attemptId, digest, readback.outcomes, readback.providerCorrelation, claim, admission, base, armed);
+        }
+      }
+      const providerCorrelation = readback.outcome === "succeeded" || readback.outcome === "unknown" ? readback.providerCorrelation ?? claim.providerCorrelation : claim.providerCorrelation;
+      await append({
+        ...eventBase({ ...base, parents: [armed.eventId] }),
+        payload: {
+          kind: "action.needs_verification",
+          attemptId,
+          stepId: command.stepId,
+          ...providerCorrelation !== void 0 ? { providerCorrelation } : {},
+          reason: "Prepared provider result could not be reproduced with its complete outcome evidence"
+        }
+      });
+      return { outcome: "needs_verification", attemptId, ...providerCorrelation !== void 0 ? { providerCorrelation } : {} };
+    }
+    return reconcileAmbiguity(command, contract, authorization, attemptId, providerIdempotencyKey, claim, admission, base, armed, {
+      outcome: "ambiguous",
+      providerCorrelation: claim.providerCorrelation,
+      reason: "Recovered an armed effect claim"
+    });
+  }
+  async function persistSuccess(command, attemptId, digest, providedOutcomes, providerCorrelation, claim, admission, base, attemptParent) {
+    const outcomes = await actionOutcomes(digest, providedOutcomes);
+    const outcomesDigest = await actionOutcomesDigest(outcomes);
+    let durableClaim = claim;
+    if (claim && !admission) throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Effect claim authorization is unavailable");
+    if (claim && claim.status !== "success_prepared" && claim.status !== "succeeded") {
+      durableClaim = await options.effectClaims.prepareSuccess(claim.claimKey, options.executorDid, claim.fencingEpoch, digest, outcomesDigest, admission, providerCorrelation);
+    }
+    if (durableClaim && (durableClaim.outputDigest !== digest || durableClaim.outcomesDigest !== outcomesDigest)) {
+      throw new PeerExecutionError("EVENT_CONFLICT", "Prepared effect claim does not match the complete Action result evidence");
+    }
+    const success = await append({
+      ...eventBase({ ...base, parents: [attemptParent.eventId] }),
+      payload: {
+        kind: "action.succeeded",
+        attemptId,
+        stepId: command.stepId,
+        outputDigest: digest,
+        outcomes,
+        ...providerCorrelation !== void 0 ? { providerCorrelation } : {},
+        ...durableClaim ? { claimKey: durableClaim.claimKey, fencingEpoch: durableClaim.fencingEpoch } : {}
+      }
+    });
+    if (durableClaim?.status === "success_prepared") {
+      await options.effectClaims.resolve(durableClaim.claimKey, options.executorDid, durableClaim.fencingEpoch, "succeeded", admission, providerCorrelation, success.eventId);
+    }
+    await persistActionOutcomeEvents(success);
+    return { outcome: "succeeded", attemptId, outputDigest: digest, providerCorrelation };
+  }
+  async function persistActionOutcomeEvents(success, existingEvents = []) {
+    if (success.payload.kind !== "action.succeeded") throw new PeerExecutionError("EVENT_CONFLICT", "Action outcomes require accepted success evidence");
+    const successPayload = success.payload;
+    for (const outcome of successPayload.outcomes ?? []) {
+      const exists = existingEvents.some(
+        (event) => event.payload.kind === "action.outcome_emitted" && event.payload.attemptId === successPayload.attemptId && event.payload.stepId === successPayload.stepId && event.payload.name === outcome.name && event.payload.payloadDigest === outcome.payloadDigest && event.parents.includes(success.eventId)
+      );
+      if (exists) continue;
+      await append({
+        ...eventBase({
+          runId: success.runId,
+          definition: success.definition,
+          actor: success.actor,
+          issuedAt: success.occurredAt,
+          idempotencyKey: success.idempotencyKey,
+          commandFingerprint: success.commandFingerprint,
+          parents: [success.eventId],
+          proofs: success.proofReferences
+        }),
+        causationId: success.eventId,
+        payload: {
+          kind: "action.outcome_emitted",
+          attemptId: successPayload.attemptId,
+          stepId: successPayload.stepId,
+          ...outcome
+        }
+      });
+    }
+  }
+  async function reconcileAmbiguity(command, contract, authorization, attemptId, providerIdempotencyKey, claim, admission, base, attemptParent, ambiguous) {
+    const readback = await options.actions.readback({
+      contract,
+      inputs: command.inputs,
+      providerIdempotencyKey,
+      providerCorrelation: ambiguous.providerCorrelation,
+      invocation: authorization
+    });
+    if (readback.outcome === "succeeded") {
+      const digest = await validatedOutputDigest(contract, readback.output);
+      return persistSuccess(command, attemptId, digest, readback.outcomes, readback.providerCorrelation, claim, admission, base, attemptParent);
+    }
+    if (readback.outcome === "not_found" && !claim) {
+      await append({
+        ...eventBase({ ...base, parents: [attemptParent.eventId] }),
+        payload: { kind: "action.failed_before_effect", attemptId, stepId: command.stepId, error: { code: "PROVIDER_CONFIRMED_NOT_FOUND" } }
+      });
+      return { outcome: "failed_before_effect", attemptId };
+    }
+    const correlation = readback.outcome === "unknown" ? readback.providerCorrelation ?? ambiguous.providerCorrelation : ambiguous.providerCorrelation;
+    if (claim && claim.status === "armed") {
+      if (!admission) throw new PeerExecutionError("AUTHORIZATION_MISMATCH", "Effect claim authorization is unavailable");
+      await options.effectClaims.markNeedsVerification(claim.claimKey, options.executorDid, claim.fencingEpoch, admission, correlation);
+    }
+    await append({
+      ...eventBase({ ...base, parents: [attemptParent.eventId] }),
+      payload: {
+        kind: "action.needs_verification",
+        attemptId,
+        stepId: command.stepId,
+        ...correlation !== void 0 ? { providerCorrelation: correlation } : {},
+        reason: ambiguous.reason
+      }
+    });
+    return { outcome: "needs_verification", attemptId, ...correlation !== void 0 ? { providerCorrelation: correlation } : {} };
+  }
+  return { startRun, cancelRun, finalizeRun, executeAttempt };
+}
+
+// src/core/lib/flowEngine/vnext/topicReceipts.ts
+async function persistSignedTopicReceipt(params) {
+  const outbox = params.outbox;
+  const snapshot = JSON.parse(
+    canonicalizeJson({
+      topicRequestId: params.topicRequestId,
+      attemptId: params.attemptId,
+      phase: params.phase,
+      eventId: params.eventId,
+      signedReceipt: params.signedReceipt,
+      persistedAt: params.persistedAt
+    })
+  );
+  const canonicalReceipt = canonicalizeJson(snapshot.signedReceipt);
+  const receiptDigest = await digestCanonicalJson(snapshot.signedReceipt);
+  const receiptId = await deriveReceiptId({
+    topicRequestId: snapshot.topicRequestId,
+    attemptId: snapshot.attemptId,
+    phase: snapshot.phase,
+    eventId: snapshot.eventId
+  });
+  const record = {
+    kind: "qi.flow.topic-receipt-outbox-record",
+    schemaVersion: "1.0",
+    receiptId,
+    receiptDigest,
+    topicRequestId: snapshot.topicRequestId,
+    attemptId: snapshot.attemptId,
+    phase: snapshot.phase,
+    eventId: snapshot.eventId,
+    canonicalReceipt,
+    persistedAt: snapshot.persistedAt
+  };
+  const outcome = await outbox.persist(record);
+  if (outcome === "conflict") throw new Error(`Topic receipt identity ${receiptId} is already bound to different signed bytes`);
+  return record;
+}
+async function drainTopicReceiptOutbox(outbox, delivery, now = () => /* @__PURE__ */ new Date(), limit = 100) {
+  const outcomes = [];
+  for (const record of await outbox.pending(limit)) {
+    try {
+      const delivered = await delivery.deliver({
+        receiptId: record.receiptId,
+        receiptDigest: record.receiptDigest,
+        canonicalReceipt: record.canonicalReceipt
+      });
+      await outbox.markDelivered(record.receiptId, record.receiptDigest, { ...delivered, deliveredAt: now().toISOString() });
+      outcomes.push({ receiptId: record.receiptId, outcome: "delivered" });
+    } catch (error) {
+      outcomes.push({ receiptId: record.receiptId, outcome: "failed", error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return outcomes;
+}
+
+// src/core/lib/flowEngine/vnext/matrixStores.ts
+var MATRIX_FLOW_EVENT_TYPE = "ixo.qi.flow.event.v1";
+var MATRIX_FLOW_DEFINITION_ANCHOR_TYPE = "ixo.qi.flow.definition-anchor.v1";
+var MatrixRoomFlowEventStore = class {
+  constructor(roomId, transport, trust) {
+    this.roomId = roomId;
+    this.transport = transport;
+    this.trust = trust;
+  }
+  async append(event, transactionId) {
+    const verified = await verifyFlowEvent(event, this.trust);
+    const expectedTransactionId = matrixFlowEventTransactionId(verified);
+    if (transactionId !== expectedTransactionId) throw new Error(`Matrix Flow event append requires deterministic transaction ID ${expectedTransactionId}`);
+    const result = await this.transport.append({ roomId: this.roomId, eventType: MATRIX_FLOW_EVENT_TYPE, transactionId, content: { event: verified } });
+    if (result.outcome !== "conflict" && result.eventId !== verified.eventId) {
+      throw new Error(`Matrix Flow event append acknowledged unexpected event ID ${result.eventId}`);
+    }
+    return result;
+  }
+  async inspect(runId, options = {}) {
+    const acceptedEvents = [];
+    const rejectedEvents = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor;
+    do {
+      const remaining = options.limit === void 0 ? void 0 : options.limit - acceptedEvents.length;
+      if (remaining !== void 0 && remaining <= 0) break;
+      const page = await this.transport.read({ roomId: this.roomId, runId, afterEventId: options.after, cursor, limit: remaining });
+      for (const carrier of page.carriers) {
+        if (options.limit !== void 0 && acceptedEvents.length >= options.limit) break;
+        let eventSnapshot;
+        try {
+          eventSnapshot = deepFreezeJson(JSON.parse(canonicalizeJson(carrier.event)));
+        } catch {
+          eventSnapshot = deepFreezeJson(structuredClone(carrier.event));
+          rejectedEvents.push({ carrierEventId: carrier.carrierEventId, event: eventSnapshot, reason: "Flow event content cannot be canonicalized" });
+          continue;
+        }
+        try {
+          acceptedEvents.push(await verifyFlowEvent(eventSnapshot, this.trust));
+        } catch (error) {
+          if (!(error instanceof FlowEventValidationError)) throw error;
+          rejectedEvents.push({ carrierEventId: carrier.carrierEventId, event: eventSnapshot, reason: error.message });
+        }
+      }
+      if (page.nextCursor === void 0) break;
+      if (seenCursors.has(page.nextCursor)) throw new Error("Matrix Flow event transport returned a repeated cursor");
+      seenCursors.add(page.nextCursor);
+      cursor = page.nextCursor;
+    } while (true);
+    return { acceptedEvents, rejectedEvents };
+  }
+  async read(runId, options = {}) {
+    return (await this.inspect(runId, options)).acceptedEvents;
+  }
+};
+var ANCHOR_DOMAIN = "qi.flow.definition-anchor.v1\0";
+function anchorSignatureInput(digest) {
+  return new TextEncoder().encode(`${ANCHOR_DOMAIN}${digest}`);
+}
+async function signMatrixDefinitionAnchor(payload, signer) {
+  const snapshot = JSON.parse(canonicalizeJson(payload));
+  if (snapshot.anchoredBy !== signer.issuerDid || !signer.verificationMethod.startsWith(`${snapshot.anchoredBy}#`)) {
+    throw new Error("Matrix definition anchor signer does not match the issuer");
+  }
+  const digest = await digestCanonicalJson(snapshot);
+  const signature = await signer.sign(anchorSignatureInput(digest));
+  if (!signature) throw new Error("Matrix definition anchor signer returned an empty signature");
+  return {
+    ...snapshot,
+    integrity: {
+      canonicalization: "RFC8785",
+      digest: { algorithm: "SHA-256", value: digest },
+      signature: { algorithm: signer.algorithm, verificationMethod: signer.verificationMethod, value: signature }
+    }
+  };
+}
+async function verifyMatrixDefinitionAnchor(anchor, trust) {
+  const snapshot = JSON.parse(canonicalizeJson(anchor));
+  const { integrity, ...payload } = snapshot;
+  const digest = await digestCanonicalJson(payload);
+  if (digest !== integrity.digest.value) throw new Error("Matrix definition anchor digest mismatch");
+  if (!trust.trustedIssuerDids.includes(payload.anchoredBy)) throw new Error(`Matrix definition anchor issuer is not trusted: ${payload.anchoredBy}`);
+  if (!trust.allowedSignatureAlgorithms.includes(integrity.signature.algorithm)) throw new Error("Matrix definition anchor signature algorithm is not allowed");
+  if (!integrity.signature.verificationMethod.startsWith(`${payload.anchoredBy}#`)) throw new Error("Matrix definition anchor verification method does not belong to the issuer");
+  if (!await trust.verifySignature({
+    issuerDid: payload.anchoredBy,
+    verificationMethod: integrity.signature.verificationMethod,
+    algorithm: integrity.signature.algorithm,
+    data: anchorSignatureInput(digest),
+    signature: integrity.signature.value
+  })) {
+    throw new Error("Matrix definition anchor signature is invalid");
+  }
+  return deepFreezeJson(snapshot);
+}
+var EncryptedMatrixFlowDefinitionRevisionRepository = class {
+  constructor(roomId, transport, cipher, anchorSigner, anchorTrust, definitionTrust, now = () => /* @__PURE__ */ new Date()) {
+    this.roomId = roomId;
+    this.transport = transport;
+    this.cipher = cipher;
+    this.anchorSigner = anchorSigner;
+    this.anchorTrust = anchorTrust;
+    this.definitionTrust = definitionTrust;
+    this.now = now;
+  }
+  async publish(revision, expectedParent) {
+    const expectedParentSnapshot = expectedParent ? deepFreezeJson(JSON.parse(canonicalizeJson(expectedParent))) : void 0;
+    const verified = await verifyFlowDefinitionRevision(revision, this.definitionTrust);
+    if (canonicalizeJson(verified.parent ?? null) !== canonicalizeJson(expectedParentSnapshot ?? null)) {
+      return "parent_conflict";
+    }
+    const definition = { ...verified.ref, digest: verified.integrity.digest.value };
+    const plaintext = new TextEncoder().encode(canonicalizeJson(verified));
+    const ciphertext = Uint8Array.from(await this.cipher.encrypt(plaintext));
+    const ciphertextDigest = await digestCanonicalJson(Array.from(ciphertext));
+    const mediaUri = await this.transport.putMedia({
+      ciphertext,
+      ciphertextDigest,
+      contentType: "application/vnd.ixo.qi-flow-revision+json"
+    });
+    const anchor = await signMatrixDefinitionAnchor(
+      {
+        kind: "qi.flow.definition-anchor",
+        schemaVersion: "1.0",
+        definition,
+        mediaUri,
+        ciphertextDigest,
+        encryption: { algorithm: this.cipher.algorithm, keyReference: this.cipher.keyReference },
+        anchoredAt: this.now().toISOString(),
+        anchoredBy: this.anchorSigner.issuerDid
+      },
+      this.anchorSigner
+    );
+    return this.transport.publishAnchor({
+      roomId: this.roomId,
+      eventType: MATRIX_FLOW_DEFINITION_ANCHOR_TYPE,
+      transactionId: `qi-flow-definition-v1-${definition.digest.slice("sha256:".length)}`,
+      anchor,
+      expectedParent: expectedParentSnapshot
+    });
+  }
+  async get(ref) {
+    const candidate = await this.transport.getAnchor(this.roomId, ref.flowId, ref.revision);
+    if (!candidate) return null;
+    const anchor = await verifyMatrixDefinitionAnchor(candidate, this.anchorTrust);
+    if (anchor.definition.digest !== ref.digest || anchor.definition.flowId !== ref.flowId || anchor.definition.revision !== ref.revision) {
+      throw new Error("Matrix definition anchor does not match the requested revision");
+    }
+    if (anchor.encryption.algorithm !== this.cipher.algorithm || anchor.encryption.keyReference !== this.cipher.keyReference) {
+      throw new Error("Matrix definition anchor encryption binding is unavailable");
+    }
+    const ciphertext = await this.transport.getMedia(anchor.mediaUri);
+    const ciphertextDigest = await digestCanonicalJson(Array.from(ciphertext));
+    if (ciphertextDigest !== anchor.ciphertextDigest) throw new Error("Encrypted Matrix revision media digest mismatch");
+    const plaintext = await this.cipher.decrypt(ciphertext);
+    const revision = JSON.parse(new TextDecoder().decode(plaintext));
+    const verified = await verifyFlowDefinitionRevision(revision, this.definitionTrust);
+    if (verified.ref.flowId !== anchor.definition.flowId || verified.ref.revision !== anchor.definition.revision || verified.integrity.digest.value !== anchor.definition.digest) {
+      throw new Error("Decrypted Matrix revision does not match its signed anchor");
+    }
+    return verified;
+  }
+};
+
+// src/core/lib/flowEngine/vnext/composio.ts
+var ComposioContractMismatchError = class extends Error {
+  constructor(reason) {
+    super(`Composio Action is unavailable: ${reason}`);
+    this.reason = reason;
+    this.name = "ComposioContractMismatchError";
+  }
+};
+var COMPOSIO_AVAILABILITY_SIGNATURE_DOMAIN = "qi.composio.action-availability.v1\0";
+function availabilitySignatureInput(digest) {
+  return new TextEncoder().encode(`${COMPOSIO_AVAILABILITY_SIGNATURE_DOMAIN}${digest}`);
+}
+function assertAvailabilityPayload(payload) {
+  if (payload.kind !== "qi.composio.action-availability" || payload.schemaVersion !== "1.0") throw new ComposioContractMismatchError("unsupported availability contract");
+  if (!payload.issuedBy || !payload.actionContractDigest || !payload.handlerIdentity || !payload.toolSlug || !payload.accountBinding.bindingId || !payload.accountBinding.connectedAccountReference || !payload.ucanAudience) {
+    throw new ComposioContractMismatchError("availability identity and execution binding are required");
+  }
+  if (payload.readback !== "unavailable" && !payload.readbackToolSlug?.trim()) {
+    throw new ComposioContractMismatchError("required or supported readback must declare an explicit readback tool");
+  }
+  const checkedAt = Date.parse(payload.checkedAt);
+  const expiresAt = Date.parse(payload.expiresAt);
+  if (!Number.isFinite(checkedAt) || !Number.isFinite(expiresAt) || expiresAt <= checkedAt) {
+    throw new ComposioContractMismatchError("availability timestamps are invalid");
+  }
+}
+async function computeComposioAvailabilityDigest(payload) {
+  assertAvailabilityPayload(payload);
+  return await digestCanonicalJson(payload);
+}
+async function signComposioActionAvailability(payload, signer) {
+  const snapshot = JSON.parse(canonicalizeJson(payload));
+  assertAvailabilityPayload(snapshot);
+  if (signer.issuerDid !== snapshot.issuedBy || !signer.verificationMethod.startsWith(`${snapshot.issuedBy}#`)) {
+    throw new ComposioContractMismatchError("availability signer does not match the issuer");
+  }
+  const digest = await computeComposioAvailabilityDigest(snapshot);
+  const signature = await signer.sign(availabilitySignatureInput(digest));
+  if (!signature) throw new ComposioContractMismatchError("availability signer returned an empty signature");
+  return {
+    ...snapshot,
+    integrity: {
+      canonicalization: "RFC8785",
+      digest: { algorithm: "SHA-256", value: digest },
+      signature: { algorithm: signer.algorithm, verificationMethod: signer.verificationMethod, value: signature }
+    }
+  };
+}
+async function verifyComposioActionAvailability(candidate, policy, now = /* @__PURE__ */ new Date()) {
+  const snapshot = JSON.parse(canonicalizeJson(candidate));
+  const { integrity, ...payload } = snapshot;
+  assertAvailabilityPayload(payload);
+  const digest = await computeComposioAvailabilityDigest(payload);
+  if (digest !== integrity.digest.value) throw new ComposioContractMismatchError("availability digest does not match its content");
+  if (!policy.trustedIssuerDids.includes(payload.issuedBy)) throw new ComposioContractMismatchError("availability issuer is not trusted");
+  if (policy.revokedIssuerDids?.includes(payload.issuedBy)) throw new ComposioContractMismatchError("availability issuer is revoked");
+  if (!policy.allowedSignatureAlgorithms.includes(integrity.signature.algorithm)) throw new ComposioContractMismatchError("availability signature algorithm is not allowed");
+  if (!integrity.signature.verificationMethod.startsWith(`${payload.issuedBy}#`)) {
+    throw new ComposioContractMismatchError("availability verification method does not belong to the issuer");
+  }
+  if (Date.parse(payload.expiresAt) <= now.getTime()) throw new ComposioContractMismatchError("availability contract is expired");
+  const valid = await policy.verifySignature({
+    issuerDid: payload.issuedBy,
+    verificationMethod: integrity.signature.verificationMethod,
+    algorithm: integrity.signature.algorithm,
+    data: availabilitySignatureInput(digest),
+    signature: integrity.signature.value
+  });
+  if (!valid) throw new ComposioContractMismatchError("availability signature verification failed");
+  return deepFreezeJson(snapshot);
+}
+async function assertAvailability(contract, availability, authorization, now) {
+  if (Date.parse(availability.expiresAt) <= now.getTime()) throw new ComposioContractMismatchError("availability contract is expired");
+  if (availability.status !== "available") throw new ComposioContractMismatchError(availability.unavailableReasons.join("; ") || "availability endpoint is unhealthy");
+  if (availability.actionContractDigest !== contract.contractDigest) throw new ComposioContractMismatchError("Action contract digest mismatch");
+  if (availability.handlerVersion !== contract.handlerVersion) throw new ComposioContractMismatchError("handler version mismatch");
+  if (await digestCanonicalJson(contract.inputSchema) !== availability.inputSchemaDigest) throw new ComposioContractMismatchError("input schema digest mismatch");
+  if (await digestCanonicalJson(contract.outputSchema) !== availability.outputSchemaDigest) throw new ComposioContractMismatchError("output schema digest mismatch");
+  if (availability.providerIdempotency !== contract.idempotency.providerKey) throw new ComposioContractMismatchError("provider idempotency contract mismatch");
+  if (availability.readback !== contract.idempotency.readback || availability.compensation !== contract.idempotency.compensation) {
+    throw new ComposioContractMismatchError("recovery procedure mismatch");
+  }
+  if (availability.readback !== "unavailable" && !availability.readbackToolSlug?.trim()) {
+    throw new ComposioContractMismatchError("required or supported readback must declare an explicit readback tool");
+  }
+  const provider = authorization.provider;
+  if (!provider) throw new ComposioContractMismatchError("verified provider invocation is missing");
+  if (provider.audience !== availability.ucanAudience || provider.can !== "composio/execute" || provider.with !== `ixo:composio:binding:${availability.accountBinding.bindingId}` || provider.actionContractDigest !== contract.contractDigest || provider.definitionDigest !== authorization.flow.definitionDigest || provider.idempotencyKey !== authorization.flow.idempotencyKey) {
+    throw new ComposioContractMismatchError("provider UCAN does not authorize this Flow command and Action");
+  }
+}
+var ManifestBoundComposioActionAdapter = class {
+  constructor(availability, gateway, now = () => /* @__PURE__ */ new Date()) {
+    this.availability = availability;
+    this.gateway = gateway;
+    this.now = now;
+  }
+  async invoke(request) {
+    const available = await this.availability.resolve(request.contract.contractDigest);
+    await assertAvailability(request.contract, available, request.invocation, this.now());
+    request.assertEffectAllowed();
+    return this.gateway.execute({
+      toolSlug: available.toolSlug,
+      bindingId: available.accountBinding.bindingId,
+      connectedAccountReference: available.accountBinding.connectedAccountReference,
+      arguments: request.inputs,
+      providerIdempotencyKey: request.providerIdempotencyKey,
+      providerInvocationReference: request.invocation.provider.cid
+    });
+  }
+  async readback(request) {
+    const available = await this.availability.resolve(request.contract.contractDigest);
+    await assertAvailability(request.contract, available, request.invocation, this.now());
+    if (!available.readbackToolSlug) return { outcome: "unknown", providerCorrelation: request.providerCorrelation, reason: "Manifest declares no explicit readback tool" };
+    return this.gateway.readback({
+      toolSlug: available.readbackToolSlug,
+      bindingId: available.accountBinding.bindingId,
+      connectedAccountReference: available.accountBinding.connectedAccountReference,
+      arguments: request.inputs,
+      providerIdempotencyKey: request.providerIdempotencyKey,
+      providerCorrelation: request.providerCorrelation,
+      providerInvocationReference: request.invocation.provider.cid
+    });
+  }
+};
+
+// src/core/lib/flowEngine/vnext/runProjections.ts
+var FLOW_RUN_PROJECTIONS_MAP_KEY = "qi.flow.runProjections";
+var FLOW_RUN_PROJECTION_KEY_SEPARATOR = "::";
+var RUN_STATUSES = /* @__PURE__ */ new Set(["queued", "running", "cancelling", "needs_verification", "completed", "failed", "cancelled"]);
+var EFFECT_DISPOSITIONS = /* @__PURE__ */ new Set(["not_started", "armed", "succeeded", "failed_before_effect", "needs_verification"]);
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isDigest(value) {
+  return typeof value === "string" && /^sha256:[0-9a-f]{64}$/u.test(value);
+}
+function hasValidProjectionShape(value) {
+  if (!isRecord2(value)) return false;
+  if (value.kind !== "qi.flow.run-projection" || value.schemaVersion !== "1.0" || typeof value.runId !== "string" || !isDigest(value.sourceEventSetDigest)) return false;
+  if (!isRecord2(value.definition) || typeof value.definition.flowId !== "string" || typeof value.definition.revision !== "string" || !isDigest(value.definition.digest))
+    return false;
+  const sourceEventIds = value.sourceEventIds;
+  if (!isStringArray2(sourceEventIds) || canonicalizeJson(sourceEventIds) !== canonicalizeJson([...new Set(sourceEventIds)].sort())) return false;
+  const headEventIds = value.headEventIds;
+  if (!isStringArray2(headEventIds) || canonicalizeJson(headEventIds) !== canonicalizeJson([...new Set(headEventIds)].sort()) || !headEventIds.every((eventId) => sourceEventIds.includes(eventId)))
+    return false;
+  if (typeof value.status !== "string" || !RUN_STATUSES.has(value.status) || typeof value.cancelRequested !== "boolean") return false;
+  const timeline = value.timeline;
+  if (!isRecord2(value.attempts) || !Array.isArray(timeline) || !Array.isArray(value.invalidEvents)) return false;
+  for (const [attemptId, attempt] of Object.entries(value.attempts)) {
+    if (!isRecord2(attempt) || attempt.attemptId !== attemptId || typeof attempt.stepId !== "string" || typeof attempt.disposition !== "string") return false;
+    if (!EFFECT_DISPOSITIONS.has(attempt.disposition) || !isStringArray2(attempt.receiptIds) || !Array.isArray(attempt.outcomes)) return false;
+    if (attempt.outputDigest !== void 0 && !isDigest(attempt.outputDigest)) return false;
+    if (attempt.providerCorrelation !== void 0 && typeof attempt.providerCorrelation !== "string") return false;
+    if (!attempt.outcomes.every((outcome) => isRecord2(outcome) && typeof outcome.name === "string" && isRecord2(outcome.payload) && isDigest(outcome.payloadDigest))) return false;
+  }
+  if (!timeline.every(
+    (entry) => isRecord2(entry) && typeof entry.eventId === "string" && sourceEventIds.includes(entry.eventId) && typeof entry.kind === "string" && typeof entry.occurredAt === "string" && typeof entry.actor === "string" && typeof entry.producer === "string" && isStringArray2(entry.parents) && (entry.attemptId === void 0 || typeof entry.attemptId === "string") && (entry.stepId === void 0 || typeof entry.stepId === "string")
+  ))
+    return false;
+  if (!headEventIds.every((eventId) => timeline.some((entry) => isRecord2(entry) && entry.eventId === eventId))) return false;
+  return value.invalidEvents.every((entry) => isRecord2(entry) && typeof entry.eventId === "string" && sourceEventIds.includes(entry.eventId) && typeof entry.reason === "string");
+}
+function orderAcceptedEvents(events, acceptedEventIds) {
+  const accepted = new Set(acceptedEventIds);
+  const byId = /* @__PURE__ */ new Map();
+  for (const event of events) if (accepted.has(event.eventId) && !byId.has(event.eventId)) byId.set(event.eventId, event);
+  const indegree = new Map([...byId.keys()].map((eventId) => [eventId, 0]));
+  const children = /* @__PURE__ */ new Map();
+  for (const event of byId.values()) {
+    for (const parent of event.parents) {
+      if (!byId.has(parent)) continue;
+      indegree.set(event.eventId, (indegree.get(event.eventId) ?? 0) + 1);
+      children.set(parent, [...children.get(parent) ?? [], event.eventId]);
+    }
+  }
+  const ready = [...byId.keys()].filter((eventId) => indegree.get(eventId) === 0).sort();
+  const ordered = [];
+  while (ready.length > 0) {
+    const eventId = ready.shift();
+    const event = byId.get(eventId);
+    if (!event) continue;
+    ordered.push(event);
+    for (const childId of (children.get(eventId) ?? []).sort()) {
+      const next = (indegree.get(childId) ?? 0) - 1;
+      indegree.set(childId, next);
+      if (next === 0) {
+        ready.push(childId);
+        ready.sort();
+      }
+    }
+  }
+  return ordered;
+}
+function projectAttempt(attempt) {
+  return {
+    attemptId: attempt.attemptId,
+    stepId: attempt.stepId,
+    disposition: attempt.disposition,
+    receiptIds: [...attempt.receiptIds],
+    outcomes: attempt.outcomes.map((outcome) => ({ ...outcome, payload: { ...outcome.payload } })),
+    ...attempt.outputDigest !== void 0 ? { outputDigest: attempt.outputDigest } : {},
+    ...attempt.providerCorrelation !== void 0 ? { providerCorrelation: attempt.providerCorrelation } : {}
+  };
+}
+function projectTimelineEntry(event) {
+  const payload = event.payload;
+  return {
+    eventId: event.eventId,
+    kind: payload.kind,
+    occurredAt: event.occurredAt,
+    actor: event.actor,
+    producer: event.producer,
+    parents: [...event.parents],
+    ..."attemptId" in payload ? { attemptId: payload.attemptId } : {},
+    ..."stepId" in payload ? { stepId: payload.stepId } : {}
+  };
+}
+async function projectFlowRun(genesis, events) {
+  const genesisSnapshot = deepFreezeJson(JSON.parse(canonicalizeJson(genesis)));
+  const eventSnapshot = deepFreezeJson(JSON.parse(canonicalizeJson(events)));
+  const reduced = reduceFlowEvents(genesisSnapshot, eventSnapshot);
+  const sourceEventIds = [...new Set(eventSnapshot.map((event) => event.eventId))].sort();
+  const sourceEventSetDigest = await digestCanonicalJson(sourceEventIds);
+  const ordered = orderAcceptedEvents(eventSnapshot, reduced.acceptedEventIds);
+  const accepted = new Set(reduced.acceptedEventIds);
+  const referencedParents = new Set(ordered.flatMap((event) => event.parents.filter((parent) => accepted.has(parent))));
+  const headEventIds = ordered.map((event) => event.eventId).filter((eventId) => !referencedParents.has(eventId)).sort();
+  const projection = {
+    kind: "qi.flow.run-projection",
+    schemaVersion: "1.0",
+    runId: reduced.runId,
+    definition: reduced.definition,
+    sourceEventIds,
+    sourceEventSetDigest,
+    headEventIds,
+    status: reduced.status,
+    cancelRequested: reduced.cancelRequested,
+    attempts: Object.fromEntries(Object.entries(reduced.attempts).map(([id, attempt]) => [id, projectAttempt(attempt)])),
+    timeline: ordered.map(projectTimelineEntry),
+    invalidEvents: reduced.invalidEvents.map((event) => ({ ...event }))
+  };
+  return deepFreezeJson(JSON.parse(canonicalizeJson(projection)));
+}
+async function snapshotProjection(value) {
+  if (!value || typeof value !== "object") return null;
+  let snapshot;
+  try {
+    snapshot = JSON.parse(canonicalizeJson(value));
+  } catch {
+    return null;
+  }
+  if (!hasValidProjectionShape(snapshot)) return null;
+  if (await digestCanonicalJson(snapshot.sourceEventIds) !== snapshot.sourceEventSetDigest) return null;
+  return deepFreezeJson(snapshot);
+}
+function canonicalStoredProjection(value) {
+  try {
+    return canonicalizeJson(value);
+  } catch {
+    return null;
+  }
+}
+function flowRunProjectionStorageKey(runId, sourceEventSetDigest) {
+  return `${encodeURIComponent(runId)}${FLOW_RUN_PROJECTION_KEY_SEPARATOR}${sourceEventSetDigest}`;
+}
+function projectionStoragePrefix(runId) {
+  return `${encodeURIComponent(runId)}${FLOW_RUN_PROJECTION_KEY_SEPARATOR}`;
+}
+async function storedRunProjections(map, runId) {
+  const projections = [];
+  const pending = [];
+  const prefix = projectionStoragePrefix(runId);
+  map.forEach((value, key) => {
+    if (!key.startsWith(prefix)) return;
+    pending.push(
+      snapshotProjection(value).then((projection) => {
+        if (projection?.runId === runId && key === flowRunProjectionStorageKey(runId, projection.sourceEventSetDigest)) projections.push(projection);
+      })
+    );
+  });
+  await Promise.all(pending);
+  return projections;
+}
+async function readFlowRunProjection(doc, genesis, events) {
+  const map = doc.share.get(FLOW_RUN_PROJECTIONS_MAP_KEY);
+  if (!isYMapLike(map)) return null;
+  const expected = await projectFlowRun(genesis, events);
+  const projection = await snapshotProjection(map.get(flowRunProjectionStorageKey(expected.runId, expected.sourceEventSetDigest)));
+  if (!projection || projection.runId !== expected.runId) return null;
+  return canonicalizeJson(projection) === canonicalizeJson(expected) ? projection : null;
+}
+async function repairFlowRunProjection(doc, genesis, events, verifiedEvidence = events) {
+  const projection = await projectFlowRun(genesis, events);
+  const canonicalProjection = canonicalizeJson(projection);
+  const map = doc.getMap(FLOW_RUN_PROJECTIONS_MAP_KEY);
+  const storageKey = flowRunProjectionStorageKey(projection.runId, projection.sourceEventSetDigest);
+  while (true) {
+    const observedValue = map.get(storageKey);
+    const observedCanonical = canonicalStoredProjection(observedValue);
+    const current = await snapshotProjection(observedValue);
+    if (canonicalStoredProjection(map.get(storageKey)) !== observedCanonical) continue;
+    const incomingIds = new Set(projection.sourceEventIds);
+    const verifiedIds = new Set(verifiedEvidence.map((event) => event.eventId));
+    const blocking = (await storedRunProjections(map, projection.runId)).filter((candidate) => candidate.sourceEventIds.every((eventId) => verifiedIds.has(eventId))).filter((candidate) => !candidate.sourceEventIds.every((eventId) => incomingIds.has(eventId))).sort((left, right) => left.sourceEventSetDigest.localeCompare(right.sourceEventSetDigest))[0];
+    if (canonicalStoredProjection(map.get(storageKey)) !== observedCanonical) continue;
+    if (blocking) {
+      return { outcome: "stale", currentSourceEventSetDigest: blocking.sourceEventSetDigest };
+    }
+    if (current && canonicalizeJson(current) === canonicalProjection) return { outcome: "unchanged" };
+    let changedWhileWriting = false;
+    doc.transact(() => {
+      if (canonicalStoredProjection(map.get(storageKey)) !== observedCanonical) {
+        changedWhileWriting = true;
+        return;
+      }
+      map.set(storageKey, JSON.parse(canonicalProjection));
+      map.delete(projection.runId);
+    }, "vnext-run-projection-repair");
+    if (changedWhileWriting) continue;
+    return {
+      outcome: "repaired",
+      ...current ? { previousSourceEventSetDigest: current.sourceEventSetDigest } : {}
+    };
+  }
+}
+
+export {
+  LegacyFlowFrozenError,
+  assertLegacyFlowOperationAllowed,
+  deepFreezeJson,
+  canonicalizeJson,
+  digestCanonicalJson,
+  FlowDefinitionVerificationError,
+  computeExecutionPolicyDigest,
+  signExecutionPolicy,
+  verifyExecutionPolicy,
+  computeFlowDefinitionDigest,
+  signFlowDefinitionRevision,
+  verifyFlowDefinitionRevision,
+  FLOW_CAPABILITIES,
+  buildFlowResourceUri,
+  deriveRunId,
+  deriveAttemptId,
+  deriveEventId,
+  deriveReceiptId,
+  deriveEffectClaimKey,
+  FlowEventValidationError,
+  signFlowEvent,
+  verifyFlowEvent,
+  matrixFlowEventTransactionId,
+  reduceFlowEvents,
+  fingerprintFlowCommand,
+  EffectClaimTransitionError,
+  claimEffect,
+  renewEffectClaim,
+  armEffectClaim,
+  prepareEffectSuccess,
+  resolveEffectClaim,
+  markEffectNeedsVerification,
+  ActionContractResolutionError,
+  computeActionContractDigest,
+  HistoricalManifestActionContractResolver,
+  UNIVERSAL_ACTION_COMPLETED_OUTCOME,
+  PeerExecutionError,
+  createPeerExecutor,
+  persistSignedTopicReceipt,
+  drainTopicReceiptOutbox,
+  MATRIX_FLOW_EVENT_TYPE,
+  MATRIX_FLOW_DEFINITION_ANCHOR_TYPE,
+  MatrixRoomFlowEventStore,
+  signMatrixDefinitionAnchor,
+  verifyMatrixDefinitionAnchor,
+  EncryptedMatrixFlowDefinitionRevisionRepository,
+  ComposioContractMismatchError,
+  computeComposioAvailabilityDigest,
+  signComposioActionAvailability,
+  verifyComposioActionAvailability,
+  ManifestBoundComposioActionAdapter,
+  FLOW_RUN_PROJECTIONS_MAP_KEY,
+  projectFlowRun,
+  flowRunProjectionStorageKey,
+  readFlowRunProjection,
+  repairFlowRunProjection
+};
+//# sourceMappingURL=chunk-RRYBAE6E.js.map