@ixo/editor 6.1.2 → 6.2.1

package/dist/{chunk-5Y2WABQE.js → chunk-GUKGNTGT.js}

@@ -39,7 +39,6 @@ var ACTION_TYPE_ALIASES = {
   MemberMultiSelect: "qi/pod.member-multi-select",
   governanceConfig: "qi/pod.governance-config",
   listDomainFlows: "qi/pod.list-domain-flows",
-  payment: "qi/payment.execute",
   "matrix.dm": "qi/matrix.dm"
 };
 var aliases = new Map(Object.entries(ACTION_TYPE_ALIASES));
@@ -191,7 +190,6 @@ var CAN_TO_TYPE = {
   "domain/card-preview": "qi/domain.card-preview",
   "domain/sign": "qi/domain.sign",
   "credential/store": "qi/credential.store",
-  "payment/execute": "qi/payment.execute",
   "http/request": "qi/http.request",
   "protocol/select": "qi/protocol.select",
   "human/checkbox": "qi/human.checkbox.set",
@@ -254,7 +252,8 @@ var SERVICE_GROUP_REQUIRED_HANDLERS = {
     "collection.updateIntents"
   ],
   collectionUsers: ["collectionUsers.grant", "collectionUsers.revoke", "collectionUsers.list", "collectionUsers.classifyAddress", "collectionUsers.enumerateMembers"],
-  carbon: ["carbon.loadBatches", "carbon.harvest", "carbon.retire"]
+  carbon: ["carbon.loadBatches", "carbon.harvest", "carbon.retire"],
+  kyc: ["kycLoadForm", "kycInitiate", "kycGetVerificationUrl", "kycGetStatus", "kycSaveCredential"]
 };
 function getHandlerAtPath(handlers, path) {
   return path.split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], handlers);
@@ -402,6 +401,17 @@ function buildServicesFromHandlers(handlers) {
     // we only forward the call here.
     entity: handlers?.entity?.transfer ? {
       transfer: async (params) => handlers.entity.transfer(params)
+    } : void 0,
+    // KYC verification service (qi/kyc.verify). The consumer exposes the five
+    // flat kyc* handlers (all-or-nothing group); wire each method straight
+    // through. The consumer handler owns the KYC-server calls, PII handling,
+    // and saveCredential idempotency — we only forward calls here.
+    kyc: handlers?.kycLoadForm && handlers?.kycInitiate && handlers?.kycGetVerificationUrl && handlers?.kycGetStatus && handlers?.kycSaveCredential ? {
+      loadForm: async (params) => handlers.kycLoadForm(params),
+      initiate: async (params) => handlers.kycInitiate(params),
+      getVerificationUrl: async (params) => handlers.kycGetVerificationUrl(params),
+      getStatus: async (params) => handlers.kycGetStatus(params),
+      saveCredential: async (params) => handlers.kycSaveCredential(params)
     } : void 0
   };
 }
@@ -4722,91 +4732,6 @@ registerAction({
   }
 });
 
