@ixo/editor 6.32.0 → 6.32.1

package/dist/core/index.js

@@ -14,8 +14,12 @@ import {
   swapFlowBlocks,
   updateNodeRuntime,
   upsertFlowParticipant
-} from "../chunk-S7CAGFE3.js";
+} from "../chunk-A4CWC4AG.js";
 import {
+  ACTION_MANIFEST_V2_SCHEMA,
+  ACTION_MANIFEST_VERSION,
+  ACTION_REGISTRY_VERSION,
+  ActionManifestV2VerificationError,
   ExplicitRunRequiredError,
   FLOW_CONNECTIONS_MAP_KEY,
   FLOW_CONNECTION_BINDINGS_MAP_KEY,
@@ -26,6 +30,8 @@ import {
   LATEST_VERSION,
   LEGACY_RUN_STORAGE_VERSION,
   MAX_RUN_ACTION_OUTPUT_BYTES,
+  MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT,
+  MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES,
   MULTI_RUN_STORAGE_VERSION,
   NODE_CONTEXT_MAP_NAME,
   NODE_CONTEXT_OVERRIDES_MAP_NAME,
@@ -48,6 +54,7 @@ import {
   XERO_WORK_ITEMS_MAP_NAME,
   XERO_WORK_TERMINAL_MAP_NAME,
   acquireFlowAgentLease,
+  actionManifestIssues,
   actionTypeToCan,
   adoptLegacyRuntime,
   appendAgentLedgerEvent,
@@ -70,6 +77,8 @@ import {
   canToActionType,
   canToType,
   cancelRun,
+  canonicalActionJson,
+  canonicalizeManifestV2Payload,
   capabilityPatternCoversCan,
   classifyBlockerCause,
   classifyNodeState,
@@ -79,6 +88,7 @@ import {
   closeRun,
   collectPhantomLegacyRun,
   compileBaseUcanFlow,
+  computeActionManifestV2Digest,
   computeAgentCommandId,
   computePendingInvocationId,
   computeRunDefinitionHash,
@@ -123,6 +133,7 @@ import {
   getAction,
   getActionByCan,
   getActionForBlock,
+  getActionPresentation,
   getActiveEditor,
   getAliasEntries,
   getAllActions,
@@ -237,6 +248,8 @@ import {
   setMultiRunStorage,
   setTempUcanEnforcementDisabled,
   setupFlowFromBaseUcan,
+  sha256Digest,
+  signActionManifestV2,
   snapshotInputRefs,
   snapshotNode,
   startRun,
@@ -256,18 +269,442 @@ import {
   validateActionProof,
   validateAgentCommand,
   validateFlowAgentLease,
+  validateTopicSemanticRecord,
+  validateTopicSemanticRecordBatch,
+  verifyActionManifestV2,
   verifyCompletion,
   writeActionState,
   writeCompiledBlocksToFragment,
   writeRunRecordAndReconcile,
   xeroOracleActivityForBlock,
   xeroOracleActivityForBlockForEditor
-} from "../chunk-ZXNBOVAA.js";
+} from "../chunk-NEOPTPDF.js";
 import {
   computeCID,
   computeJsonCID
 } from "../chunk-ZPMRM6DA.js";
 
+// src/core/lib/topicActions/topicActionBridge.ts
+var TopicRevisionConflictError = class extends Error {
+  constructor(currentRevision) {
+    super(`Topic revision conflict; current revision is ${currentRevision}`);
+    this.currentRevision = currentRevision;
+    this.name = "TopicRevisionConflictError";
+  }
+};
+function mergeOutboxProgress(current, next) {
+  return {
+    ...current,
+    ...next,
+    attempts: Math.max(current.attempts, next.attempts),
+    receiptDelivery: next.receiptDelivery ?? current.receiptDelivery,
+    noticeDelivery: next.noticeDelivery ?? current.noticeDelivery
+  };
+}
+var InMemoryTopicActionOutboxStore = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.delivered = /* @__PURE__ */ new Set();
+    this.sequences = /* @__PURE__ */ new Map();
+  }
+  async nextSequence(topicId, requestId) {
+    const key = `${topicId}|${requestId}`;
+    const sequence = (this.sequences.get(key) || 0) + 1;
+    this.sequences.set(key, sequence);
+    return sequence;
+  }
+  async enqueue(entry) {
+    if (this.entries.has(entry.deduplicationKey) || this.delivered.has(entry.deduplicationKey)) return "duplicate";
+    this.entries.set(entry.deduplicationKey, structuredClone(entry));
+    return "queued";
+  }
+  async pending() {
+    return [...this.entries.values()].map((entry) => structuredClone(entry));
+  }
+  async update(entry) {
+    if (this.delivered.has(entry.deduplicationKey)) return;
+    const current = this.entries.get(entry.deduplicationKey);
+    this.entries.set(entry.deduplicationKey, structuredClone(current ? mergeOutboxProgress(current, entry) : entry));
+  }
+  async markDelivered(deduplicationKey) {
+    this.entries.delete(deduplicationKey);
+    this.delivered.add(deduplicationKey);
+  }
+  async has(deduplicationKey) {
+    return this.entries.has(deduplicationKey) || this.delivered.has(deduplicationKey);
+  }
+};
+var YjsTopicActionOutboxStore = class {
+  constructor(yDoc) {
+    this.yDoc = yDoc;
+    this.entries = yDoc.getMap("topicActionReceiptOutbox");
+    this.delivered = yDoc.getMap("topicActionReceiptDelivered");
+    this.sequences = yDoc.getMap("topicActionReceiptSequences");
+  }
+  async nextSequence(topicId, requestId) {
+    const key = `${topicId}|${requestId}`;
+    let sequence = 0;
+    this.yDoc.transact(() => {
+      sequence = (this.sequences.get(key) || 0) + 1;
+      this.sequences.set(key, sequence);
+    }, "topic-action-sequence");
+    return sequence;
+  }
+  async enqueue(entry) {
+    if (this.entries.has(entry.deduplicationKey) || this.delivered.has(entry.deduplicationKey)) return "duplicate";
+    this.entries.set(entry.deduplicationKey, structuredClone(entry));
+    return "queued";
+  }
+  async pending() {
+    return [...this.entries.values()].filter((entry) => !this.delivered.has(entry.deduplicationKey)).map((entry) => structuredClone(entry));
+  }
+  async update(entry) {
+    this.yDoc.transact(() => {
+      if (this.delivered.has(entry.deduplicationKey)) return;
+      const current = this.entries.get(entry.deduplicationKey);
+      this.entries.set(entry.deduplicationKey, structuredClone(current ? mergeOutboxProgress(current, entry) : entry));
+    }, "topic-action-outbox-progress");
+  }
+  async markDelivered(deduplicationKey, operationId, topicRevision) {
+    this.yDoc.transact(() => {
+      this.entries.delete(deduplicationKey);
+      this.delivered.set(deduplicationKey, { operationId, topicRevision });
+    }, "topic-action-delivered");
+  }
+  async has(deduplicationKey) {
+    return this.entries.has(deduplicationKey) || this.delivered.has(deduplicationKey);
+  }
+};
+function readPath(value, path) {
+  return path.split(".").reduce((current, segment) => current && typeof current === "object" ? current[segment] : void 0, value);
+}
+function safeSummary(value, sensitivePaths) {
+  if (!value) return void 0;
+  const sensitiveRoots = new Set(sensitivePaths.map((path) => path.split(".")[0]));
+  const summary = {};
+  for (const key of Object.keys(value).sort()) {
+    if (Object.keys(summary).length >= 20 || sensitiveRoots.has(key)) continue;
+    const item = value[key];
+    if (typeof item === "string") summary[key] = item.length <= 240 ? item : `${item.slice(0, 237)}\u2026`;
+    else if (typeof item === "number" || typeof item === "boolean" || item === null) summary[key] = item;
+    else if (Array.isArray(item)) summary[key] = { count: item.length };
+    else if (item && typeof item === "object") summary[key] = { digest: sha256Digest(item) };
+  }
+  return Object.keys(summary).length > 0 ? summary : void 0;
+}
+function proofFor(action, output) {
+  if (!output || action.proof === "none") return void 0;
+  if ("validate" in action.proof) return { kind: "custom", digest: sha256Digest(output) };
+  const values = action.proof.fields.map((path) => readPath(output, path)).filter((value) => value !== void 0 && value !== null && value !== "");
+  const refs = values.filter((value) => typeof value === "string" && value.length <= 500);
+  return { kind: "fields", digest: sha256Digest(values), ...refs.length > 0 ? { refs: [...new Set(refs)].slice(0, 50) } : {} };
+}
+function localPhaseDeduplicationKey(receipt) {
+  return sha256Digest({
+    topicId: receipt.topicId,
+    requestId: receipt.requestId,
+    executionId: receipt.runtime.executionId,
+    status: receipt.status,
+    idempotencyKey: receipt.idempotencyKey
+  });
+}
+function externalReceiptDeduplicationKey(receipt) {
+  return sha256Digest({ topicId: receipt.topicId, requestId: receipt.requestId, receiptId: receipt.receiptId, sequence: receipt.sequence });
+}
+function topicSemanticRecordsDigest(records) {
+  return sha256Digest(records);
+}
+function validateSemanticRecords(action, records) {
+  if (!action.topic) throw new Error("Action has no Topic policy");
+  const result = validateTopicSemanticRecordBatch(records, action.topic);
+  if (!result.valid) throw new Error(`Invalid Topic semantic record (${result.code})`);
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "rejected", "cancelled", "needs_verification"]);
+var MAX_RECEIPT_DELIVERY_ATTEMPTS = 3;
+function statusWording(status) {
+  switch (status) {
+    case "succeeded":
+      return "completed successfully";
+    case "failed":
+      return "failed";
+    case "rejected":
+      return "was rejected";
+    case "cancelled":
+      return "was cancelled";
+    case "needs_verification":
+      return "completed and needs verification";
+  }
+}
+function topicActionThreadUpdateBody(action, status, semanticRecords) {
+  const recordText = semanticRecords.length > 0 ? ` ${semanticRecords.map((record) => `${record.displayName}: ${record.description}`).join(" ")}` : "";
+  return `${action.displayName} ${statusWording(status)}. ${action.description}${recordText} This update does not change the Topic, contract, outcome, claim, or settlement lifecycle.`;
+}
+function topicActionThreadUpdateId(input) {
+  return sha256Digest(input);
+}
+function buildTopicActionThreadUpdate(receipt, action, semanticRecords) {
+  if (!TERMINAL_STATUSES.has(receipt.status)) return void 0;
+  const status = receipt.status;
+  const definitions = new Map((action.topic?.semanticRecordTypes || []).map((definition) => [definition.type, definition]));
+  const presentedRecords = semanticRecords.map((record) => {
+    const definition = definitions.get(record.type);
+    return {
+      recordId: record.id,
+      type: record.type,
+      version: record.version,
+      displayName: definition.displayName,
+      description: definition.description
+    };
+  });
+  const body = topicActionThreadUpdateBody(action, status, presentedRecords);
+  const semanticRecordReferences = presentedRecords.map(({ recordId, type, version }) => ({ recordId, type, version }));
+  return {
+    version: 1,
+    updateId: topicActionThreadUpdateId({
+      topicId: receipt.topicId,
+      requestId: receipt.requestId,
+      receiptId: receipt.receiptId,
+      status,
+      semanticRecords: semanticRecordReferences
+    }),
+    topicId: receipt.topicId,
+    requestId: receipt.requestId,
+    receipt: { receiptId: receipt.receiptId },
+    action: { type: action.type, displayName: action.displayName, description: action.description },
+    status,
+    occurredAt: receipt.occurredAt,
+    semanticRecords: presentedRecords,
+    body,
+    lifecycleEffect: "none"
+  };
+}
+function topicActionThreadUpdateTransactionId(update) {
+  return `topic-action-update-${update.updateId.slice("sha256:".length)}`;
+}
+var TopicActionBridge = class {
+  constructor(sink, signer, store = new InMemoryTopicActionOutboxStore(), verifier, now = () => /* @__PURE__ */ new Date()) {
+    this.sink = sink;
+    this.signer = signer;
+    this.store = store;
+    this.verifier = verifier;
+    this.now = now;
+    this.deliveries = /* @__PURE__ */ new Map();
+  }
+  async recordFlowPhase(params) {
+    const action = getAction(params.actionType);
+    if (!action) return { state: "rejected", error: `Unknown Action '${params.actionType}'` };
+    const manifestEntry = generateActionManifest().actions.find((entry) => entry.type === action.type);
+    if (!manifestEntry) return { state: "rejected", error: `Action '${action.type}' is absent from Manifest v4` };
+    const baseKind = params.topic.kind.source === "standard" ? params.topic.kind.kind : params.topic.kind.baseKind;
+    if (!action.topic?.supportedBaseKinds.includes(baseKind)) return { state: "rejected", error: `Action '${action.type}' does not support Topic Kind '${baseKind}'` };
+    const semanticRecords = params.semanticRecords || [];
+    try {
+      validateSemanticRecords(action, semanticRecords);
+    } catch (error) {
+      return { state: "rejected", error: error instanceof Error ? error.message : "Invalid Topic semantic records" };
+    }
+    const stablePhaseKey = localPhaseDeduplicationKey({
+      topicId: params.topic.topicId,
+      requestId: params.topic.requestId,
+      status: params.status,
+      idempotencyKey: params.topic.idempotencyKey,
+      runtime: { executionId: params.executionId }
+    });
+    if (await this.store.has(stablePhaseKey)) return { state: "duplicate" };
+    const sequence = await this.store.nextSequence(params.topic.topicId, params.topic.requestId);
+    const occurredAt = params.occurredAt || this.now().toISOString();
+    const idempotencyKey = params.topic.idempotencyKey;
+    const inputSummary = safeSummary(params.input, action.sensitiveInputPaths || []);
+    const outputSummary = safeSummary(params.output, action.sensitiveOutputPaths || []);
+    const proof = proofFor(action, params.output);
+    const unsigned = {
+      version: 2,
+      receiptId: sha256Digest({ topicId: params.topic.topicId, requestId: params.topic.requestId, executionId: params.executionId, sequence, status: params.status }),
+      sequence,
+      requestId: params.topic.requestId,
+      topicId: params.topic.topicId,
+      topicRevision: params.topic.topicRevision,
+      action: { type: action.type, can: manifestEntry.can, registryVersion: ACTION_REGISTRY_VERSION, contractDigest: manifestEntry.contractDigest },
+      runtime: {
+        provider: params.topic.executorProvider,
+        ...params.topic.bindingId ? { bindingId: params.topic.bindingId } : {},
+        ...params.flowUri ? { flowUri: params.flowUri } : {},
+        ...params.sessionRunId ? { sessionRunId: params.sessionRunId } : {},
+        ...params.nodeId ? { nodeId: params.nodeId } : {},
+        executionId: params.executionId
+      },
+      actorDid: params.actorDid,
+      executorDid: params.executorDid,
+      status: params.status,
+      idempotencyKey,
+      occurredAt,
+      authorization: {
+        capability: params.topic.topicCapabilityReference,
+        ...params.invocationReference ? { invocation: params.invocationReference } : {},
+        ...params.topic.confirmationReference ? { confirmation: params.topic.confirmationReference } : {}
+      },
+      input: { digest: sha256Digest(params.input), ...inputSummary ? { summary: inputSummary } : {} },
+      semanticRecordsDigest: topicSemanticRecordsDigest(semanticRecords),
+      ...params.output ? { output: { digest: sha256Digest(params.output), ...outputSummary ? { summary: outputSummary } : {} } } : {},
+      ...proof ? { proof } : {},
+      ...params.evidenceReferences?.length ? { evidenceRefs: [...new Set(params.evidenceReferences)].slice(0, 100) } : {},
+      ...params.traceReference ? { traceRef: params.traceReference } : {},
+      ...params.error ? { error: { ...params.error.code ? { code: params.error.code.slice(0, 80) } : {}, message: params.error.message.slice(0, 2e3) } } : {}
+    };
+    const signed = await this.signer.sign(unsigned);
+    return this.queueAndFlush({ ...unsigned, ...signed }, action, semanticRecords, params.topic.topicRevision, stablePhaseKey);
+  }
+  async ingestExternalReceipt(receipt, semanticRecords = []) {
+    const action = getAction(receipt.action.type);
+    const manifest = generateActionManifest();
+    const manifestEntry = action && manifest.actions.find((entry) => entry.type === action.type);
+    if (!action || !manifestEntry) return { state: "rejected", error: "Receipt names an unknown Action" };
+    if (receipt.action.contractDigest !== manifestEntry.contractDigest || receipt.action.can !== manifestEntry.can || receipt.action.registryVersion !== manifest.registryVersion) {
+      return { state: "rejected", error: "Receipt Action contract does not match the live manifest" };
+    }
+    if (!this.verifier) return { state: "rejected", error: "No external receipt verifier is configured" };
+    const verification = await this.verifier.verify(receipt, {
+      audience: receipt.topicId,
+      capability: "topic/record-action",
+      actionType: receipt.action.type,
+      topicId: receipt.topicId
+    });
+    if (!verification.valid || verification.revoked)
+      return { state: "rejected", error: verification.reason || (verification.revoked ? "Receipt capability was revoked" : "Receipt signature is invalid") };
+    if (verification.audience && verification.audience !== receipt.topicId) return { state: "rejected", error: "Receipt has the wrong audience" };
+    if (verification.capabilities && !verification.capabilities.includes("topic/record-action"))
+      return { state: "rejected", error: "Receipt does not grant Topic receipt recording" };
+    if (verification.expiresAt && Date.parse(verification.expiresAt) <= this.now().getTime()) return { state: "rejected", error: "Receipt capability is expired" };
+    if (Date.parse(receipt.occurredAt) > this.now().getTime() + 5 * 6e4) return { state: "rejected", error: "Receipt occurrence time is too far in the future" };
+    try {
+      validateSemanticRecords(action, semanticRecords);
+    } catch (error) {
+      return { state: "rejected", error: error instanceof Error ? error.message : "Invalid Topic semantic records" };
+    }
+    if (receipt.semanticRecordsDigest !== topicSemanticRecordsDigest(semanticRecords)) {
+      return { state: "rejected", error: "Receipt semantic record digest does not match its records" };
+    }
+    return this.queueAndFlush(receipt, action, semanticRecords, receipt.topicRevision, externalReceiptDeduplicationKey(receipt));
+  }
+  async flush() {
+    const results = [];
+    for (const entry of await this.store.pending()) results.push(await this.deliver(entry));
+    return results;
+  }
+  async queueAndFlush(receipt, action, semanticRecords, writeRevision, key) {
+    if (await this.store.has(key)) return { state: "duplicate", receiptId: receipt.receiptId };
+    const queued = await this.store.enqueue({
+      deduplicationKey: key,
+      receipt,
+      semanticRecords,
+      writeRevision,
+      queuedAt: this.now().toISOString(),
+      attempts: 0,
+      threadUpdate: buildTopicActionThreadUpdate(receipt, action, semanticRecords)
+    });
+    if (queued === "duplicate") return { state: "duplicate", receiptId: receipt.receiptId };
+    const entry = (await this.store.pending()).find((candidate) => candidate.deduplicationKey === key);
+    return entry ? this.deliver(entry) : { state: "duplicate", receiptId: receipt.receiptId };
+  }
+  deliver(entry) {
+    const inFlight = this.deliveries.get(entry.deduplicationKey);
+    if (inFlight) return inFlight;
+    const delivery = this.deliverOnce(entry).finally(() => this.deliveries.delete(entry.deduplicationKey));
+    this.deliveries.set(entry.deduplicationKey, delivery);
+    return delivery;
+  }
+  async deliverOnce(entry) {
+    let current = { ...entry, attempts: entry.attempts + 1 };
+    try {
+      if (!current.receiptDelivery) {
+        const result = await this.sink.appendReceipt({ receipt: current.receipt, semanticRecords: current.semanticRecords, previousRevision: current.writeRevision });
+        current = {
+          ...current,
+          receiptDelivery: result,
+          writeRevision: result.topicRevision,
+          threadUpdate: current.threadUpdate ? { ...current.threadUpdate, receipt: { ...current.threadUpdate.receipt, operationId: result.operationId } } : void 0,
+          lastError: void 0
+        };
+        await this.store.update(current);
+      }
+      if (current.threadUpdate && !current.noticeDelivery) {
+        const notice = await this.sink.appendThreadUpdate({
+          update: current.threadUpdate,
+          transactionId: topicActionThreadUpdateTransactionId(current.threadUpdate)
+        });
+        current = { ...current, noticeDelivery: notice, lastError: void 0 };
+        await this.store.update(current);
+      }
+      const delivery = current.receiptDelivery;
+      await this.store.markDelivered(current.deduplicationKey, delivery.operationId, delivery.topicRevision);
+      return {
+        state: "delivered",
+        receiptId: current.receipt.receiptId,
+        operationId: delivery.operationId,
+        topicRevision: delivery.topicRevision,
+        ...current.noticeDelivery ? { threadEventId: current.noticeDelivery.eventId } : {}
+      };
+    } catch (error) {
+      if (!current.receiptDelivery && error instanceof TopicRevisionConflictError) {
+        current = { ...current, writeRevision: error.currentRevision, lastError: error.message };
+        await this.store.update(current);
+        if (current.attempts < MAX_RECEIPT_DELIVERY_ATTEMPTS) return this.deliverOnce(current);
+      }
+      current = { ...current, lastError: error instanceof Error ? error.message : "Topic write-back failed" };
+      await this.store.update(current);
+      return {
+        state: "queued",
+        receiptId: current.receipt.receiptId,
+        ...current.receiptDelivery ? { operationId: current.receiptDelivery.operationId, topicRevision: current.receiptDelivery.topicRevision } : {},
+        error: current.lastError
+      };
+    }
+  }
+};
+function topicActionReceiptSigningPayload(receipt) {
+  return canonicalActionJson(receipt);
+}
+
+// src/core/lib/topicActions/externalExecutorAdapter.ts
+var ManifestBoundTopicExecutorAdapter = class {
+  constructor(provider, executor, bridge) {
+    this.provider = provider;
+    this.executor = executor;
+    this.bridge = bridge;
+  }
+  async execute(invocation) {
+    this.validateInvocation(invocation);
+    const result = await this.executor.invoke(structuredClone(invocation));
+    this.validateResult(invocation, result);
+    return this.bridge.ingestExternalReceipt(result.receipt, result.semanticRecords || []);
+  }
+  validateInvocation(invocation) {
+    if (invocation.version !== 1 || invocation.executorProvider !== this.provider) throw new Error(`Invocation is not addressed to ${this.provider}`);
+    if (!invocation.requestId || !invocation.idempotencyKey || !invocation.topicId || !invocation.topicRevision) throw new Error("External Topic invocation is incomplete");
+    if (!invocation.actorDid.startsWith("did:") || !invocation.executorDid.startsWith("did:")) throw new Error("External Topic invocation requires actor and executor DIDs");
+    if (!invocation.topicCapabilityReference || !invocation.input.digest.startsWith("sha256:")) throw new Error("External Topic invocation lacks capability or safe input digest");
+    const manifest = generateActionManifest();
+    const action = manifest.actions.find((entry) => entry.type === invocation.actionType);
+    if (!action || action.hidden || action.deprecated) throw new Error(`Action '${invocation.actionType}' is unavailable to external executors`);
+    if (action.contractDigest !== invocation.actionContractDigest) throw new Error(`Action '${invocation.actionType}' contract digest does not match Manifest v4`);
+  }
+  validateResult(invocation, result) {
+    const receipt = result.receipt;
+    if (receipt.topicId !== invocation.topicId || receipt.topicRevision !== invocation.topicRevision || receipt.requestId !== invocation.requestId || receipt.idempotencyKey !== invocation.idempotencyKey) {
+      throw new Error("External receipt does not correlate to its invocation");
+    }
+    if (receipt.runtime.provider !== this.provider || receipt.action.type !== invocation.actionType || receipt.action.contractDigest !== invocation.actionContractDigest) {
+      throw new Error("External receipt provider or Action contract does not match its invocation");
+    }
+    if (receipt.actorDid !== invocation.actorDid || receipt.executorDid !== invocation.executorDid)
+      throw new Error("External receipt actor or executor DID does not match its invocation");
+    if (receipt.input.digest !== invocation.input.digest) throw new Error("External receipt input digest does not match its invocation");
+    if (receipt.authorization.capability !== invocation.topicCapabilityReference) throw new Error("External receipt uses a different Topic capability reference");
+  }
+};
+var createQiForgeTopicExecutorAdapter = (executor, bridge) => new ManifestBoundTopicExecutorAdapter("qiforge", executor, bridge);
+var createMcpTopicExecutorAdapter = (executor, bridge) => new ManifestBoundTopicExecutorAdapter("mcp", executor, bridge);
+
 // src/core/templates/oracleInitFlow.ts
 var oracleInitSurveySchema = {
   title: "Oracle Configuration",
@@ -648,6 +1085,10 @@ function createOracleInitFlowTemplate() {
   return { metadata, nodes };
 }
 export {
+  ACTION_MANIFEST_V2_SCHEMA,
+  ACTION_MANIFEST_VERSION,
+  ACTION_REGISTRY_VERSION,
+  ActionManifestV2VerificationError,
   ExplicitRunRequiredError,
   FLOW_CONNECTIONS_MAP_KEY,
   FLOW_CONNECTION_BINDINGS_MAP_KEY,
@@ -655,11 +1096,15 @@ export {
   FlowAgentService,
   FlowNotMigratedError,
   INVOCATIONS_MAP_KEY,
+  InMemoryTopicActionOutboxStore,
   InvalidConditionConfigError,
   LATEST_VERSION,
   LEGACY_RUN_STORAGE_VERSION,
   MAX_RUN_ACTION_OUTPUT_BYTES,
+  MAX_TOPIC_SEMANTIC_RECORDS_PER_RECEIPT,
+  MAX_TOPIC_SEMANTIC_RECORD_BATCH_BYTES,
   MULTI_RUN_STORAGE_VERSION,
+  ManifestBoundTopicExecutorAdapter,
   NODE_CONTEXT_MAP_NAME,
   NODE_CONTEXT_OVERRIDES_MAP_NAME,
   PROOF_MISSING_CODE,
@@ -673,6 +1118,8 @@ export {
   STEP_COMPLETED_EVENT,
   STEP_COMPLETED_EVENT_NAME,
   TerminalRunExecutionError,
+  TopicActionBridge,
+  TopicRevisionConflictError,
   UnknownRunError,
   VERSION_MANIFEST,
   XERO_ORACLE_WORKING_STATUSES,
@@ -680,7 +1127,9 @@ export {
   XERO_TOOLKIT,
   XERO_WORK_ITEMS_MAP_NAME,
   XERO_WORK_TERMINAL_MAP_NAME,
+  YjsTopicActionOutboxStore,
   acquireFlowAgentLease,
+  actionManifestIssues,
   actionTypeToCan,
   addFlowNode,
   adoptLegacyRuntime,
@@ -698,12 +1147,14 @@ export {
   buildFlowNodeFromBlock,
   buildRunDefinitionSnapshot,
   buildServicesFromHandlers,
+  buildTopicActionThreadUpdate,
   buildXeroInvoiceWorkKey,
   buildXeroPaymentWorkKey,
   canMatches,
   canToActionType,
   canToType,
   cancelRun,
+  canonicalizeManifestV2Payload,
   capabilityPatternCoversCan,
   classifyBlockerCause,
   classifyNodeState,
@@ -713,6 +1164,7 @@ export {
   closeRun,
   collectPhantomLegacyRun,
   compileBaseUcanFlow,
+  computeActionManifestV2Digest,
   computeAgentCommandId,
   computeCID,
   computeJsonCID,
@@ -722,9 +1174,11 @@ export {
   countPendingInvocations,
   createAgentCommand,
   createInvocationStore,
+  createMcpTopicExecutorAdapter,
   createMemoryInvocationStore,
   createMemoryUcanDelegationStore,
   createOracleInitFlowTemplate,
+  createQiForgeTopicExecutorAdapter,
   createReference,
   createRunEventIdempotencyKey,
   createRunId,
@@ -760,6 +1214,7 @@ export {
   getAction,
   getActionByCan,
   getActionForBlock,
+  getActionPresentation,
   getActiveEditor,
   getAliasEntries,
   getAllActions,
@@ -885,6 +1340,8 @@ export {
   setMultiRunStorage,
   setTempUcanEnforcementDisabled,
   setupFlowFromBaseUcan,
+  sha256Digest,
+  signActionManifestV2,
   snapshotInputRefs,
   snapshotNode,
   startRun,
@@ -893,6 +1350,11 @@ export {
   tickFlowAgent,
   toEvaluatorOperator,
   toRunJsonValue,
+  topicActionReceiptSigningPayload,
+  topicActionThreadUpdateBody,
+  topicActionThreadUpdateId,
+  topicActionThreadUpdateTransactionId,
+  topicSemanticRecordsDigest,
   typeToCan,
   updateAgentCommand,
   updateNodeRuntime,
@@ -907,6 +1369,9 @@ export {
   validateActionProof,
   validateAgentCommand,
   validateFlowAgentLease,
+  validateTopicSemanticRecord,
+  validateTopicSemanticRecordBatch,
+  verifyActionManifestV2,
   verifyCompletion,
   writeActionState,
   writeCompiledBlocksToFragment,