@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-IIIZZ4E4.js

@@ -0,0 +1,1679 @@
+import {
+  warnOnce
+} from "./chunk-HT6L7A5M.js";
+import {
+  getExistingYMap,
+  isYMapLike
+} from "./chunk-NCSGIRRQ.js";
+
+// src/core/lib/actionRegistry/digest.ts
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function canonicalActionJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Action manifest cannot contain non-finite numbers");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : canonicalActionJson(item)).join(",")}]`;
+  if (typeof value === "object") {
+    const fields = Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => compareCodeUnits(a, b));
+    return `{${fields.map(([key, item]) => `${JSON.stringify(key)}:${canonicalActionJson(item)}`).join(",")}}`;
+  }
+  throw new Error(`Action manifest cannot contain ${typeof value}`);
+}
+var SHA256_K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex(text) {
+  const input = new TextEncoder().encode(text);
+  const bitLength = input.length * 8;
+  const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(input);
+  bytes[input.length] = 128;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  const state = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) words[index] = view.getUint32(offset + index * 4, false);
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let index = 0; index < 64; index += 1) {
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temp1 = h + sum1 + choice + SHA256_K[index] + words[index] >>> 0;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temp2 = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function sha256Digest(value) {
+  return `sha256:${sha256Hex(canonicalActionJson(value))}`;
+}
+
+// src/core/lib/actionRegistry/topicSemanticRecords.ts
+import Ajv2020 from "ajv/dist/2020.js";
+var stringArray = { type: "array", items: { type: "string" } };
+var digest = { type: "string", pattern: "^sha256:[a-f0-9]{64}$" };
+var dateTime = {
+  type: "string",
+  pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$"
+};
+var MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT = 25;
+var MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES = 32 * 1024;
+function closed(required, properties) {
+  return { type: "object", required, additionalProperties: false, properties };
+}
+var TOPIC_SEMANTIC_RECORD_DEFINITIONS = [
+  {
+    type: "org.ixo.topic.claim-submission",
+    version: 1,
+    displayName: "Claim submitted",
+    description: "Records that a claim was submitted to a collection.",
+    valueSchema: closed(["claimId", "collectionId", "deedDid", "submittedByDid", "submittedAt", "transactionHash", "submissionDigest"], {
+      claimId: { type: "string" },
+      collectionId: { type: "string" },
+      deedDid: { type: "string" },
+      submittedByDid: { type: "string" },
+      submittedAt: dateTime,
+      transactionHash: { type: "string" },
+      submissionDigest: digest
+    })
+  },
+  {
+    type: "org.ixo.topic.claim-evaluation",
+    version: 1,
+    displayName: "Claim evaluated",
+    description: "Records the governed evaluation outcome for a claim.",
+    valueSchema: closed(["claimId", "collectionId", "deedDid", "decision", "evaluatedByDid", "evaluatedAt", "transactionHash", "evidenceDigest"], {
+      claimId: { type: "string" },
+      collectionId: { type: "string" },
+      deedDid: { type: "string" },
+      decision: { type: "string" },
+      evaluatedByDid: { type: "string" },
+      evaluatedAt: dateTime,
+      verificationProof: { type: "string" },
+      transactionHash: { type: "string" },
+      evidenceDigest: digest
+    })
+  },
+  {
+    type: "org.ixo.topic.proposal-receipt",
+    version: 1,
+    displayName: "Governance proposal update",
+    description: "Records the creation of, or a vote on, a governance proposal.",
+    valueSchema: closed(["event", "proposalId", "proposalContractAddress"], {
+      event: { type: "string", enum: ["created", "vote-cast"] },
+      actionType: { type: "string" },
+      proposalId: { type: "string" },
+      proposalContractAddress: { type: "string" },
+      coreAddress: { type: "string" },
+      title: { type: "string" },
+      proposalTitle: { type: "string" },
+      descriptionDigest: digest,
+      proposalDescriptionDigest: digest,
+      status: { type: "string" },
+      vote: { type: "string" },
+      rationaleDigest: digest,
+      actorDid: { type: "string" },
+      votedAt: dateTime,
+      createdAt: dateTime
+    })
+  },
+  {
+    type: "org.ixo.topic.work-event",
+    version: 1,
+    displayName: "Work update",
+    description: "Records an assignment, dispatch, checkpoint, submission, or acceptance of work.",
+    valueSchema: closed(["workId", "resourceType", "phase", "assigneeDid", "note", "artifactReferences", "evidenceReferences", "actorDid", "occurredAt"], {
+      workId: { type: "string" },
+      resourceType: { type: "string" },
+      phase: { type: "string", enum: ["requested", "dispatched", "in_progress", "ready_for_review", "completed"] },
+      assigneeDid: { type: "string" },
+      note: { type: "string" },
+      artifactReferences: stringArray,
+      evidenceReferences: stringArray,
+      actorDid: { type: "string" },
+      occurredAt: dateTime
+    })
+  },
+  {
+    type: "org.ixo.topic.agent-result",
+    version: 1,
+    displayName: "Agent result",
+    description: "Records a delegated agent result and its evidence references without exposing invocation inputs.",
+    valueSchema: closed(["sessionId", "result", "resultDigest", "evidenceReferences", "evidenceDigest", "providerReceiptReference"], {
+      sessionId: { type: "string" },
+      result: { description: "Provider-owned result extension point." },
+      resultDigest: digest,
+      evidenceReferences: stringArray,
+      evidenceDigest: digest,
+      providerReceiptReference: { type: "string" }
+    })
+  },
+  {
+    type: "org.ixo.topic.agent-cancellation",
+    version: 1,
+    displayName: "Agent cancelled",
+    description: "Records cancellation of a delegated agent session.",
+    valueSchema: closed(["sessionId", "status", "providerReceiptReference"], {
+      sessionId: { type: "string" },
+      status: { const: "cancelled" },
+      providerReceiptReference: { type: "string" }
+    })
+  },
+  {
+    type: "org.ixo.topic.evidence",
+    version: 1,
+    displayName: "Evidence collected",
+    description: "Records collected evidence, provenance, and stable evidence references.",
+    valueSchema: closed(["question", "evidence", "provenance", "evidenceReferences", "evidenceDigest"], {
+      question: { type: "string" },
+      evidence: { description: "Provider-owned evidence extension point." },
+      provenance: { description: "Provider-owned provenance extension point." },
+      evidenceReferences: stringArray,
+      evidenceDigest: digest
+    })
+  },
+  ...["proposed", "accepted"].map(
+    (status) => ({
+      type: `org.ixo.topic.${status}-answer`,
+      version: 1,
+      displayName: status === "accepted" ? "Answer accepted" : "Answer proposed",
+      description: status === "accepted" ? "Records an answer accepted by the stated authority." : "Records an answer proposed for review.",
+      valueSchema: closed(["answer", "status", "proposedAnswerRecordId", "authorityDid", "evidenceReferences", "limitations", "occurredAt"], {
+        answer: { type: "string" },
+        status: { const: status },
+        proposedAnswerRecordId: { type: "string" },
+        authorityDid: { type: "string" },
+        evidenceReferences: stringArray,
+        limitations: { type: "string" },
+        occurredAt: dateTime
+      })
+    })
+  ),
+  ...["assertion", "review"].map(
+    (kind) => ({
+      type: `org.ixo.topic.evaluation-${kind}`,
+      version: 1,
+      displayName: kind === "review" ? "Evaluation reviewed" : "Evaluation assertion",
+      description: kind === "review" ? "Records a signed human review of an evaluation assertion." : "Records a signed evaluation assertion.",
+      valueSchema: closed(
+        [kind === "review" ? "reviewId" : "assertionId", "providerResult", "methodologyRevision", "rubricRevision", "evaluatorDid", "evidenceReferences", "signature"],
+        {
+          assertionId: { type: "string" },
+          reviewId: { type: "string" },
+          providerResult: { type: "object", description: "Provider-owned evaluation result extension point.", additionalProperties: true },
+          methodologyRevision: { type: "string" },
+          rubricRevision: { type: "string" },
+          evaluatorDid: { type: "string" },
+          evidenceReferences: stringArray,
+          signature: { type: "string" }
+        }
+      )
+    })
+  ),
+  {
+    type: "org.ixo.topic.settlement-record",
+    version: 1,
+    displayName: "Settlement update",
+    description: "Records the provider reference and terminal status of an approved settlement execution.",
+    valueSchema: closed(["settlementId", "transactionReference", "providerReceiptReference", "status"], {
+      settlementId: { type: "string" },
+      transactionReference: { type: "string" },
+      providerReceiptReference: { type: "string" },
+      status: { type: "string", enum: ["submitted", "confirmed", "needs_verification"] }
+    })
+  },
+  {
+    type: "org.ixo.topic.incident-escalation",
+    version: 1,
+    displayName: "Incident escalated",
+    description: "Records that an incident was escalated to the stated recipients.",
+    valueSchema: closed(["severity", "affectedResources", "recipients", "evidenceReferences", "summary", "escalationId", "notifiedAt", "providerReceiptReferences"], {
+      severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
+      affectedResources: stringArray,
+      recipients: stringArray,
+      evidenceReferences: stringArray,
+      summary: { type: "string" },
+      escalationId: { type: "string" },
+      notifiedAt: dateTime,
+      providerReceiptReferences: stringArray
+    })
+  },
+  {
+    type: "org.ixo.topic.incident-mitigation",
+    version: 1,
+    displayName: "Incident mitigation recorded",
+    description: "Records mitigation work for an incident without changing the incident lifecycle.",
+    valueSchema: closed(["mitigation", "affectedResources", "evidenceReferences", "recordedBy", "occurredAt"], {
+      mitigation: { type: "string" },
+      affectedResources: stringArray,
+      evidenceReferences: stringArray,
+      recordedBy: { type: "string" },
+      occurredAt: dateTime
+    })
+  }
+];
+var definitionsByType = new Map(TOPIC_SEMANTIC_RECORD_DEFINITIONS.map((definition) => [definition.type, definition]));
+var ajv = new Ajv2020({ allErrors: true, strict: false });
+var validators = /* @__PURE__ */ new Map();
+function getTopicSemanticRecordDefinitions(types) {
+  return types.map((type) => definitionsByType.get(type)).filter((definition) => !!definition);
+}
+function validateTopicSemanticRecord(record, topic) {
+  if (!record || typeof record !== "object" || Array.isArray(record)) return { valid: false, code: "INVALID_RECORD_ENVELOPE" };
+  const candidate = record;
+  const envelopeKeys = /* @__PURE__ */ new Set(["type", "id", "version", "value", "evidenceReferences"]);
+  if (Object.keys(candidate).some((key) => !envelopeKeys.has(key)) || typeof candidate.type !== "string" || typeof candidate.id !== "string" || !candidate.id || !Number.isInteger(candidate.version) || Number(candidate.version) < 1 || !candidate.value || typeof candidate.value !== "object" || Array.isArray(candidate.value)) {
+    return { valid: false, code: "INVALID_RECORD_ENVELOPE" };
+  }
+  if (candidate.evidenceReferences !== void 0 && (!Array.isArray(candidate.evidenceReferences) || candidate.evidenceReferences.some((item) => typeof item !== "string"))) {
+    return { valid: false, code: "INVALID_RECORD_ENVELOPE" };
+  }
+  const definition = topic.semanticRecordTypes.find((item) => item.type === candidate.type);
+  if (!definition) return { valid: false, code: "UNKNOWN_RECORD_TYPE" };
+  if (candidate.version !== definition.version) return { valid: false, code: "UNSUPPORTED_RECORD_VERSION" };
+  const validatorKey = `${definition.type}@${definition.version}:${sha256Digest(definition.valueSchema)}`;
+  let validate = validators.get(validatorKey);
+  if (!validate) {
+    validate = ajv.compile(definition.valueSchema);
+    validators.set(validatorKey, validate);
+  }
+  if (!validate(candidate.value)) return { valid: false, code: "INVALID_RECORD_VALUE", errors: validate.errors || void 0 };
+  return { valid: true, definition };
+}
+function validateTopicSemanticRecordBatch(records, topic) {
+  if (records.length > MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT) return { valid: false, code: "TOO_MANY_RECORDS" };
+  for (const record of records) {
+    const validation = validateTopicSemanticRecord(record, topic);
+    if (!validation.valid) return validation;
+  }
+  try {
+    const byteLength = new TextEncoder().encode(canonicalActionJson(records)).byteLength;
+    if (byteLength > MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES) return { valid: false, code: "RECORD_BATCH_TOO_LARGE" };
+  } catch {
+    return { valid: false, code: "INVALID_RECORD_BATCH" };
+  }
+  return { valid: true };
+}
+
+// src/core/lib/actionRegistry/canMapping.ts
+var CAN_TO_TYPE = {
+  "flow/run.start": "qi/flow.run.start",
+  "flow/run.close": "qi/flow.run.close",
+  "bid/submit": "qi/bid.submit",
+  "bid/evaluate": "qi/bid.evaluate",
+  "claim/submit": "qi/claim.submit",
+  "claim/evaluate": "qi/claim.evaluate",
+  "collection/lifecycle": "qi/collection.lifecycle",
+  "collection/users": "qi/collection.users",
+  "email/send": "qi/email.send",
+  "notification/push": "qi/notification.push",
+  "matrix/dm": "qi/matrix.dm",
+  "proposal/create": "qi/proposal.create",
+  "proposal/vote": "qi/proposal.vote",
+  "governance/member-proposal": "qi/governance.member-proposal",
+  "governance/settings-proposal": "qi/governance.settings-proposal",
+  "governance.transaction/send-funds": "qi/governance.transaction.send-funds",
+  "domain/card-preview": "qi/domain.card-preview",
+  "domain/sign": "qi/domain.sign",
+  "credential/store": "qi/credential.store",
+  "funding/verify": "qi/funding.verify",
+  "credential/issue": "qi/credential.issue",
+  "yoma/opportunity": "qi/yoma.opportunity",
+  "yoid/link": "qi/yoid.link",
+  "outcome/certificate": "qi/outcome.certificate",
+  "http/request": "qi/http.request",
+  "protocol/select": "qi/protocol.select",
+  "human/checkbox": "qi/human.checkbox.set",
+  "human/form": "qi/human.form.submit",
+  "oracle/query": "oracle",
+  "pod/domain-indexer-lookup": "qi/pod.domain-indexer-lookup",
+  "pod/domain-single-selection": "qi/pod.domain-single-selection",
+  "pod/entity-single-selection": "qi/pod.entity-single-selection",
+  "pod/governance-config": "qi/pod.governance-config",
+  "pod/member-multi-select": "qi/pod.member-multi-select",
+  "pod/list-domain-flows": "qi/pod.list-domain-flows",
+  "blueprint/workspace-start": "qi/blueprint.workspace-start",
+  "blueprint/journey-resume": "qi/blueprint.journey-resume",
+  "blueprint/guided-authoring": "qi/blueprint.guided-authoring",
+  "blueprint/artifact-preview": "qi/blueprint.artifact-preview",
+  "blueprint/artifact-save": "qi/blueprint.artifact-save",
+  "blueprint/checklist-update": "qi/blueprint.checklist-update",
+  "blueprint/phase-commit": "qi/blueprint.phase-commit",
+  "blueprint/phase-confirm": "qi/blueprint.phase-confirm",
+  "blueprint/reviewer-assign": "qi/blueprint.reviewer-assign",
+  "blueprint/review-submit": "qi/blueprint.review-submit",
+  "blueprint/review-respond": "qi/blueprint.review-respond",
+  "blueprint/release-compile": "qi/blueprint.release-compile",
+  "blueprint/yoma-readiness": "qi/blueprint.yoma-readiness",
+  "blueprint/publish": "qi/blueprint.publish",
+  // Delegated integrations (author connects once, runners execute on their behalf)
+  "gmail.email/send": "qi/gmail.email.send",
+  "outlook.email/send": "qi/outlook.email.send",
+  "slack.message/send": "qi/slack.message.send",
+  "googlecalendar.event/create": "qi/googlecalendar.event.create",
+  // Google Calendar, self-connected (renamed from qi/calendar.* — IXO-4420 §5).
+  // The cans keep their historical values so existing UCAN grants still match.
+  "calendar.event/create": "qi/googlecalendar.event.create-self",
+  "calendar.event/update": "qi/googlecalendar.event.update-self",
+  "calendar.event/list": "qi/googlecalendar.event.list-self",
+  // Xero integration
+  "xero.contact/create": "qi/xero.contact.create",
+  "xero.invoice/create": "qi/xero.invoice.create",
+  "xero.invoice/list": "qi/xero.invoice.list",
+  "xero.payment/create": "qi/xero.payment.create",
+  // Oracle / wallet / matrix lifecycle
+  "wallet/generate": "qi/wallet.generate",
+  "wallet/fund": "qi/wallet.fund",
+  "iid/create": "qi/iid.create",
+  "matrix/register": "qi/matrix.register",
+  "entity/createOracle": "qi/entity.createOracle",
+  "sandbox/provision": "qi/sandbox.provision",
+  "oracle/contract": "qi/oracle.contract",
+  "oracle/storeSecrets": "qi/oracle.storeSecrets",
+  "oracle/storeConfig": "qi/oracle.storeConfig",
+  "oracle/configureOracle": "qi/oracle.configureOracle"
+};
+var TYPE_TO_CAN = Object.fromEntries(Object.entries(CAN_TO_TYPE).map(([can, type]) => [type, can]));
+function canToType(can) {
+  return CAN_TO_TYPE[can];
+}
+function typeToCan(type) {
+  return TYPE_TO_CAN[type];
+}
+function getAllCanMappings() {
+  return Object.entries(CAN_TO_TYPE).map(([can, type]) => ({ can, type }));
+}
+
+// src/core/lib/actionRegistry/presentation.ts
+var PRESENTATION = {
+  oracle: { displayName: "Ask your Agent", description: "Send a prompt to the Personal Agent" },
+  "oracle.prompt": { displayName: "Oracle Prompt", description: "Send a prompt to the Personal Agent" },
+  "qi/bid.evaluate": { displayName: "Evaluate Bid", description: "Approve or reject a bid" },
+  "qi/bid.submit": { displayName: "Bid", description: "Submit a bid application" },
+  "qi/agent.cancel": { displayName: "Cancel Agent", description: "Cancel a delegated agent session" },
+  "qi/agent.invoke": { displayName: "Invoke Agent", description: "Delegate a task to an authorised agent runtime" },
+  "qi/answer.accept": { displayName: "Accept Answer", description: "Accept a proposed answer using the stated authority" },
+  "qi/answer.propose": { displayName: "Propose Answer", description: "Propose an answer for review in the Topic" },
+  "qi/blueprint.artifact-preview": { displayName: "Preview Blueprint Artifact", description: "Preview an authored Blueprint artifact before saving it" },
+  "qi/blueprint.artifact-save": { displayName: "Save Blueprint Artifact", description: "Save an authored artifact to the Blueprint workspace" },
+  "qi/blueprint.checklist-update": { displayName: "Update Blueprint Checklist", description: "Record progress against the Blueprint authoring checklist" },
+  "qi/blueprint.guided-authoring": { displayName: "Guide Blueprint Authoring", description: "Generate guided authoring input for the current Blueprint phase" },
+  "qi/blueprint.journey-resume": { displayName: "Resume Blueprint Journey", description: "Resume an existing Blueprint authoring journey" },
+  "qi/blueprint.phase-commit": { displayName: "Commit Blueprint Phase", description: "Commit the agreed answers for this phase of the design" },
+  "qi/blueprint.phase-confirm": { displayName: "Confirm Blueprint Phase", description: "Confirm completion of the current Blueprint authoring phase" },
+  "qi/blueprint.publish": { displayName: "Publish Blueprint", description: "Publish an approved Blueprint release" },
+  "qi/blueprint.release-compile": { displayName: "Compile Blueprint Release", description: "Compile Blueprint artifacts into a release candidate" },
+  "qi/blueprint.review-respond": { displayName: "Respond to Blueprint Review", description: "Respond to review feedback on a Blueprint release" },
+  "qi/blueprint.review-submit": { displayName: "Submit Blueprint Review", description: "Submit a Blueprint release for review" },
+  "qi/blueprint.reviewer-assign": { displayName: "Assign Blueprint Reviewer", description: "Assign a reviewer to a Blueprint release" },
+  "qi/blueprint.protocol-mint": { displayName: "Mint Protocol", description: "Create the protocol from the published design so working domains can be set up from it" },
+  "qi/blueprint.workspace-start": { displayName: "Start Blueprint Workspace", description: "Create a workspace for a new Blueprint authoring journey" },
+  "qi/blueprint.yoma-readiness": { displayName: "Check Blueprint Readiness", description: "Report how far the design has progressed towards publication" },
+  "qi/calendar.event.create": { displayName: "Create Calendar event", description: "Create an event on a connected Calendar" },
+  "qi/calendar.event.list": { displayName: "List Calendar events", description: "Fetch events from a connected Calendar" },
+  "qi/calendar.event.update": { displayName: "Update Calendar event", description: "Replace an existing Calendar event" },
+  "qi/carbon.harvest": { displayName: "Harvest Carbon", description: "Claim carbon credits into your wallet" },
+  "qi/carbon.loadBatches": { displayName: "Load Carbon Batches", description: "Reconcile harvestable and retireable CARBON credits" },
+  "qi/carbon.retire": { displayName: "Retire Carbon", description: "Permanently retire carbon credits to offset impact" },
+  "qi/claim.evaluate": { displayName: "Evaluate Claim", description: "Approve or reject a claim" },
+  "qi/claim.submit": { displayName: "Claim", description: "Submit a claim" },
+  "qi/collection.lifecycle": { displayName: "Claim Collection", description: "Create and manage a claim collection lifecycle" },
+  "qi/collection.create": { displayName: "Create Claim Collection", description: "Pin a protocol release and create its exact on-chain collection record" },
+  "qi/collection.users": { displayName: "Collection Users", description: "Add, list and revoke claim collection contributors & evaluators" },
+  "qi/credential.issue": { displayName: "Issue Credential", description: "Issue a verifiable credential to a participant" },
+  "qi/credential.store": { displayName: "Store Credential", description: "Store a verifiable credential in Matrix room state" },
+  "qi/funding.verify": { displayName: "Verify Funding", description: "Confirm the payout source holds enough funds before claims are evaluated" },
+  "qi/domain.card-preview": { displayName: "Preview Domain Card", description: "Review an oracle-enriched domain card and approve it before signing" },
+  "qi/domain.sign": { displayName: "Sign Domain", description: "Sign the domain card credential and create the entity on-chain" },
+  "qi/email.send": { displayName: "Email", description: "Send an email to a user" },
+  "qi/eval.connect": { displayName: "Connect Evaluation Service", description: "Authorize one evaluation service for one existing claim collection" },
+  "qi/eval.engine": { displayName: "Evaluation Engine", description: "Enroll a collection and publish its claim-approval rules in one step" },
+  "qi/evaluation.review": { displayName: "Review Evaluation", description: "Review and sign an evaluation assertion" },
+  "qi/evaluation.run": { displayName: "Run Evaluation", description: "Run an evaluation against the selected methodology and rubric" },
+  "qi/evidence.collect": { displayName: "Collect Evidence", description: "Collect evidence and provenance from approved sources" },
+  "qi/flow.run.close": { displayName: "Close Flow Run", description: "Close the current Flow run with a terminal outcome" },
+  "qi/flow.run.start": { displayName: "Start Flow Run", description: "Start a new governed Flow run" },
+  "qi/entity.createOracle": { displayName: "Create Oracle Entity", description: "Create the oracle entity on-chain" },
+  "qi/entity.transfer": { displayName: "Transfer Entity", description: "Transfer ownership of an entity to a new owner" },
+  "qi/form.submit": { displayName: "Form Submit", description: "Submit a form response" },
+  "qi/gmail.email.send": { displayName: "Send Gmail email", description: "Send an email from the template author's Gmail account" },
+  "qi/googlecalendar.event.create": { displayName: "Create Calendar event (delegated)", description: "Create an event on the template author's Google Calendar" },
+  "qi/googlecalendar.event.create-self": { displayName: "Create Calendar event", description: "Create an event on a connected Calendar" },
+  "qi/googlecalendar.event.list-self": { displayName: "List Calendar events", description: "Fetch events from a connected Calendar" },
+  "qi/googlecalendar.event.update-self": { displayName: "Update Calendar event", description: "Replace an existing Calendar event" },
+  "qi/governance.authz.exec": { displayName: "Execute Authorized Action", description: "Propose executing a message the POD was authorized to run" },
+  "qi/governance.authz.grant": { displayName: "Grant Authorization", description: "Propose granting an address authorization to act for the POD" },
+  "qi/governance.authz.revoke": { displayName: "Revoke Authorization", description: "Propose revoking a previously granted authorization" },
+  "qi/governance.chain-governance-vote": { displayName: "Chain Governance Vote", description: "Propose casting the POD's vote on a chain governance proposal" },
+  "qi/governance.contract.execute": { displayName: "Execute Contract", description: "Propose executing a message on a smart contract as the DAO" },
+  "qi/governance.contract.instantiate": { displayName: "Instantiate Contract", description: "Propose instantiating a new smart contract from a code id" },
+  "qi/governance.contract.manage-cw20": { displayName: "Manage Token List", description: "Propose tracking or untracking a cw20 token in the DAO treasury" },
+  "qi/governance.contract.migrate": { displayName: "Migrate Contract", description: "Propose migrating a smart contract the DAO administers to a new code id" },
+  "qi/governance.contract.update-admin": { displayName: "Update Contract Admin", description: "Propose transferring admin rights over a smart contract to a new address" },
+  "qi/governance.custom-message": { displayName: "Custom Message", description: "Propose executing a raw JSON cosmos message (advanced)" },
+  "qi/governance.dao.accept-to-marketplace": { displayName: "Accept to Marketplace", description: "Propose marking an entity as verified on the marketplace" },
+  "qi/governance.dao.admin-exec": { displayName: "DAO Admin Execute", description: "Propose executing admin messages on a SubDAO this POD administers" },
+  "qi/governance.dao.create-entity": { displayName: "Create Entity", description: "Propose broadcasting a raw entity-creation message" },
+  "qi/governance.dao.join": { displayName: "Join Entity", description: "Propose linking this POD as a member of another entity" },
+  "qi/governance.dao.manage-storage": { displayName: "Manage Storage Items", description: "Propose setting or removing an item in the DAO's on-chain storage" },
+  "qi/governance.dao.manage-subdaos": { displayName: "Manage SubDAOs", description: "Propose recognising or removing SubDAOs of this DAO" },
+  "qi/governance.dao.update-info": { displayName: "Update DAO Info", description: "Propose replacing the DAO's name, description and image" },
+  "qi/governance.member-proposal": { displayName: "Membership Proposal", description: "Propose adding/removing members or changing voting power" },
+  "qi/governance.nft.burn": { displayName: "Burn NFT", description: "Propose permanently burning an NFT held by the treasury" },
+  "qi/governance.nft.manage-collections": { displayName: "Manage NFT Collections", description: "Propose tracking or untracking an NFT collection in the treasury" },
+  "qi/governance.nft.transfer": { displayName: "Transfer NFT", description: "Propose transferring an NFT from the treasury" },
+  "qi/governance.settings-proposal": { displayName: "Governance Settings Proposal", description: "Propose new voting rules (period, quorum, thresholds)" },
+  "qi/governance.staking.stake": { displayName: "Stake Treasury Tokens", description: "Propose staking treasury IXO with a validator \u2014 stake, unstake, restake or claim rewards" },
+  "qi/governance.staking.stake-to-group": { displayName: "Stake to POD", description: "Propose staking treasury cw20 tokens into a POD's staking contract" },
+  "qi/governance.submission-config-proposal": { displayName: "Proposal Submission Rules", description: "Propose changing who may submit proposals and the required deposit" },
+  "qi/governance.transaction.mint": { displayName: "Mint Governance Tokens", description: "Propose minting new governance tokens to an address" },
+  "qi/governance.transaction.perform-token-swap": { displayName: "Fund Token Swap", description: "Propose funding the POD\u2019s side of a token swap contract" },
+  "qi/governance.transaction.send-funds": { displayName: "Send Funds", description: "Propose sending funds from the POD treasury" },
+  "qi/governance.transaction.send-group-token": { displayName: "Send POD Tokens", description: "Propose transferring cw20 POD tokens from the treasury" },
+  "qi/governance.transaction.withdraw-token-swap": { displayName: "Withdraw Token Swap", description: "Propose withdrawing the POD\u2019s funds from a token swap contract" },
+  "qi/governance.validator.actions": { displayName: "Validator Actions", description: "Propose a validator operation with the POD's validator account" },
+  "qi/http.request": { displayName: "HTTP Request", description: "Make an HTTP API request" },
+  "qi/http.fetch": { displayName: "Fetch HTTP Resource", description: "Read data from an HTTP endpoint" },
+  "qi/incident.escalate": { displayName: "Escalate Incident", description: "Notify the stated recipients about an incident escalation" },
+  "qi/incident.mitigation.record": { displayName: "Record Incident Mitigation", description: "Record mitigation work and evidence for an incident" },
+  "qi/human.checkbox.set": { displayName: "Checkbox Set", description: "Record a checkbox response" },
+  "qi/human.form.submit": { displayName: "Human Form Submit", description: "Submit a human-completed form" },
+  "qi/identity.create": { displayName: "Create Identity", description: "Create an IID document and Matrix account for a user" },
+  "qi/iid.create": { displayName: "Create IID", description: "Create an IID document on-chain" },
+  "qi/kyc.verify": { displayName: "Identity Verification (KYC)", description: "Verify your identity and save the issued credential to your Vault" },
+  "qi/matrix.dm": { displayName: "Matrix DM", description: "Send a direct message via Matrix" },
+  "qi/matrix.register": { displayName: "Register Matrix Account", description: "Create a Matrix account and access token" },
+  "qi/notification.push": { displayName: "Push Notification", description: "Send a push notification" },
+  "qi/oracle.configureOracle": { displayName: "Configure Oracle", description: "Store oracle secrets and configuration in one step" },
+  "qi/oracle.contract": { displayName: "Create Oracle Contract", description: "Establish the user-oracle Matrix DM room" },
+  "qi/oracle.deploy": { displayName: "Deploy Oracle", description: "Build, deploy, and start the oracle" },
+  "qi/oracle.deploySetup": { displayName: "Set Up Oracle Deployment", description: "Build and prepare the oracle for deployment" },
+  "qi/oracle.deployStart": { displayName: "Start Oracle Deployment", description: "Start the oracle deployment process" },
+  "qi/oracle.invoke": { displayName: "Ask your Agent", description: "Send a prompt to the Personal Agent" },
+  "qi/oracle.storeConfig": { displayName: "Store Oracle Config", description: "Store the oracle configuration in Matrix room state" },
+  "qi/oracle.storeSecrets": { displayName: "Store Oracle Secrets", description: "Store oracle secrets in Matrix room state" },
+  "qi/oracle.storeSecretsAndConfig": { displayName: "Store Oracle Secrets & Config", description: "Store oracle secrets and configuration in Matrix room state" },
+  "qi/outlook.email.send": { displayName: "Send Outlook email", description: "Send an email from the template author's Outlook account" },
+  "qi/pod.domain-indexer-lookup": { displayName: "Define Purpose", description: "Capture intent and find matching Blueprint candidates" },
+  "qi/pod.domain-single-selection": { displayName: "Select Blueprint", description: "Choose a Blueprint protocol for the POD" },
+  "qi/pod.entity-single-selection": { displayName: "Select Parent Organisation", description: "Pick a parent entity where you hold a role" },
+  "qi/pod.governance-config": { displayName: "Configure Governance", description: "Set the governance group type and decision policy" },
+  "qi/pod.list-domain-flows": { displayName: "Select Flow Templates", description: "Choose protocol flow templates to import" },
+  "qi/pod.member-multi-select": { displayName: "Configure Membership", description: "Define POD members, roles, and voting power" },
+  "qi/proposal.create": { displayName: "Create Proposal", description: "Create an on-chain governance proposal" },
+  "qi/proposal.vote": { displayName: "Vote on Proposal", description: "Cast a vote on a governance proposal" },
+  "qi/protocol.select": { displayName: "Select Protocol", description: "Select a protocol from a configured list" },
+  "qi/sandbox.provision": { displayName: "Provision Sandbox", description: "Provision a sandbox environment for the oracle" },
+  "qi/settlement.execute": { displayName: "Execute Settlement", description: "Execute an approved settlement using the configured provider" },
+  "qi/slack.message.send": { displayName: "Post Slack message", description: "Post a message to a channel from the template author's Slack account" },
+  "qi/topic.action.cancel": { displayName: "Cancel Topic Action", description: "Cancel an outstanding governed Action request" },
+  "qi/topic.action.receipt.record": { displayName: "Record Action Receipt", description: "Record a signed Action receipt against its Topic request" },
+  "qi/topic.action.request": { displayName: "Request Topic Action", description: "Request an Action against the current Topic revision" },
+  "qi/topic.context.link": { displayName: "Link Topic Context", description: "Link a referenced resource or service to the Topic" },
+  "qi/topic.contract.confirm-setup": { displayName: "Confirm Topic Setup", description: "Confirm the exact proposed Topic setup revision" },
+  "qi/topic.decision.record": { displayName: "Record Topic Decision", description: "Record an authorised decision and its rationale" },
+  "qi/topic.file.attach-reference": { displayName: "Attach File Reference", description: "Attach a pinned VFS file reference to the Topic" },
+  "qi/topic.flow.bind": { displayName: "Bind Flow to Topic", description: "Bind a governed Flow revision to the Topic" },
+  "qi/topic.flow.unbind": { displayName: "Unbind Flow from Topic", description: "Remove an existing Flow binding from the Topic" },
+  "qi/outcome.certificate": { displayName: "Issue Outcome Certificate", description: "Certify that a promised outcome was achieved and evidenced" },
+  "qi/topic.outcome.confirm": { displayName: "Confirm Topic Outcome", description: "Confirm a proposed outcome using the stated authority" },
+  "qi/topic.outcome.propose": { displayName: "Propose Topic Outcome", description: "Propose an evidence-backed outcome for review" },
+  "qi/topic.status.transition": { displayName: "Change Topic Status", description: "Move the Topic between permitted lifecycle statuses" },
+  "qi/yoid.link": { displayName: "Link YoID", description: "Link a participant to their Yoma identity" },
+  "qi/yoma.opportunity": { displayName: "Publish Yoma Opportunity", description: "Publish an opportunity young people can take part in" },
+  "qi/wallet.fund": { displayName: "Fund Wallet", description: "Fund a wallet with an on-chain transfer" },
+  "qi/wallet.generate": { displayName: "Generate Wallet", description: "Generate an IXO wallet and DID" },
+  "qi/wallet.generateAndFund": { displayName: "Generate & Fund Wallet", description: "Generate an IXO wallet and fund it on-chain" },
+  "qi/work.accept": { displayName: "Accept Work", description: "Accept submitted work using the stated authority" },
+  "qi/work.assign": { displayName: "Assign Work", description: "Assign a referenced unit of work" },
+  "qi/work.checkpoint": { displayName: "Record Work Checkpoint", description: "Record progress and evidence for work in progress" },
+  "qi/work.dispatch": { displayName: "Dispatch Work", description: "Dispatch assigned work to its assignee" },
+  "qi/work.submit": { displayName: "Submit Work", description: "Submit completed work for review" },
+  "qi/xero.contact.create": { displayName: "Create Xero contact", description: "Add a customer or supplier in Xero" },
+  "qi/xero.invoice.create": { displayName: "Create Xero invoice", description: "Draft a new Xero invoice" },
+  "qi/xero.invoice.list": { displayName: "List Xero invoices", description: "Fetch invoices from Xero" },
+  "qi/xero.payment.create": { displayName: "Record Xero payment", description: "Settle a Xero bill \u2014 typically wired to capture an on-chain tx hash as the reference" }
+};
+function humanizeActionType(type) {
+  const withoutNamespace = type.replace(/^qi\//, "").replace(/^oracle\.?/, "oracle ");
+  const words = withoutNamespace.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[./_-]+/).filter(Boolean);
+  return words.map((word) => /^(iid|kyc|dao|nft|http|dm|pod|cw20)$/i.test(word) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getActionPresentation(type) {
+  const registered = PRESENTATION[type];
+  if (registered) return registered;
+  const displayName = humanizeActionType(type) || "Action";
+  return { displayName, description: `Perform ${displayName.toLowerCase()} as part of this flow.` };
+}
+
+// src/core/lib/actionRegistry/types.ts
+var TOPIC_ACTION_BASE_KINDS = ["task", "agent_task", "proposal", "evaluation", "claims", "question", "discussion", "incident"];
+var CollectionStateEnum = /* @__PURE__ */ ((CollectionStateEnum2) => {
+  CollectionStateEnum2[CollectionStateEnum2["OPEN"] = 0] = "OPEN";
+  CollectionStateEnum2[CollectionStateEnum2["PAUSED"] = 1] = "PAUSED";
+  CollectionStateEnum2[CollectionStateEnum2["CLOSED"] = 2] = "CLOSED";
+  return CollectionStateEnum2;
+})(CollectionStateEnum || {});
+
+// src/core/lib/actionRegistry/topicPolicy.ts
+var ALL_KINDS = [...TOPIC_ACTION_BASE_KINDS];
+var HUMAN_OWNED = [
+  /^qi\/human\./,
+  /^qi\/governance\./,
+  /^qi\/proposal\./,
+  /^qi\/(claim|bid)\.(submit|evaluate)$/,
+  /^qi\/(domain\.sign|entity\.|iid\.|identity\.|kyc\.)/,
+  /^qi\/(carbon\.(harvest|retire)|wallet\.fund)/,
+  // qi/xero.invoice.create and qi/xero.payment.create are deliberately absent:
+  // they are agent-owned. A headless runner contracts them out to the Xero
+  // helper oracle through @ixo/flow-work, and that oracle acts on the user's
+  // own delegated Composio authority, so no human surface is needed at
+  // execution time. qi/xero.payment.create stays riskTier 'high' — risk and
+  // execution owner are separate decisions.
+  /^qi\/settlement\./,
+  /^qi\/topic\.(flow\.(bind|unbind)|status\.transition|contract\.accept|outcome\.confirm)$/,
+  /^qi\/work\.accept$/,
+  /^qi\/answer\.accept$/
+];
+var RESTRICTED = [/^qi\/oracle\.(configure|deploy|store)/i, /^qi\/(matrix\.register|sandbox\.provision|entity\.createOracle|wallet\.generate)/];
+function any(patterns, value) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function requiredServices(type) {
+  if (type.startsWith("qi/http.")) return ["http"];
+  if (type === "qi/email.send") return ["email"];
+  if (type === "qi/notification.push") return ["notifications"];
+  if (/^qi\/(gmail|outlook|slack|googlecalendar|calendar|xero)\./.test(type)) return ["integrations"];
+  if (/^qi\/flow\.run\./.test(type)) return ["flowRuns"];
+  if (/^qi\/blueprint\./.test(type)) return ["blueprint"];
+  if (/^qi\/bid\./.test(type)) return ["bid"];
+  if (/^qi\/claim\./.test(type)) return ["claim"];
+  if (type === "qi/collection.lifecycle") return ["collection"];
+  if (type === "qi/collection.users") return ["collectionUsers"];
+  if (/^qi\/(matrix\.dm|credential\.store)/.test(type)) return ["matrix"];
+  if (/^qi\/(oracle\.|wallet\.|iid\.|matrix\.register|identity\.|entity\.createOracle|sandbox\.)/.test(type) || type === "qi/oracle.invoke") return ["oracle"];
+  if (/^qi\/carbon\./.test(type)) return ["carbon"];
+  if (/^qi\/entity\.transfer/.test(type)) return ["entity"];
+  if (/^qi\/kyc\./.test(type)) return ["kyc"];
+  if (/^qi\/eval\./.test(type)) return ["evalRegister", "rubric"];
+  if (/^qi\/topic\./.test(type)) return ["topic"];
+  if (/^qi\/agent\./.test(type)) return ["agents"];
+  if (/^qi\/evidence\./.test(type)) return ["evidence"];
+  if (/^qi\/evaluation\./.test(type)) return ["evaluations"];
+  if (/^qi\/settlement\./.test(type)) return ["settlement"];
+  if (/^qi\/incident\.escalate/.test(type)) return ["incidents"];
+  if (/^qi\/(work|answer|incident\.mitigation)\./.test(type)) return ["topic"];
+  if (/^qi\/(governance|proposal|domain\.)\./.test(type)) return ["portalHandlers"];
+  return [];
+}
+function riskTier(action) {
+  const type = action.type;
+  if (/^qi\/(settlement\.execute|carbon\.retire)$/.test(type)) return "critical";
+  if (/^qi\/(governance\.|claim\.evaluate|entity\.transfer|domain\.sign|xero\.payment\.create|wallet\.fund)/.test(type)) return "high";
+  if (!action.sideEffect || /\.(list|loadBatches|card-preview|fetch)$/.test(type)) return "low";
+  return "medium";
+}
+function sensitivePaths(type) {
+  const input = [];
+  const output = [];
+  if (type.startsWith("qi/http.")) {
+    input.push("headers.authorization", "headers.cookie", "headers.x-api-key", "body");
+    output.push("data", "response");
+  }
+  if (/^qi\/(email|gmail|outlook|slack|notification|matrix\.dm)/.test(type)) {
+    input.push("to", "cc", "bcc", "body", "template", "variables");
+    output.push("providerResponse");
+  }
+  if (/^qi\/(gmail|outlook|slack|googlecalendar|calendar|xero)\./.test(type)) input.push("connection", "bindingId");
+  if (/^qi\/(kyc|credential)\./.test(type)) {
+    input.push("data", "credential");
+    output.push("credential", "surveyAnswers");
+  }
+  if (/^qi\/(oracle\.|wallet\.|iid\.|matrix\.register|identity\.|entity\.createOracle|sandbox\.)/.test(type)) {
+    input.push("mnemonic", "pin", "secrets", "config");
+    output.push("mnemonic", "privateKey", "matrixAccessToken", "matrixPassword", "matrixRecoveryPhrase", "secrets");
+  }
+  if (type === "qi/oracle.invoke") {
+    input.push("prompt");
+    output.push("result");
+  }
+  if (/^qi\/(form|human\.form|claim|bid)\./.test(type)) {
+    input.push("answers", "surveyAnswers", "surveyData");
+    output.push("answers", "surveyAnswers", "surveyData");
+  }
+  return { sensitiveInputPaths: [...new Set(input)].sort(), sensitiveOutputPaths: [...new Set(output)].sort() };
+}
+function topicKindsAndRelevance(type) {
+  if (any(RESTRICTED, type)) return { supportedBaseKinds: ["agent_task"], relevance: "restricted" };
+  if (/^qi\/flow\.run\./.test(type)) return { supportedBaseKinds: ALL_KINDS, relevance: "recommended" };
+  if (/^qi\/(oracle\.invoke|agent\.)/.test(type)) return { supportedBaseKinds: ["agent_task", "question", "task"], relevance: "recommended" };
+  if (/^qi\/(governance\.|proposal\.|topic\.decision)/.test(type)) return { supportedBaseKinds: ["proposal", "discussion", "evaluation"], relevance: "recommended" };
+  if (/^qi\/(eval\.|evaluation\.)/.test(type)) return { supportedBaseKinds: ["evaluation", "claims"], relevance: "recommended" };
+  if (/^qi\/(claim\.|collection\.|settlement\.)/.test(type)) return { supportedBaseKinds: ["claims", "evaluation"], relevance: "recommended" };
+  if (/^qi\/(work\.)/.test(type)) return { supportedBaseKinds: ["task", "discussion", "incident"], relevance: "recommended" };
+  if (/^qi\/(evidence\.|answer\.)/.test(type)) return { supportedBaseKinds: ["question", "evaluation"], relevance: "recommended" };
+  if (/^qi\/incident\./.test(type)) return { supportedBaseKinds: ["incident"], relevance: "recommended" };
+  if (/^qi\/topic\./.test(type)) return { supportedBaseKinds: ALL_KINDS, relevance: "recommended" };
+  if (/^qi\/(http\.|domain\.card-preview|calendar\.|googlecalendar\.)/.test(type))
+    return { supportedBaseKinds: ["question", "evaluation", "agent_task", "task"], relevance: "contextual" };
+  if (/^qi\/(email\.|gmail\.|outlook\.|slack\.|matrix\.dm|notification\.)/.test(type)) {
+    return { supportedBaseKinds: ["task", "question", "discussion", "incident"], relevance: "contextual" };
+  }
+  return { supportedBaseKinds: ALL_KINDS, relevance: "contextual" };
+}
+function topicSemanticRecords(type) {
+  if (/^qi\/(governance\.|proposal\.)/.test(type)) return ["org.ixo.topic.proposal-receipt"];
+  if (/^qi\/claim\.submit/.test(type)) return ["org.ixo.topic.claim-submission"];
+  if (/^qi\/claim\.evaluate/.test(type)) return ["org.ixo.topic.claim-evaluation"];
+  if (/^qi\/evaluation\./.test(type)) return ["org.ixo.topic.evaluation-assertion"];
+  return [];
+}
+function normalizeActionPolicy(action) {
+  const sensitive = sensitivePaths(action.type);
+  const topicSelection = topicKindsAndRelevance(action.type);
+  const semanticRecords = topicSemanticRecords(action.type);
+  const declaredTopic = action.topic;
+  const sensitiveInputPaths = [.../* @__PURE__ */ new Set([...action.sensitiveInputPaths || [], ...sensitive.sensitiveInputPaths])].sort();
+  const sensitiveOutputPaths = [.../* @__PURE__ */ new Set([...action.sensitiveOutputPaths || [], ...sensitive.sensitiveOutputPaths])].sort();
+  return {
+    executionOwner: action.executionOwner || (any(HUMAN_OWNED, action.type) ? "human" : "agent"),
+    riskTier: action.riskTier || riskTier(action),
+    requiredServices: [...new Set(action.requiredServices || requiredServices(action.type))].sort(),
+    sensitiveInputPaths,
+    sensitiveOutputPaths,
+    topic: declaredTopic ? {
+      ...declaredTopic,
+      semanticRecordTypes: declaredTopic.semanticRecordTypes || getTopicSemanticRecordDefinitions(declaredTopic.permittedTopicRecordTypes),
+      permittedTopicRecordTypes: (declaredTopic.semanticRecordTypes || getTopicSemanticRecordDefinitions(declaredTopic.permittedTopicRecordTypes)).map(
+        (definition) => definition.type
+      )
+    } : {
+      ...topicSelection,
+      writeBackMode: semanticRecords.length > 0 ? "semantic-record" : "receipt-only",
+      semanticRecordTypes: getTopicSemanticRecordDefinitions(semanticRecords),
+      permittedTopicRecordTypes: semanticRecords,
+      lifecycleEffect: "none",
+      requiredTopicAbilities: ["topic/request-action", "topic/record-action"],
+      redactionPolicy: { mode: "paths", sensitiveInputPaths, sensitiveOutputPaths }
+    }
+  };
+}
+
+// src/core/lib/actionRegistry/registry.ts
+var actions = /* @__PURE__ */ new Map();
+var LEGACY_ACTION_CONTRACT_VERSION = "4.0.0";
+var registryRevision = 0;
+function getRegistryRevision() {
+  return registryRevision;
+}
+var STEP_COMPLETED_EVENT_NAME = "step.completed";
+var STEP_COMPLETED_EVENT = {
+  name: STEP_COMPLETED_EVENT_NAME,
+  displayName: "Completed",
+  description: "Fires when this step is completed.",
+  payloadSchema: []
+};
+var doneWhenCompleted = {
+  isDone: (state) => state.state === "completed"
+};
+var neverDone = {
+  isDone: () => false
+};
+var ACTION_TYPE_ALIASES = {
+  oracle: "qi/oracle.invoke",
+  bid: "qi/bid.submit",
+  claim: "qi/claim.submit",
+  evaluateBid: "qi/bid.evaluate",
+  evaluateClaim: "qi/claim.evaluate",
+  "email.send": "qi/email.send",
+  "http.request": "qi/http.request",
+  "form.submit": "qi/form.submit",
+  "human.form.submit": "qi/human.form.submit",
+  "human.checkbox.set": "qi/human.checkbox.set",
+  "notification.push": "qi/notification.push",
+  "proposal.create": "qi/proposal.create",
+  "proposal.vote": "qi/proposal.vote",
+  "protocol.select": "qi/protocol.select",
+  "domain.sign": "qi/domain.sign",
+  "domain.card-preview": "qi/domain.card-preview",
+  "credential.store": "qi/credential.store",
+  // POD setup flow — camelCase orchestrator labels → canonical action types
+  DomainIndexerLookup: "qi/pod.domain-indexer-lookup",
+  DomainSingleSelection: "qi/pod.domain-single-selection",
+  EntitySingleSelection: "qi/pod.entity-single-selection",
+  MemberMultiSelect: "qi/pod.member-multi-select",
+  governanceConfig: "qi/pod.governance-config",
+  listDomainFlows: "qi/pod.list-domain-flows",
+  "matrix.dm": "qi/matrix.dm",
+  // The qi/calendar.* namespace is retired permanently (IXO-4420 §5): these
+  // blocks were always Google Calendar via Composio, misnamed as neutral.
+  // Aliases keep every existing document loading; because resolveActionType
+  // checks aliases before registered types, no new canonical action can ever
+  // be registered under these names — the IXO-native calendar (M4) takes
+  // qi/ixo.calendar.event.* instead.
+  "qi/calendar.event.create": "qi/googlecalendar.event.create-self",
+  "qi/calendar.event.update": "qi/googlecalendar.event.update-self",
+  "qi/calendar.event.list": "qi/googlecalendar.event.list-self",
+  // Topic v3 called setup confirmation "accept contract". Persisted Flow
+  // documents keep that action key, so resolve it to the v4 confirmation
+  // contract while new documents use the canonical name.
+  "qi/topic.contract.accept": "qi/topic.contract.confirm-setup"
+};
+var aliases = new Map(Object.entries(ACTION_TYPE_ALIASES));
+function resolveActionType(type) {
+  return aliases.get(type) ?? type;
+}
+function normalizeCan(can) {
+  const trimmed = can.trim();
+  const lastDot = trimmed.lastIndexOf(".");
+  if (!trimmed.includes("/") && lastDot > 0) {
+    return `${trimmed.slice(0, lastDot)}/${trimmed.slice(lastDot + 1)}`;
+  }
+  return trimmed;
+}
+function normalizeCapabilityPattern(pattern) {
+  return normalizeCan(pattern);
+}
+function actionTypeToCan(type) {
+  const resolvedType = resolveActionType(type.trim());
+  const registered = actions.get(resolvedType);
+  if (registered?.can) return normalizeCan(registered.can);
+  const mapped = typeToCan(resolvedType);
+  if (mapped) return normalizeCan(mapped);
+  if (!resolvedType.startsWith("qi/")) return void 0;
+  return normalizeCan(resolvedType.slice("qi/".length));
+}
+function canToActionType(can) {
+  const normalizedCan = normalizeCan(can);
+  for (const action of actions.values()) {
+    if (action.can && normalizeCan(action.can) === normalizedCan) return action.type;
+  }
+  const mapped = canToType(normalizedCan);
+  if (mapped) return resolveActionType(mapped);
+  const segments = normalizedCan.split("/");
+  if (segments.length !== 2) return void 0;
+  const [namespace, verb] = segments;
+  if (namespace.length === 0 || verb.length === 0) return void 0;
+  return `qi/${namespace}.${verb}`;
+}
+function capabilityPatternCoversCan(pattern, can, options = {}) {
+  const normalizedPattern = normalizeCapabilityPattern(pattern);
+  const normalizedCan = normalizeCan(can);
+  if (normalizedPattern === "*") return options.allowGlobalWildcard === true;
+  if (normalizedPattern === normalizedCan) return true;
+  if (normalizedPattern.endsWith("/*")) {
+    const prefix = normalizedPattern.slice(0, -1);
+    return normalizedCan.startsWith(prefix);
+  }
+  return false;
+}
+function registerAction(definition) {
+  const presentation = getActionPresentation(definition.type);
+  definition.displayName = definition.displayName?.trim() || presentation.displayName;
+  definition.description = definition.description?.trim() || presentation.description;
+  if (!definition.contractVersion?.trim()) {
+    definition.contractVersion = LEGACY_ACTION_CONTRACT_VERSION;
+  }
+  if (definition.can) definition.can = normalizeCan(definition.can);
+  Object.assign(definition, normalizeActionPolicy(definition));
+  if (!definition.done) {
+    warnOnce(`missing-done-contract:${definition.type}`, `[flow-config] action ${definition.type}: no done contract declared; defaulting to state === 'completed'`);
+    definition.done = doneWhenCompleted;
+  }
+  actions.set(definition.type, definition);
+  registryRevision += 1;
+}
+function getAction(type) {
+  return actions.get(resolveActionType(type));
+}
+function getAllActions() {
+  return Array.from(actions.values());
+}
+function isRepeatableAction(type) {
+  if (!type) return false;
+  return getAction(type)?.cardinality === "many";
+}
+function isNeverDoneAction(type) {
+  if (!type) return false;
+  return getAction(type)?.done === neverDone;
+}
+function getAliasEntries() {
+  return Array.from(aliases.entries());
+}
+function hasAction(type) {
+  return actions.has(resolveActionType(type));
+}
+function getActionByCan(can) {
+  const normalizedCan = normalizeCan(can);
+  for (const action of actions.values()) {
+    if (action.can && normalizeCan(action.can) === normalizedCan) return action;
+  }
+  return void 0;
+}
+function getEventsForBlock(action, inputs) {
+  if (!action) return [];
+  let events;
+  if (action.getDynamicEvents) {
+    const parsed = normalizeInputs(inputs);
+    try {
+      const dynamic = action.getDynamicEvents(parsed) || [];
+      events = action.dynamicResolutionMode === "replace" ? dynamic : mergeByKey(action.events || [], dynamic, (event) => event.name);
+    } catch (error) {
+      warnOnce(
+        `dynamic-events:${action.type}`,
+        `[flow-config] action ${action.type}: getDynamicEvents threw (${error instanceof Error ? error.message : String(error)}); no events resolved`
+      );
+      events = [];
+    }
+  } else {
+    events = action.events || [];
+  }
+  if (events.some((event) => event.name === STEP_COMPLETED_EVENT_NAME)) {
+    return events;
+  }
+  return [...events, STEP_COMPLETED_EVENT];
+}
+function getOutputSchemaForBlock(action, inputs) {
+  if (!action) return [];
+  if (action.getDynamicOutputSchema) {
+    const parsed = normalizeInputs(inputs);
+    try {
+      const dynamic = action.getDynamicOutputSchema(parsed) || [];
+      if (action.dynamicResolutionMode === "replace") return dynamic;
+      return mergeByKey(action.outputSchema || [], dynamic, (field) => field.path);
+    } catch (error) {
+      warnOnce(
+        `dynamic-output-schema:${action.type}`,
+        `[flow-config] action ${action.type}: getDynamicOutputSchema threw (${error instanceof Error ? error.message : String(error)}); using static schema`
+      );
+      return action.outputSchema || [];
+    }
+  }
+  return action.outputSchema || [];
+}
+function mergeByKey(baseline, dynamic, keyOf) {
+  const dynamicKeys = new Set(dynamic.map(keyOf));
+  return [...baseline.filter((item) => !dynamicKeys.has(keyOf(item))), ...dynamic];
+}
+function normalizeInputs(inputs) {
+  if (!inputs) return {};
+  if (typeof inputs === "object") return inputs;
+  if (typeof inputs === "string") {
+    try {
+      const parsed = JSON.parse(inputs || "{}");
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      warnOnce(`inputs-normalize:${inputs}`, `[flow-config] block inputs are not valid JSON; treated as empty`);
+      return {};
+    }
+  }
+  return {};
+}
+
+// src/core/lib/flowEngine/dmNotificationState.ts
+var DM_NOTIFICATIONS_MAP_KEY = "dmNotificationState";
+var DM_NOTIFICATIONS_KEY = "__dm_notifications";
+var DM_NOTIFICATIONS_PENDING_KEY = "__dm_notifications_pending";
+var LEGACY_RUNTIME_MAP_KEY = "runtime";
+function getDMMap(yDoc) {
+  return yDoc.getMap(DM_NOTIFICATIONS_MAP_KEY);
+}
+function getLegacyMap(yDoc) {
+  return yDoc.getMap(LEGACY_RUNTIME_MAP_KEY);
+}
+function readRecordBag(map, key) {
+  return readNestedBag(map?.get(key));
+}
+function readNestedBag(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function notifiedAtOf(record) {
+  const at = record.notifiedAt;
+  return typeof at === "number" && Number.isFinite(at) ? at : Number.NEGATIVE_INFINITY;
+}
+function resolveRecord(legacy, current) {
+  const l = asRecord(legacy);
+  const c = asRecord(current);
+  if (!l) return c;
+  if (!c) return l;
+  return notifiedAtOf(l) > notifiedAtOf(c) ? l : c;
+}
+function unionKeys(a, b) {
+  return Array.from(/* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]));
+}
+function copyBag(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const out = {};
+  for (const [key, nested] of Object.entries(value)) {
+    out[key] = copyBag(nested);
+  }
+  return out;
+}
+function writeDedupBag(yDoc, key, next) {
+  yDoc.transact(() => {
+    getDMMap(yDoc).set(key, copyBag(next));
+    getLegacyMap(yDoc).set(key, copyBag(next));
+  });
+}
+function getDMNotificationState(yDoc) {
+  const legacy = readRecordBag(getLegacyMap(yDoc), DM_NOTIFICATIONS_KEY);
+  const current = readRecordBag(getDMMap(yDoc), DM_NOTIFICATIONS_KEY);
+  const merged = {};
+  for (const blockId of unionKeys(legacy, current)) {
+    const winner = resolveRecord(legacy[blockId], current[blockId]);
+    if (winner) merged[blockId] = { ...winner };
+  }
+  return merged;
+}
+function setDMNotificationRecord(yDoc, blockId, record) {
+  const next = {
+    ...getDMNotificationState(yDoc),
+    [blockId]: { ...record }
+  };
+  writeDedupBag(yDoc, DM_NOTIFICATIONS_KEY, next);
+}
+function shouldNotify(state, blockId, currentAssignedDid) {
+  const existing = state[blockId];
+  if (!existing) return true;
+  return existing.assignedDid !== currentAssignedDid;
+}
+function getPendingDMNotificationState(yDoc) {
+  const legacy = readRecordBag(getLegacyMap(yDoc), DM_NOTIFICATIONS_PENDING_KEY);
+  const current = readRecordBag(getDMMap(yDoc), DM_NOTIFICATIONS_PENDING_KEY);
+  const merged = {};
+  for (const blockId of unionKeys(legacy, current)) {
+    const legacyBlock = readNestedBag(legacy[blockId]);
+    const currentBlock = readNestedBag(current[blockId]);
+    const block = {};
+    for (const invocationId of unionKeys(legacyBlock, currentBlock)) {
+      const winner = resolveRecord(legacyBlock[invocationId], currentBlock[invocationId]);
+      if (winner) block[invocationId] = { ...winner };
+    }
+    if (Object.keys(block).length > 0) merged[blockId] = block;
+  }
+  return merged;
+}
+function setPendingDMNotificationRecord(yDoc, blockId, pendingInvocationId, record) {
+  const current = getPendingDMNotificationState(yDoc);
+  const blockState = current[blockId] || {};
+  const next = {
+    ...current,
+    [blockId]: {
+      ...blockState,
+      [pendingInvocationId]: { ...record }
+    }
+  };
+  writeDedupBag(yDoc, DM_NOTIFICATIONS_PENDING_KEY, next);
+}
+function shouldNotifyPending(state, blockId, pendingInvocationId, currentAssignedDid) {
+  const blockState = state[blockId];
+  if (!blockState) return true;
+  const existing = blockState[pendingInvocationId];
+  if (!existing) return true;
+  return existing.assignedDid !== currentAssignedDid;
+}
+
+// src/core/lib/flowEngine/runs.ts
+import * as Y from "yjs";
+var RUNS_MAP_KEY = "runs";
+var RUNS_TERMINAL_MAP_KEY = "runsTerminal";
+var RUNS_TERMINAL_PENDING_MAP_KEY = "runsTerminalPending";
+var LEGACY_RUNTIME_MAP_KEY2 = "runtime";
+var UNSESSIONED_RUN_ID = "__unsessioned__";
+function isRecordInRun(recordRunId, sessionRunId) {
+  return (recordRunId ?? UNSESSIONED_RUN_ID) === sessionRunId;
+}
+function resolveRecordRunId(recordRunId, requestedRunId) {
+  return recordRunId ?? requestedRunId ?? UNSESSIONED_RUN_ID;
+}
+var PHANTOM_LEGACY_RUN_ID = "r-0000-legacy";
+var RUN_STORAGE_VERSION_KEY = "runStorageVersion";
+var LEGACY_RUN_STORAGE_VERSION = 1;
+var MULTI_RUN_STORAGE_VERSION = 2;
+var RESERVED_RUNTIME_KEY_PREFIX = "__";
+var LEGACY_RUNTIME_ADOPTION_DEFAULT = false;
+var legacyRuntimeAdoptionEnabled = LEGACY_RUNTIME_ADOPTION_DEFAULT;
+function isLegacyRuntimeAdoptionEnabled() {
+  return legacyRuntimeAdoptionEnabled;
+}
+var META_KEY = "meta";
+var ACTIONS_KEY = "actions";
+var PENDING_INVOCATIONS_KEY = "pendingInvocations";
+var BARRIER_STATE_KEY = "barrierState";
+var NODE_STATE_RANK = {
+  idle: 0,
+  pending: 1,
+  running: 2,
+  cancelled: 3,
+  failed: 4,
+  retry_scheduled: 5,
+  awaiting_readback: 6,
+  awaiting_human: 7,
+  needs_verification: 8,
+  completed: 9
+};
+function rankOf(state) {
+  if (!state) return -1;
+  const rank = NODE_STATE_RANK[state];
+  return typeof rank === "number" ? rank : -1;
+}
+function isKnownNodeState(state) {
+  return Object.prototype.hasOwnProperty.call(NODE_STATE_RANK, state);
+}
+function isStarted(entry) {
+  return !!entry.state && entry.state !== "idle";
+}
+function cloneState(value) {
+  if (value === null || typeof value !== "object") return value;
+  try {
+    return structuredClone(value);
+  } catch {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch {
+      return value;
+    }
+  }
+}
+function asStateObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return void 0;
+  const entry = value;
+  const state = entry.state;
+  const at = entry.executedAt;
+  const stateUsable = state === void 0 || typeof state === "string" && isKnownNodeState(state);
+  const atUsable = at === void 0 || typeof at === "number" && Number.isFinite(at);
+  if (stateUsable && atUsable) return entry;
+  const normalised = { ...entry };
+  if (!stateUsable) delete normalised.state;
+  if (!atUsable) delete normalised.executedAt;
+  return normalised;
+}
+function resolveActionState(runEntry, flatEntry) {
+  const run = asStateObject(runEntry);
+  const flat = asStateObject(flatEntry);
+  if (!run && !flat) return { value: {}, winner: "neither" };
+  if (!run) return { value: cloneState(flat), winner: "flat" };
+  if (!flat) return { value: cloneState(run), winner: "run" };
+  const runWins = () => ({ value: cloneState(run), winner: "run" });
+  const flatWins = () => ({ value: cloneState(flat), winner: "flat" });
+  const runStarted = isStarted(run);
+  const flatStarted = isStarted(flat);
+  if (runStarted !== flatStarted) return runStarted ? runWins() : flatWins();
+  const runAt = typeof run.executedAt === "number" ? run.executedAt : void 0;
+  const flatAt = typeof flat.executedAt === "number" ? flat.executedAt : void 0;
+  if (runAt !== void 0 && flatAt !== void 0 && runAt !== flatAt) {
+    return runAt > flatAt ? runWins() : flatWins();
+  }
+  const runRank = rankOf(run.state);
+  const flatRank = rankOf(flat.state);
+  if (runRank !== flatRank) return runRank > flatRank ? runWins() : flatWins();
+  if (runAt !== void 0 && flatAt === void 0) return runWins();
+  if (flatAt !== void 0 && runAt === void 0) return flatWins();
+  return runWins();
+}
+function getRunsMap(yDoc) {
+  return yDoc.getMap(RUNS_MAP_KEY);
+}
+function getExistingRunsMap(yDoc) {
+  return getExistingYMap(yDoc, RUNS_MAP_KEY);
+}
+function getRunsTerminalMap(yDoc) {
+  return yDoc.getMap(RUNS_TERMINAL_MAP_KEY);
+}
+function getExistingRunsTerminalMap(yDoc) {
+  return getExistingYMap(yDoc, RUNS_TERMINAL_MAP_KEY);
+}
+function getRunsTerminalPendingMap(yDoc) {
+  return yDoc.getMap(RUNS_TERMINAL_PENDING_MAP_KEY);
+}
+function getExistingRunsTerminalPendingMap(yDoc) {
+  return getExistingYMap(yDoc, RUNS_TERMINAL_PENDING_MAP_KEY);
+}
+function isRunTerminalOrPending(yDoc, runId) {
+  return Boolean(getExistingRunsTerminalMap(yDoc)?.has(runId) || getExistingRunsTerminalPendingMap(yDoc)?.has(runId));
+}
+function getLegacyRuntimeMap(yDoc) {
+  return yDoc.getMap(LEGACY_RUNTIME_MAP_KEY2);
+}
+function getExistingLegacyRuntimeMap(yDoc) {
+  return getExistingYMap(yDoc, LEGACY_RUNTIME_MAP_KEY2);
+}
+function getRunStorageVersion(yDoc) {
+  assertDoc(yDoc, "getRunStorageVersion");
+  const declared = getExistingYMap(yDoc, "root")?.get(RUN_STORAGE_VERSION_KEY);
+  if (declared === MULTI_RUN_STORAGE_VERSION) return MULTI_RUN_STORAGE_VERSION;
+  if (declared === LEGACY_RUN_STORAGE_VERSION) return LEGACY_RUN_STORAGE_VERSION;
+  return hasLegacyRuntimeHistory(yDoc) ? LEGACY_RUN_STORAGE_VERSION : MULTI_RUN_STORAGE_VERSION;
+}
+function usesLegacyRuntimeCompatibility(yDoc) {
+  return getRunStorageVersion(yDoc) === LEGACY_RUN_STORAGE_VERSION;
+}
+var ExplicitRunRequiredError = class extends Error {
+  constructor(message = "Multi-run execution requires an explicit session run id.") {
+    super(message);
+    this.name = "ExplicitRunRequiredError";
+  }
+};
+var UnknownRunError = class extends Error {
+  constructor(runId) {
+    super(`Unknown session run "${runId}".`);
+    this.runId = runId;
+    this.name = "UnknownRunError";
+  }
+};
+var TerminalRunExecutionError = class extends Error {
+  constructor(runId, blockId) {
+    super(`Run "${runId}" is terminal; sequenced action "${blockId}" cannot execute.`);
+    this.runId = runId;
+    this.blockId = blockId;
+    this.name = "TerminalRunExecutionError";
+  }
+};
+function isBelowTheLineBlock(block) {
+  const props = block?.props || {};
+  return props.belowTheLine === true || props.sequenced === false || props.runScope === "below-the-line" || props.executionLane === "below-the-line" || isNeverDoneAction(typeof props.actionType === "string" ? props.actionType : void 0);
+}
+function resolveRunIdForExecution(yDoc, requestedRunId) {
+  assertDoc(yDoc, "resolveRunIdForExecution");
+  if (usesLegacyRuntimeCompatibility(yDoc)) {
+    return requestedRunId || resolveActiveRunId(yDoc) || UNSESSIONED_RUN_ID;
+  }
+  if (!requestedRunId) throw new ExplicitRunRequiredError();
+  if (!getExistingRunsMap(yDoc)?.has(requestedRunId)) {
+    throw new UnknownRunError(requestedRunId);
+  }
+  return requestedRunId;
+}
+function assertRunActionExecutionAllowed(yDoc, runId, block) {
+  if (!getExistingRunsMap(yDoc)?.has(runId) && !usesLegacyRuntimeCompatibility(yDoc)) {
+    throw new UnknownRunError(runId);
+  }
+  if (isRunTerminalOrPending(yDoc, runId) && !isBelowTheLineBlock(block)) {
+    throw new TerminalRunExecutionError(runId, block.id || "unknown");
+  }
+}
+function assertDoc(yDoc, fn) {
+  if (!yDoc || typeof yDoc.getMap !== "function") {
+    throw new Error(`[runs] ${fn} requires a Y.Doc \u2014 refusing to fall back to non-persistent state`);
+  }
+}
+function ensureRun(yDoc, runId, meta) {
+  assertDoc(yDoc, "ensureRun");
+  let run = getRunsMap(yDoc).get(runId);
+  if (!run) {
+    yDoc.transact(() => {
+      const runs = getRunsMap(yDoc);
+      if (!runs.get(runId)) {
+        const created = new Y.Map();
+        created.set(META_KEY, { seq: 0, startedAt: Date.now(), ...meta });
+        created.set(ACTIONS_KEY, new Y.Map());
+        runs.set(runId, created);
+      }
+    });
+    run = getRunsMap(yDoc).get(runId);
+  }
+  return run;
+}
+function getRunActionsMap(yDoc, runId) {
+  assertDoc(yDoc, "getRunActionsMap");
+  const run = getExistingRunsMap(yDoc)?.get(runId);
+  if (!run) return void 0;
+  const actions2 = run.get(ACTIONS_KEY);
+  return isYMapLike(actions2) ? actions2 : void 0;
+}
+function getRunScopedMap(yDoc, runId, key) {
+  assertDoc(yDoc, "getRunScopedMap");
+  const value = getExistingRunsMap(yDoc)?.get(runId)?.get(key);
+  return isYMapLike(value) ? value : void 0;
+}
+function ensureRunScopedMap(yDoc, runId, key) {
+  assertDoc(yDoc, "ensureRunScopedMap");
+  const run = ensureRun(yDoc, runId);
+  const existing = run.get(key);
+  if (isYMapLike(existing)) return existing;
+  run.set(key, new Y.Map());
+  return getRunScopedMap(yDoc, runId, key);
+}
+function getRunMeta(yDoc, runId) {
+  assertDoc(yDoc, "getRunMeta");
+  const run = getExistingRunsMap(yDoc)?.get(runId);
+  const meta = run?.get(META_KEY);
+  if (!meta || typeof meta !== "object") return void 0;
+  return { ...meta };
+}
+function resolveActionsForWrite(yDoc, runId) {
+  if (!getExistingRunsMap(yDoc)?.has(runId)) {
+    if (usesLegacyRuntimeCompatibility(yDoc)) return void 0;
+    throw new UnknownRunError(runId);
+  }
+  return ensureRunActions(yDoc, runId);
+}
+function ensureRunActions(yDoc, runId) {
+  ensureRun(yDoc, runId);
+  const existing = getRunActionsMap(yDoc, runId);
+  if (existing) return existing;
+  const run = getRunsMap(yDoc).get(runId);
+  run.set(ACTIONS_KEY, new Y.Map());
+  return getRunActionsMap(yDoc, runId);
+}
+function copyNestedMapIntoRun(yDoc, runId, key) {
+  const source = yDoc.getMap(key);
+  const target = ensureRunScopedMap(yDoc, runId, key);
+  let copied = 0;
+  source.forEach((sourceInner, outerKey) => {
+    if (!isYMapLike(sourceInner)) return;
+    let targetInner = target.get(outerKey);
+    if (!isYMapLike(targetInner)) {
+      targetInner = new Y.Map();
+      target.set(outerKey, targetInner);
+    }
+    sourceInner.forEach((value, innerKey) => {
+      if (!targetInner.has(innerKey)) {
+        targetInner.set(innerKey, cloneState(value));
+        copied += 1;
+      }
+    });
+  });
+  return copied;
+}
+function hasLegacyRuntimeHistory(yDoc) {
+  assertDoc(yDoc, "hasLegacyRuntimeHistory");
+  const flat = getExistingLegacyRuntimeMap(yDoc);
+  if (!flat) return false;
+  let found = false;
+  flat.forEach((value, key) => {
+    if (found || key.startsWith(RESERVED_RUNTIME_KEY_PREFIX)) return;
+    if (asStateObject(value)) found = true;
+  });
+  return found;
+}
+function collectPhantomLegacyRun(yDoc) {
+  assertDoc(yDoc, "collectPhantomLegacyRun");
+  if (!getExistingRunsMap(yDoc)?.has(PHANTOM_LEGACY_RUN_ID)) return false;
+  if (getRunMeta(yDoc, PHANTOM_LEGACY_RUN_ID)?.manifest) return false;
+  const phantomActions = getRunActionsMap(yDoc, PHANTOM_LEGACY_RUN_ID);
+  if (phantomActions && phantomActions.size > 0 && !usesLegacyRuntimeCompatibility(yDoc)) return false;
+  yDoc.transact(() => {
+    getRunsMap(yDoc).delete(PHANTOM_LEGACY_RUN_ID);
+    getRunsTerminalMap(yDoc).delete(PHANTOM_LEGACY_RUN_ID);
+    const root = getExistingYMap(yDoc, "root");
+    if (root?.get("activeRunId") === PHANTOM_LEGACY_RUN_ID) root.delete("activeRunId");
+  });
+  return true;
+}
+function seedRunFromLegacyRuntime(yDoc, runId) {
+  assertDoc(yDoc, "seedRunFromLegacyRuntime");
+  const result = { actionStates: 0, pendingInvocations: 0, barrierEntries: 0 };
+  yDoc.transact(() => {
+    const actions2 = ensureRunActions(yDoc, runId);
+    const flat = getLegacyRuntimeMap(yDoc);
+    const keys = /* @__PURE__ */ new Set();
+    actions2.forEach((_, key) => keys.add(key));
+    flat.forEach((_, key) => {
+      if (!key.startsWith(RESERVED_RUNTIME_KEY_PREFIX)) keys.add(key);
+    });
+    for (const key of keys) {
+      const resolved = resolveActionState(actions2.get(key), flat.get(key)).value;
+      actions2.set(key, cloneState(resolved));
+      result.actionStates += 1;
+    }
+    result.pendingInvocations = copyNestedMapIntoRun(yDoc, runId, PENDING_INVOCATIONS_KEY);
+    result.barrierEntries = copyNestedMapIntoRun(yDoc, runId, BARRIER_STATE_KEY);
+  });
+  return result;
+}
+function setMultiRunStorage(yDoc) {
+  assertDoc(yDoc, "setMultiRunStorage");
+  yDoc.getMap("root").set(RUN_STORAGE_VERSION_KEY, MULTI_RUN_STORAGE_VERSION);
+}
+function enableMultiRunStorage(yDoc) {
+  setMultiRunStorage(yDoc);
+}
+function readActionState(yDoc, runId, blockId) {
+  assertDoc(yDoc, "readActionState");
+  const runEntry = getRunActionsMap(yDoc, runId)?.get(blockId);
+  if (!usesLegacyRuntimeCompatibility(yDoc)) {
+    const state = asStateObject(runEntry);
+    return state ? cloneState(state) : {};
+  }
+  const flatEntry = getExistingLegacyRuntimeMap(yDoc)?.get(blockId);
+  return resolveActionState(runEntry, flatEntry).value;
+}
+function readActionStates(yDoc, runId) {
+  assertDoc(yDoc, "readActionStates");
+  const keys = /* @__PURE__ */ new Set();
+  getRunActionsMap(yDoc, runId)?.forEach((_, key) => keys.add(key));
+  if (usesLegacyRuntimeCompatibility(yDoc)) {
+    getExistingLegacyRuntimeMap(yDoc)?.forEach((_, key) => {
+      if (!key.startsWith(RESERVED_RUNTIME_KEY_PREFIX)) keys.add(key);
+    });
+  }
+  const states = {};
+  for (const key of keys) {
+    states[key] = readActionState(yDoc, runId, key);
+  }
+  return states;
+}
+function writeActionState(yDoc, runId, blockId, updates) {
+  assertDoc(yDoc, "writeActionState");
+  let prev = {};
+  let next = {};
+  yDoc.transact(() => {
+    const actions2 = resolveActionsForWrite(yDoc, runId);
+    const legacyCompatible = usesLegacyRuntimeCompatibility(yDoc);
+    const flat = legacyCompatible ? getLegacyRuntimeMap(yDoc) : void 0;
+    prev = legacyCompatible ? resolveActionState(actions2?.get(blockId), flat?.get(blockId)).value : readActionState(yDoc, runId, blockId);
+    next = cloneState({ ...prev, ...updates });
+    actions2?.set(blockId, cloneState(next));
+    flat?.set(blockId, cloneState(next));
+  });
+  return { prev, next };
+}
+function resetActionState(yDoc, runId, blockId, value = { state: "idle" }) {
+  assertDoc(yDoc, "resetActionState");
+  yDoc.transact(() => {
+    const actions2 = resolveActionsForWrite(yDoc, runId);
+    actions2?.set(blockId, cloneState(value));
+    if (usesLegacyRuntimeCompatibility(yDoc)) {
+      getLegacyRuntimeMap(yDoc).set(blockId, cloneState(value));
+    }
+  });
+}
+function deleteActionState(yDoc, runId, blockId) {
+  assertDoc(yDoc, "deleteActionState");
+  yDoc.transact(() => {
+    getRunActionsMap(yDoc, runId)?.delete(blockId);
+    if (usesLegacyRuntimeCompatibility(yDoc)) {
+      getLegacyRuntimeMap(yDoc).delete(blockId);
+    }
+  });
+}
+function clearAllActionState(yDoc) {
+  assertDoc(yDoc, "clearAllActionState");
+  yDoc.transact(() => {
+    const runs = getRunsMap(yDoc);
+    runs.forEach((_, key) => runs.delete(key));
+    const terminal = getRunsTerminalMap(yDoc);
+    terminal.forEach((_, key) => terminal.delete(key));
+    const flat = getLegacyRuntimeMap(yDoc);
+    flat.forEach((_, key) => flat.delete(key));
+    const dmState = yDoc.getMap(DM_NOTIFICATIONS_MAP_KEY);
+    dmState.forEach((_, key) => dmState.delete(key));
+  });
+}
+function adoptLegacyRuntime(yDoc, runId) {
+  assertDoc(yDoc, "adoptLegacyRuntime");
+  if (!legacyRuntimeAdoptionEnabled) return 0;
+  let adopted = 0;
+  yDoc.transact(() => {
+    const actions2 = ensureRunActions(yDoc, runId);
+    const flat = getLegacyRuntimeMap(yDoc);
+    flat.forEach((value, key) => {
+      if (key.startsWith(RESERVED_RUNTIME_KEY_PREFIX)) return;
+      if (!asStateObject(value)) return;
+      const resolved = resolveActionState(actions2.get(key), value);
+      if (resolved.winner !== "flat") return;
+      actions2.set(key, cloneState(resolved.value));
+      adopted += 1;
+    });
+  });
+  return adopted;
+}
+function subscribeToActionState(yDoc, handler) {
+  assertDoc(yDoc, "subscribeToActionState");
+  const runs = getRunsMap(yDoc);
+  runs.observeDeep(handler);
+  const flat = usesLegacyRuntimeCompatibility(yDoc) ? getLegacyRuntimeMap(yDoc) : void 0;
+  flat?.observe(handler);
+  return () => {
+    runs.unobserveDeep(handler);
+    flat?.unobserve(handler);
+  };
+}
+function resolveActiveRunId(yDoc) {
+  if (yDoc && typeof yDoc.getMap === "function") {
+    const advisory = getExistingYMap(yDoc, "root")?.get("activeRunId");
+    if (typeof advisory === "string" && advisory.length > 0 && getExistingRunsMap(yDoc)?.has(advisory)) {
+      return advisory;
+    }
+  }
+  return void 0;
+}
+function resolveRunIdForRead(yDoc, requestedRunId) {
+  assertDoc(yDoc, "resolveRunIdForRead");
+  if (requestedRunId) return requestedRunId;
+  return resolveActiveRunId(yDoc) ?? (usesLegacyRuntimeCompatibility(yDoc) ? UNSESSIONED_RUN_ID : void 0);
+}
+function createRunScopedRuntimeManager(yDoc, runId) {
+  assertDoc(yDoc, "createRunScopedRuntimeManager");
+  if (!runId) {
+    throw new Error("[runs] createRunScopedRuntimeManager requires a runId");
+  }
+  return {
+    get: (nodeId) => readActionState(yDoc, runId, nodeId),
+    update: (nodeId, updates) => {
+      writeActionState(yDoc, runId, nodeId, updates);
+    }
+  };
+}
+function createRunRuntimeReader(yDoc, runId) {
+  assertDoc(yDoc, "createRunRuntimeReader");
+  return {
+    get(blockId) {
+      const runEntry = getRunActionsMap(yDoc, runId)?.get(blockId);
+      if (!usesLegacyRuntimeCompatibility(yDoc)) {
+        const state = asStateObject(runEntry);
+        return state ? cloneState(state) : void 0;
+      }
+      const flatEntry = getLegacyRuntimeMap(yDoc).get(blockId);
+      const resolved = resolveActionState(runEntry, flatEntry);
+      return resolved.winner === "neither" ? void 0 : resolved.value;
+    }
+  };
+}
+function createRunRuntimeReaderWithDoc(yDoc, runId) {
+  return Object.assign(createRunRuntimeReader(yDoc, runId), { doc: yDoc });
+}
+
+export {
+  compareCodeUnits,
+  canonicalActionJson,
+  sha256Digest,
+  MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT,
+  MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES,
+  getTopicSemanticRecordDefinitions,
+  validateTopicSemanticRecord,
+  validateTopicSemanticRecordBatch,
+  canToType,
+  typeToCan,
+  getAllCanMappings,
+  CollectionStateEnum,
+  getActionPresentation,
+  getRegistryRevision,
+  STEP_COMPLETED_EVENT_NAME,
+  STEP_COMPLETED_EVENT,
+  doneWhenCompleted,
+  neverDone,
+  resolveActionType,
+  normalizeCan,
+  normalizeCapabilityPattern,
+  actionTypeToCan,
+  canToActionType,
+  capabilityPatternCoversCan,
+  registerAction,
+  getAction,
+  getAllActions,
+  isRepeatableAction,
+  isNeverDoneAction,
+  getAliasEntries,
+  hasAction,
+  getActionByCan,
+  getEventsForBlock,
+  getOutputSchemaForBlock,
+  DM_NOTIFICATIONS_MAP_KEY,
+  getDMNotificationState,
+  setDMNotificationRecord,
+  shouldNotify,
+  getPendingDMNotificationState,
+  setPendingDMNotificationRecord,
+  shouldNotifyPending,
+  RUNS_MAP_KEY,
+  RUNS_TERMINAL_MAP_KEY,
+  RUNS_TERMINAL_PENDING_MAP_KEY,
+  LEGACY_RUNTIME_MAP_KEY2 as LEGACY_RUNTIME_MAP_KEY,
+  isRecordInRun,
+  resolveRecordRunId,
+  RUN_STORAGE_VERSION_KEY,
+  LEGACY_RUN_STORAGE_VERSION,
+  MULTI_RUN_STORAGE_VERSION,
+  isLegacyRuntimeAdoptionEnabled,
+  getRunsMap,
+  getExistingRunsMap,
+  getRunsTerminalMap,
+  getExistingRunsTerminalMap,
+  getRunsTerminalPendingMap,
+  getExistingRunsTerminalPendingMap,
+  isRunTerminalOrPending,
+  getRunStorageVersion,
+  usesLegacyRuntimeCompatibility,
+  ExplicitRunRequiredError,
+  UnknownRunError,
+  TerminalRunExecutionError,
+  isBelowTheLineBlock,
+  resolveRunIdForExecution,
+  assertRunActionExecutionAllowed,
+  ensureRun,
+  getRunActionsMap,
+  getRunScopedMap,
+  ensureRunScopedMap,
+  getRunMeta,
+  hasLegacyRuntimeHistory,
+  collectPhantomLegacyRun,
+  seedRunFromLegacyRuntime,
+  setMultiRunStorage,
+  enableMultiRunStorage,
+  readActionState,
+  readActionStates,
+  writeActionState,
+  resetActionState,
+  deleteActionState,
+  clearAllActionState,
+  adoptLegacyRuntime,
+  subscribeToActionState,
+  resolveActiveRunId,
+  resolveRunIdForRead,
+  createRunScopedRuntimeManager,
+  createRunRuntimeReader,
+  createRunRuntimeReaderWithDoc
+};
+//# sourceMappingURL=chunk-IIIZZ4E4.js.map