-// src/core/lib/actionRegistry/actions/payment.ts
-registerAction({
-  type: "qi/payment.execute",
-  can: "payment/execute",
-  sideEffect: true,
-  proof: { fields: ["paymentBlockId"] },
-  defaultRequiresConfirmation: true,
-  requiredCapability: "flow/block/execute",
-  inputSchema: {
-    type: "object",
-    required: ["rowIds", "verb", "paymentBlockId"],
-    properties: {
-      rowIds: { type: "array", description: "IDs of the rows in the payment block to operate on (at least one)." },
-      verb: { type: "string", description: 'Which worker route to hit: "propose", "execute", or "check".' },
-      paymentBlockId: { type: "string", description: "The payment block ID so the oracle can edit_block back into the right place." },
-      delegationCid: { type: "string", description: "Optional user's UCAN delegation CID to the oracle." },
-      skill: { type: "object", description: "Optional skill context with cid and name." }
-    }
-  },
-  outputSchema: [
-    { path: "verb", displayName: "Action verb", type: "string" },
-    { path: "rowCount", displayName: "Rows targeted", type: "number" },
-    { path: "paymentBlockId", displayName: "Payment block ID", type: "string" }
-  ],
-  events: [
-    {
-      name: "rows.completed",
-      displayName: "Payment rows completed",
-      description: "Fires after the oracle writes terminal status for one or more rows in this batch. Listeners can react to the just-completed payouts.",
-      payloadSchema: [
-        { path: "paymentBlockId", displayName: "Payment block ID", type: "string" },
-        { path: "completedRowIds", displayName: "Completed row IDs", type: "string" },
-        { path: "failedRowIds", displayName: "Failed row IDs", type: "string" }
-      ]
-    }
-  ],
-  run: async (inputs, ctx) => {
-    const rowIds = Array.isArray(inputs.rowIds) ? inputs.rowIds.filter((v) => typeof v === "string" && v.length > 0) : [];
-    if (rowIds.length === 0) {
-      throw new Error("rowIds is required \u2014 pick at least one row before sending");
-    }
-    const verb = String(inputs.verb || "").trim().toLowerCase();
-    if (verb !== "propose" && verb !== "execute" && verb !== "check") {
-      throw new Error('verb is required and must be one of: "propose", "execute", "check"');
-    }
-    const paymentBlockId = String(inputs.paymentBlockId || "").trim();
-    if (!paymentBlockId) {
-      throw new Error("paymentBlockId is required");
-    }
-    const delegationCid = typeof inputs.delegationCid === "string" ? inputs.delegationCid : "";
-    const skillCtx = inputs.skill && typeof inputs.skill === "object" ? inputs.skill : null;
-    if (!ctx.handlers?.askCompanion) {
-      throw new Error("askCompanion handler is not available");
-    }
-    const verbDescription = verb === "propose" ? "Make payout proposals for the rows listed below." : verb === "execute" ? "Execute the previously-proposed payouts for the rows listed below." : "Check status for the rows listed below.";
-    const lines = [verbDescription];
-    lines.push(
-      "Read the flow context and the payment block to find the worker base URL, sender info, defaults, and the rows. Follow the skill's SKILL.md for the workflow.",
-      `Payment block ID: ${paymentBlockId}`,
-      `Verb: ${verb}`,
-      `Row IDs (in this batch): ${rowIds.join(", ")}`
-    );
-    if (skillCtx?.name) lines.push(`Skill name: ${skillCtx.name}`);
-    if (skillCtx?.cid) lines.push(`Skill CID: ${skillCtx.cid}`);
-    if (delegationCid) lines.push(`UCAN delegation CID: ${delegationCid}`);
-    await ctx.handlers.askCompanion(lines.join("\n"));
-    return {
-      output: {
-        verb,
-        rowCount: rowIds.length,
-        paymentBlockId
-      },
-      completion: {
-        state: "awaiting_readback",
-        readBack: {
-          kind: "paymentRows",
-          paymentBlockId,
-          rowIds,
-          verb
-        }
-      }
-    };
-  }
-});
-
 // src/core/lib/actionRegistry/actions/matrixDm.ts
 registerAction({
   type: "qi/matrix.dm",
@@ -6546,6 +6471,89 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/kycVerify.ts
+registerAction({
+  type: "qi/kyc.verify",
+  can: "kyc/verify",
+  sideEffect: true,
+  proof: { fields: ["credentialCid"] },
+  defaultRequiresConfirmation: false,
+  cardinality: "once",
+  // Human-driven (details form + hosted webview) — never event-triggered,
+  // same as the human input actions.
+  eligibleForEventTrigger: false,
+  inputSchema: {
+    type: "object",
+    required: ["protocolDid"],
+    properties: {
+      protocolDid: { type: "string", description: "DID of the KYC protocol entity to verify against. The protocol determines the KYC level and check plan." },
+      credentialType: {
+        type: "string",
+        description: "Vault index key of the credential the protocol issues (e.g. 'kycamllevel1', 'kycamllevel2'). Defaults to level 1 when omitted."
+      },
+      credentialCid: {
+        type: "string",
+        description: "Runtime-selected CID of an existing Vault credential to use (set by the FlowDetail when the user picks one of several)."
+      }
+    }
+  },
+  outputSchema: [
+    { path: "credentialCid", displayName: "Credential CID", type: "string", description: "CID of the SD-JWT credential saved to the Vault (proof of completion)." },
+    { path: "credentialType", displayName: "Credential Type", type: "string", description: "Type of the issued credential." },
+    { path: "protocolId", displayName: "Protocol ID", type: "string", description: "The KYC protocol this verification ran against." },
+    { path: "status", displayName: "Status", type: "string", description: "Terminal lifecycle status \u2014 'complete' once the credential is saved." }
+  ],
+  events: [
+    {
+      name: "kyc.completed",
+      displayName: "KYC completed",
+      description: "Fires when the issued credential has been saved to the Vault and the verification is complete.",
+      payloadSchema: [
+        { path: "credentialCid", displayName: "Credential CID", type: "string" },
+        { path: "credentialType", displayName: "Credential Type", type: "string" },
+        { path: "protocolId", displayName: "Protocol ID", type: "string" },
+        { path: "status", displayName: "Status", type: "string" }
+      ],
+      pendingDisplayFields: ["credentialType", "status"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    if (!ctx.services.kyc) {
+      throw new Error("kyc handlers not available");
+    }
+    if (!inputs.protocolDid) throw new Error("protocolDid is required");
+    const credentialType = typeof inputs.credentialType === "string" && inputs.credentialType.trim() ? inputs.credentialType.trim() : void 0;
+    const credentialCid = typeof inputs.credentialCid === "string" && inputs.credentialCid.trim() ? inputs.credentialCid.trim() : void 0;
+    const { status } = await ctx.services.kyc.getStatus({ protocolId: inputs.protocolDid });
+    let eligible = status === "issued" || status === "complete";
+    if (!eligible) {
+      try {
+        const form = await ctx.services.kyc.loadForm({ protocolDid: inputs.protocolDid, credentialType });
+        eligible = !!form.hasExistingCredential;
+      } catch (err) {
+        console.warn("[kyc.verify] vault fallback check failed", err);
+      }
+    }
+    if (!eligible) {
+      throw new Error(`KYC verification not complete \u2014 current status: ${status}`);
+    }
+    const saved = await ctx.services.kyc.saveCredential({ protocolId: inputs.protocolDid, credentialType, credentialCid });
+    if (!saved?.credentialCid) {
+      throw new Error("kyc.saveCredential returned no credentialCid. Check the [kyc:saveCredential] handler logs.");
+    }
+    const output = {
+      credentialCid: saved.credentialCid,
+      credentialType: saved.credentialType,
+      protocolId: inputs.protocolDid,
+      status: "complete"
+    };
+    return {
+      output,
+      events: [{ name: "kyc.completed", payload: output }]
+    };
+  }
+});
+
 // src/core/lib/actionRegistry/actions/_shared/delegatedTool.ts
 function parseBoundConnection(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -10599,42 +10607,6 @@ import * as Y3 from "yjs";
 
 // src/core/lib/flowEngine/readBackReconciler.ts
 import * as Y2 from "yjs";
-function isYDoc(value) {
-  return value instanceof Y2.Doc;
-}
-function getYDoc(editorOrYDoc) {
-  if (!editorOrYDoc) return void 0;
-  if (isYDoc(editorOrYDoc)) return editorOrYDoc;
-  return editorOrYDoc._yDoc;
-}
-function getEditor(editorOrYDoc) {
-  return editorOrYDoc && !isYDoc(editorOrYDoc) ? editorOrYDoc : void 0;
-}
-function getRuntime(editorOrYDoc, runtime) {
-  if (runtime) return runtime;
-  const yDoc = getYDoc(editorOrYDoc);
-  if (yDoc) return createYDocRuntimeManager(yDoc);
-  return createRuntimeStateManager(!isYDoc(editorOrYDoc) ? editorOrYDoc : void 0);
-}
-function getReconcileEditor(params, yDoc, editor) {
-  if (editor) return editor;
-  if (!yDoc || !params.document) return void 0;
-  return {
-    _yDoc: yDoc,
-    _yRuntime: yDoc.getMap("runtime"),
-    document: params.document
-  };
-}
-function makeRunId(now) {
-  return `readback-${now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function asOutput(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
-}
-function errorRecord(error) {
-  if (!error) return void 0;
-  return typeof error === "string" ? { message: error } : { message: error.message, code: error.code };
-}
 function normalizeActionReadBackMetadata(params) {
   const base = params.readBack && typeof params.readBack === "object" && !Array.isArray(params.readBack) ? { ...params.readBack } : {};
   const kind = typeof base.kind === "string" && base.kind.trim() ? base.kind.trim() : params.actionType;
@@ -10659,221 +10631,14 @@ function normalizeActionReadBackMetadata(params) {
   }
   return normalized;
 }
-function writeReconciliationRunRecord(params) {
-  if (!params.yDoc) return void 0;
-  const completedAt = params.now();
-  const runId = makeRunId(params.now);
-  const pendingInvocation = params.readBack.pendingInvocation;
-  const details = {
-    runId,
-    output: params.output,
-    events: params.events,
-    startedAt: params.readBack.requestedAt || new Date(completedAt).toISOString(),
-    completedAt: new Date(completedAt).toISOString(),
-    actorDid: params.actorDid,
-    invocationCid: params.readBack.invocationCid,
-    capabilityId: params.readBack.capabilityId,
-    error: params.error,
-    readBack: params.readBack,
-    reconciled: true
-  };
-  if (pendingInvocation) {
-    details.fromPendingInvocationId = pendingInvocation.id;
-    details.triggeredBy = {
-      sourceBlockId: pendingInvocation.triggeringBlockId,
-      eventName: pendingInvocation.eventName
-    };
-    details.sourceRunId = pendingInvocation.sourceRunId;
-  }
-  appendRunRecord(params.yDoc, params.blockId, details, params.actorDid);
-  if (params.editor && params.events.length > 0) {
-    reconcilePendingInvocations(params.editor);
-  }
-  return runId;
-}
-async function reconcileActionReadBack(params) {
-  const now = params.now || Date.now;
-  const yDoc = getYDoc(params.editorOrYDoc);
-  const editor = getEditor(params.editorOrYDoc);
-  const runtime = getRuntime(params.editorOrYDoc, params.runtime);
-  const current = runtime.get(params.blockId);
-  const output = asOutput(current.output);
-  const readBack = current.readBack;
-  if (current.state !== "awaiting_readback" || !readBack?.kind) {
-    return {
-      success: false,
-      blockId: params.blockId,
-      state: current.state === "failed" ? "failed" : "pending",
-      output,
-      events: [],
-      error: `Block "${params.blockId}" is not awaiting read-back`,
-      pendingInvocationRemoved: false,
-      readBack
-    };
-  }
-  const resolver = params.resolver || params.resolvers?.[readBack.kind];
-  if (!resolver) {
-    return {
-      success: false,
-      blockId: params.blockId,
-      state: "pending",
-      output,
-      events: [],
-      error: `No read-back resolver registered for "${readBack.kind}"`,
-      pendingInvocationRemoved: false,
-      readBack
-    };
-  }
-  const resolution = await resolver({
-    blockId: params.blockId,
-    runtime: current,
-    output,
-    readBack
-  });
-  const checkedAt = now();
-  const checkedIso = new Date(checkedAt).toISOString();
-  const nextReadBack = {
-    ...readBack,
-    ...resolution.readBack || {},
-    status: resolution.state,
-    lastCheckedAt: checkedIso
-  };
-  if (resolution.state === "pending") {
-    runtime.update(params.blockId, {
-      readBack: nextReadBack
-    });
-    return {
-      success: true,
-      blockId: params.blockId,
-      state: "pending",
-      output,
-      events: resolution.events || [],
-      pendingInvocationRemoved: false,
-      readBack: nextReadBack
-    };
-  }
-  const events = resolution.events || [];
-  const finalOutput = {
-    ...output,
-    ...resolution.output || {}
-  };
-  const actorDid = params.actorDid || readBack.actorDid || current.executedByDid || "system:readback";
-  if (resolution.state === "failed") {
-    const error = errorRecord(resolution.error) || { message: "External read-back failed" };
-    const failedReadBack = {
-      ...nextReadBack,
-      terminalAt: checkedIso
-    };
-    runtime.update(params.blockId, {
-      state: "failed",
-      output: finalOutput,
-      error: { ...error, at: checkedAt },
-      readBack: failedReadBack
-    });
-    const runId2 = writeReconciliationRunRecord({
-      yDoc,
-      editor: getReconcileEditor(params, yDoc, editor),
-      blockId: params.blockId,
-      actorDid,
-      output: finalOutput,
-      events,
-      readBack: failedReadBack,
-      error,
-      now
-    });
-    return {
-      success: false,
-      blockId: params.blockId,
-      state: "failed",
-      output: finalOutput,
-      events,
-      error: error.message,
-      runId: runId2,
-      pendingInvocationRemoved: false,
-      readBack: failedReadBack
-    };
-  }
-  const readBackActionType = readBack.actionType || readBack.kind;
-  const actionDef = readBackActionType ? getAction(readBackActionType) : void 0;
-  if (actionDef) {
-    const proofCheck = validateActionProof(actionDef, finalOutput || {});
-    if (!proofCheck.valid) {
-      const message = proofCheck.reason || "Read-back resolved completed without proof of execution.";
-      const proofFailedReadBack = {
-        ...nextReadBack,
-        terminalAt: checkedIso
-      };
-      runtime.update(params.blockId, {
-        state: actionDef.sideEffect ? "needs_verification" : "failed",
-        output: finalOutput,
-        error: { message, code: PROOF_MISSING_CODE, at: checkedAt },
-        readBack: proofFailedReadBack
-      });
-      const failedRunId = writeReconciliationRunRecord({
-        yDoc,
-        editor: getReconcileEditor(params, yDoc, editor),
-        blockId: params.blockId,
-        actorDid,
-        output: finalOutput,
-        events,
-        readBack: proofFailedReadBack,
-        error: { message, code: PROOF_MISSING_CODE },
-        now
-      });
-      return {
-        success: false,
-        blockId: params.blockId,
-        state: "failed",
-        output: finalOutput,
-        events,
-        error: message,
-        runId: failedRunId,
-        pendingInvocationRemoved: false,
-        readBack: proofFailedReadBack
-      };
-    }
-  }
-  const completedReadBack = {
-    ...nextReadBack,
-    terminalAt: checkedIso
-  };
-  runtime.update(params.blockId, {
-    state: "completed",
-    output: finalOutput,
-    executedAt: checkedAt,
-    error: void 0,
-    readBack: completedReadBack
-  });
-  const runId = writeReconciliationRunRecord({
-    yDoc,
-    editor: getReconcileEditor(params, yDoc, editor),
-    blockId: params.blockId,
-    actorDid,
-    output: finalOutput,
-    events,
-    readBack: completedReadBack,
-    now
-  });
-  const pendingInvocationRemoved = Boolean(yDoc && completedReadBack.pendingInvocation?.id) && removePendingInvocation(yDoc, params.blockId, completedReadBack.pendingInvocation.id);
-  return {
-    success: true,
-    blockId: params.blockId,
-    state: "completed",
-    output: finalOutput,
-    events,
-    runId,
-    pendingInvocationRemoved,
-    readBack: completedReadBack
-  };
-}
 
 // src/core/lib/flowEngine/actionExecutor.ts
-function isYDoc2(value) {
+function isYDoc(value) {
   return value instanceof Y3.Doc;
 }
-function getYDoc2(editorOrYDoc) {
+function getYDoc(editorOrYDoc) {
   if (!editorOrYDoc) return void 0;
-  if (isYDoc2(editorOrYDoc)) return editorOrYDoc;
+  if (isYDoc(editorOrYDoc)) return editorOrYDoc;
   return editorOrYDoc._yDoc;
 }
 function parseInputs2(value) {
@@ -10888,20 +10653,20 @@ function parseInputs2(value) {
     return {};
   }
 }
-function getRuntime2(editorOrYDoc, runtime) {
+function getRuntime(editorOrYDoc, runtime) {
   if (runtime) return runtime;
-  const yDoc = getYDoc2(editorOrYDoc);
+  const yDoc = getYDoc(editorOrYDoc);
   if (yDoc) return createYDocRuntimeManager(yDoc);
-  return createRuntimeStateManager(!isYDoc2(editorOrYDoc) ? editorOrYDoc : void 0);
+  return createRuntimeStateManager(!isYDoc(editorOrYDoc) ? editorOrYDoc : void 0);
 }
-function getEditor2(editorOrYDoc) {
-  return editorOrYDoc && !isYDoc2(editorOrYDoc) ? editorOrYDoc : void 0;
+function getEditor(editorOrYDoc) {
+  return editorOrYDoc && !isYDoc(editorOrYDoc) ? editorOrYDoc : void 0;
 }
 function findBlock(params) {
   if (params.block) return params.block;
   const blockId = params.blockId;
   if (!blockId) return void 0;
-  const editor = getEditor2(params.editorOrYDoc);
+  const editor = getEditor(params.editorOrYDoc);
   return (params.document || editor?.document || []).find((block) => block?.id === blockId);
 }
 function getFlowMetadata(editor) {
@@ -10935,8 +10700,8 @@ function getNodeOutput(runtime, nodeId) {
 }
 function buildActionRunInputs(params) {
   const blockId = params.blockId || params.block?.id;
-  const yDoc = getYDoc2(params.editorOrYDoc);
-  const runtime = getRuntime2(params.editorOrYDoc, params.runtime);
+  const yDoc = getYDoc(params.editorOrYDoc);
+  const runtime = getRuntime(params.editorOrYDoc, params.runtime);
   const savedInputs = parseInputs2(params.savedInputs ?? params.block?.props?.inputs);
   const pendingInvocation = getPendingInvocation(yDoc, blockId, params.pendingInvocationId);
   const triggerContext = pendingInvocation ? {
@@ -10975,10 +10740,10 @@ function updateRuntimeFailure(runtime, blockId, message, now) {
     error: { message, at: now() }
   });
 }
-function makeRunId2(now) {
+function makeRunId(now) {
   return `run-${now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function getReconcileEditor2(params, yDoc, editor) {
+function getReconcileEditor(params, yDoc, editor) {
   if (editor) return editor;
   if (!yDoc || !params.document) return void 0;
   return {
@@ -10989,7 +10754,7 @@ function getReconcileEditor2(params, yDoc, editor) {
 }
 function persistEvents(params) {
   if (!params.yDoc || params.events.length === 0) return void 0;
-  const runId = makeRunId2(params.now);
+  const runId = makeRunId(params.now);
   const details = {
     runId,
     output: params.output,
@@ -11021,9 +10786,9 @@ function cleanupCompletedPendingInvocation(yDoc, blockId, pendingInvocation) {
 async function executeActionBlock(params) {
   const block = findBlock(params);
   const blockId = params.blockId || block?.id;
-  const editor = getEditor2(params.editorOrYDoc);
-  const yDoc = getYDoc2(params.editorOrYDoc);
-  const runtime = getRuntime2(params.editorOrYDoc, params.runtime);
+  const editor = getEditor(params.editorOrYDoc);
+  const yDoc = getYDoc(params.editorOrYDoc);
+  const runtime = getRuntime(params.editorOrYDoc, params.runtime);
   const now = params.now || Date.now;
   if (!block || !blockId) {
     return buildFailureResult({
@@ -11183,7 +10948,7 @@ async function executeActionBlock(params) {
   });
   const runId = persistEvents({
     yDoc,
-    editor: getReconcileEditor2(params, yDoc, editor),
+    editor: getReconcileEditor(params, yDoc, editor),
     blockId,
     actorDid: params.actorDid,
     output,
@@ -11445,7 +11210,6 @@ var ICON_DEFAULTS = {
   "domain/card-preview": "id",
   "domain/sign": "feather",
   "credential/store": "shield",
-  "payment/execute": "credit-card",
   "http/request": "cloud",
   "protocol/select": "git-branch",
   "human/checkbox": "check-square",
@@ -12943,7 +12707,7 @@ var BLOCKER_DIAGNOSIS_VERSION = 2;
 function getBlocks(context) {
   return context.blocks || context.editor?.document || [];
 }
-function getRuntime3(yDoc, nodeId) {
+function getRuntime2(yDoc, nodeId) {
   const runtime = yDoc.getMap("runtime");
   const value = runtime.get(nodeId);
   return value && typeof value === "object" ? value : {};
@@ -13153,7 +12917,7 @@ function planRalphLoopCommands(context, options = {}) {
     const nodeId = getBlockId(block);
     if (!nodeId) continue;
     const pendingInvocationCount = readPendingInvocations(context.yDoc, nodeId).length;
-    const runtime = getRuntime3(context.yDoc, nodeId);
+    const runtime = getRuntime2(context.yDoc, nodeId);
     const actionType = getBlockActionType(block);
     const completionVerification = verifyCompletion({
       runtime,
@@ -13845,7 +13609,6 @@ export {
   executeNode,
   PROOF_MISSING_CODE,
   validateActionProof,
-  reconcileActionReadBack,
   buildActionRunInputs,
   executeActionBlock,
   verifyCompletion,
@@ -13906,4 +13669,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-5Y2WABQE.js.map
+//# sourceMappingURL=chunk-GUKGNTGT.js.map