@ixo/editor 5.39.0 → 5.40.0

package/dist/{chunk-YWZJYSOP.js → chunk-KNMPGX5G.js}

@@ -1,5 +1,12 @@
 // src/core/lib/actionRegistry/registry.ts
 var actions = /* @__PURE__ */ new Map();
+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 ACTION_TYPE_ALIASES = {
   bid: "qi/bid.submit",
   claim: "qi/claim.submit",
@@ -51,15 +58,21 @@ function getActionByCan(can) {
 }
 function getEventsForBlock(action, inputs) {
   if (!action) return [];
+  let events;
   if (action.getDynamicEvents) {
     const parsed = normalizeInputs(inputs);
     try {
-      return action.getDynamicEvents(parsed) || [];
+      events = action.getDynamicEvents(parsed) || [];
     } catch {
-      return [];
+      events = [];
     }
+  } else {
+    events = action.events || [];
   }
-  return 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 [];
@@ -9031,438 +9044,90 @@ var createUcanService = (config) => {
   };
 };
 
-// src/core/lib/flowEngine/utils.ts
-var buildAuthzFromProps = (props) => {
-  const linkedClaimCollectionId = typeof props.linkedClaimCollectionId === "string" ? props.linkedClaimCollectionId.trim() : "";
-  const authz = {};
-  if (linkedClaimCollectionId) {
-    authz.linkedClaim = { collectionId: linkedClaimCollectionId };
-  }
-  return authz;
-};
-var buildFlowNodeFromBlock = (block) => {
-  const base = {
-    id: block.id,
-    type: block.type,
-    props: block.props || {}
-  };
-  const authz = buildAuthzFromProps(block.props || {});
-  return {
-    ...base,
-    ...authz
-  };
-};
-
-// src/core/lib/flowEngine/runtime.ts
-var XERO_WORK_ITEMS_MAP_NAME = "xeroWorkItems";
-var XERO_CONNECTION_MAP_NAME = "xeroConnection";
-var ensureStateObject = (value) => {
-  if (!value || typeof value !== "object") {
-    return {};
-  }
-  return { ...value };
-};
-var createYMapManager = (map) => {
-  return {
-    get: (nodeId) => {
-      const stored = map.get(nodeId);
-      return ensureStateObject(stored);
-    },
-    update: (nodeId, updates) => {
-      const current = ensureStateObject(map.get(nodeId));
-      map.set(nodeId, { ...current, ...updates });
-    }
-  };
-};
-var createMemoryManager = () => {
-  const memory = /* @__PURE__ */ new Map();
-  return {
-    get: (nodeId) => ensureStateObject(memory.get(nodeId)),
-    update: (nodeId, updates) => {
-      const current = ensureStateObject(memory.get(nodeId));
-      memory.set(nodeId, { ...current, ...updates });
-    }
-  };
-};
-var createRuntimeStateManager = (editor) => {
-  if (editor?._yRuntime) {
-    return createYMapManager(editor._yRuntime);
-  }
-  return createMemoryManager();
-};
-var createYDocRuntimeManager = (yDoc) => {
-  return createYMapManager(yDoc.getMap("runtime"));
-};
-function clearRuntimeForTemplateClone(yDoc) {
-  const runtime = yDoc.getMap("runtime");
-  const invocations = yDoc.getMap("invocations");
-  const pendingInvocations = yDoc.getMap("pendingInvocations");
-  const agentOutbox = yDoc.getMap("agentOutbox");
-  const agentLeases = yDoc.getMap("agentLeases");
-  const auditTrail = yDoc.getMap("auditTrail");
-  const xeroWorkItems = yDoc.getMap(XERO_WORK_ITEMS_MAP_NAME);
-  const xeroConnection = yDoc.getMap(XERO_CONNECTION_MAP_NAME);
-  yDoc.transact(() => {
-    runtime.forEach((_, key) => runtime.delete(key));
-    invocations.forEach((_, key) => invocations.delete(key));
-    pendingInvocations.forEach((_, key) => pendingInvocations.delete(key));
-    agentOutbox.forEach((_, key) => agentOutbox.delete(key));
-    agentLeases.forEach((_, key) => agentLeases.delete(key));
-    auditTrail.forEach((_, key) => auditTrail.delete(key));
-    xeroWorkItems.forEach((_, key) => xeroWorkItems.delete(key));
-    xeroConnection.forEach((_, key) => xeroConnection.delete(key));
-  });
-}
-
 // src/core/types/baseUcan.ts
 function isRuntimeRef(value) {
   return typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string";
 }
 
-// src/core/lib/flowCompiler/resolveRefs.ts
-function resolveRuntimeRefs(nb, getNodeOutput2, triggerContext) {
-  return resolveValue(nb, getNodeOutput2, triggerContext);
+// src/core/lib/flowEngine/triggers.ts
+import * as Y from "yjs";
+var RUN_RECORD_AUDIT_TYPE = "block.run";
+function computePendingInvocationId(args) {
+  const { sourceBlockId, sourceRunId, listenerBlockId, eventName, eventIndex } = args;
+  const input = `${sourceBlockId}:${sourceRunId}:${listenerBlockId}:${eventName}:${eventIndex}`;
+  return `pi-${fnv1a32(input)}`;
 }
-function resolveValue(value, getNodeOutput2, triggerContext) {
+function snapshotInputRefs(inputs, getNodeOutput2) {
+  const snapshots = {};
+  walkRefs(inputs, (ref) => {
+    if (ref.$ref.startsWith("trigger.")) return;
+    const parsed = parseOutputRef(ref.$ref);
+    if (!parsed) return;
+    const output = getNodeOutput2(parsed.nodeId);
+    if (!output) return;
+    snapshots[ref.$ref] = getNestedValue2(output, parsed.fieldPath);
+  });
+  return snapshots;
+}
+function walkRefs(value, visit) {
   if (isRuntimeRef(value)) {
-    return resolveRef(value.$ref, getNodeOutput2, triggerContext);
+    visit(value);
+    return;
   }
   if (Array.isArray(value)) {
-    return value.map((item) => resolveValue(item, getNodeOutput2, triggerContext));
+    for (const item of value) walkRefs(item, visit);
+    return;
   }
   if (typeof value === "object" && value !== null) {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = resolveValue(val, getNodeOutput2, triggerContext);
-    }
-    return result;
+    for (const v of Object.values(value)) walkRefs(v, visit);
   }
-  return value;
 }
-function resolveRef(ref, getNodeOutput2, triggerContext) {
-  if (ref.startsWith("trigger.payload.")) {
-    if (!triggerContext) {
-      throw new Error(`Trigger ref "${ref}" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);
-    }
-    const fieldPath2 = ref.slice("trigger.payload.".length);
-    return getNestedValue2(triggerContext.payload, fieldPath2);
-  }
-  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
-    return triggerContext.refSnapshots[ref];
-  }
+function parseOutputRef(ref) {
   const outputIndex = ref.indexOf(".output.");
-  if (outputIndex === -1) {
-    throw new Error(`Invalid runtime reference "${ref}". Expected format: "nodeId.output.fieldPath" or "trigger.payload.fieldPath"`);
-  }
-  const nodeId = ref.slice(0, outputIndex);
-  const fieldPath = ref.slice(outputIndex + ".output.".length);
-  const output = getNodeOutput2(nodeId);
-  if (!output) {
-    return void 0;
-  }
-  return getNestedValue2(output, fieldPath);
+  if (outputIndex === -1) return null;
+  return {
+    nodeId: ref.slice(0, outputIndex),
+    fieldPath: ref.slice(outputIndex + ".output.".length)
+  };
 }
 function getNestedValue2(obj, path) {
   const parts = path.split(".");
   let current = obj;
   for (const part of parts) {
-    if (current == null || typeof current !== "object") {
-      return void 0;
-    }
+    if (current == null || typeof current !== "object") return void 0;
     current = current[part];
   }
   return current;
 }
-
-// src/core/lib/flowEngine/versionManifest.ts
-var VERSION_MANIFEST = {
-  "0.3": {
-    version: "0.3",
-    label: "Legacy",
-    ucanRequired: false,
-    delegationRootRequired: false,
-    whitelistOnlyAllowed: true,
-    unrestrictedAllowed: true,
-    executionPath: "legacy",
-    authorizationFn: "v1",
-    allowedAuthModes: ["anyone", "actors", "capability"],
-    ui: {
-      showDelegationPanel: false,
-      showWhitelistConfig: true,
-      showAnyoneConfig: true,
-      showMigrationBanner: true,
-      requirePinForExecution: false
-    },
-    description: "Legacy version. UCAN optional, whitelist-only authorization accepted."
-  },
-  "1.0.0": {
-    version: "1.0.0",
-    label: "UCAN Required",
-    /** TEMP Disablement - needs to be true TODO */
-    ucanRequired: false,
-    delegationRootRequired: true,
-    whitelistOnlyAllowed: false,
-    unrestrictedAllowed: false,
-    executionPath: "invocation",
-    authorizationFn: "v2",
-    allowedAuthModes: ["capability"],
-    ui: {
-      showDelegationPanel: true,
-      showWhitelistConfig: false,
-      showAnyoneConfig: false,
-      showMigrationBanner: false,
-      requirePinForExecution: true
-    },
-    description: "UCAN-enforced. Every block execution requires a valid delegation chain."
-  }
-};
-var LATEST_VERSION = "1.0.0";
-function getVersionPolicy(version) {
-  const policy = VERSION_MANIFEST[version];
-  if (!policy) {
-    return VERSION_MANIFEST[LATEST_VERSION];
+function fnv1a32(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
   }
-  return policy;
+  return (hash >>> 0).toString(16).padStart(8, "0");
 }
-
-// src/core/lib/flowEngine/authorization.ts
-var isAuthorized = async (blockId, actorDid, ucanService, flowUri, schemaVersion) => {
-  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
-  if (policy && !policy.ucanRequired) {
-    return { authorized: true };
+var PENDING_INVOCATIONS_MAP_KEY = "pendingInvocations";
+function getPendingInvocationsMap(yDoc) {
+  return yDoc.getMap(PENDING_INVOCATIONS_MAP_KEY);
+}
+function getOrCreateBlockPendingMap(yDoc, blockId) {
+  const outer = getPendingInvocationsMap(yDoc);
+  let inner = outer.get(blockId);
+  if (!inner) {
+    inner = new Y.Map();
+    outer.set(blockId, inner);
   }
-  if (!ucanService) {
-    if (!policy) {
-      return { authorized: true };
-    }
-    return {
-      authorized: false,
-      reason: "UCAN service is not configured. This flow version requires UCAN authorization."
-    };
-  }
-  const capability = {
-    can: "flow/block/execute",
-    with: `${flowUri}:${blockId}`
-  };
-  const result = await ucanService.validateDelegationChain(actorDid, capability);
-  if (!result.valid) {
-    return {
-      authorized: false,
-      reason: result.error || "No valid capability chain found"
-    };
-  }
-  const proofCids = result.proofChain?.map((d) => d.cid) || [];
-  return {
-    authorized: true,
-    capabilityId: proofCids[0],
-    proofCids
-  };
-};
-
-// src/core/lib/flowEngine/executor.ts
-var updateRuntimeAfterSuccess = (node, actorDid, runtime, actionResult, invocationCid, now) => {
-  const updates = {
-    submittedByDid: actionResult.submittedByDid || actorDid,
-    evaluationStatus: actionResult.evaluationStatus || "pending",
-    executionTimestamp: now ? now() : Date.now(),
-    lastInvocationCid: invocationCid
-  };
-  if (actionResult.claimId) {
-    updates.claimId = actionResult.claimId;
-  }
-  runtime.update(node.id, updates);
-};
-var executeNode = async ({ node, actorDid, actorType, entityRoomId, context, action, pin }) => {
-  const { runtime, ucanService, invocationStore, flowUri, flowId, schemaVersion, now } = context;
-  const auth = await isAuthorized(node.id, actorDid, ucanService, flowUri, schemaVersion);
-  if (!auth.authorized) {
-    return { success: false, stage: "authorization", error: auth.reason };
-  }
-  if (node.linkedClaim && !node.linkedClaim.collectionId) {
-    return { success: false, stage: "claim", error: "Linked claim collection is required but missing." };
-  }
-  let invocationCid;
-  let invocationData;
-  if (ucanService && auth.proofCids && auth.proofCids.length > 0) {
-    const capability = {
-      can: "flow/block/execute",
-      with: `${flowUri}:${node.id}`
-    };
-    try {
-      const invocationResult = await ucanService.createAndValidateInvocation(
-        {
-          invokerDid: actorDid,
-          invokerType: actorType,
-          entityRoomId,
-          capability,
-          proofs: auth.proofCids,
-          pin
-        },
-        flowId,
-        node.id
-      );
-      if (!invocationResult.valid) {
-        return {
-          success: false,
-          stage: "authorization",
-          error: `Invocation validation failed: ${invocationResult.error}`
-        };
-      }
-      invocationCid = invocationResult.cid;
-      invocationData = invocationResult.invocation;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to create invocation";
-      return { success: false, stage: "authorization", error: message };
-    }
-  }
-  try {
-    const result = await action();
-    if (node.linkedClaim && !result.claimId) {
-      if (invocationStore && invocationCid && invocationData) {
-        const storedInvocation = {
-          cid: invocationCid,
-          invocation: invocationData,
-          invokerDid: actorDid,
-          capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
-          executedAt: now ? now() : Date.now(),
-          flowId,
-          blockId: node.id,
-          result: "failure",
-          error: "Execution did not return a claimId for linked claim requirement.",
-          proofCids: auth.proofCids || []
-        };
-        invocationStore.add(storedInvocation);
-      }
-      return {
-        success: false,
-        stage: "claim",
-        error: "Execution did not return a claimId for linked claim requirement.",
-        invocationCid
-      };
-    }
-    if (invocationStore && invocationCid && invocationData) {
-      const storedInvocation = {
-        cid: invocationCid,
-        invocation: invocationData,
-        invokerDid: actorDid,
-        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
-        executedAt: now ? now() : Date.now(),
-        flowId,
-        blockId: node.id,
-        result: "success",
-        proofCids: auth.proofCids || [],
-        claimId: result.claimId
-      };
-      invocationStore.add(storedInvocation);
-    }
-    updateRuntimeAfterSuccess(node, actorDid, runtime, result, invocationCid || auth.capabilityId, now);
-    return {
-      success: true,
-      stage: "complete",
-      result,
-      capabilityId: auth.capabilityId,
-      invocationCid
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Execution failed";
-    if (invocationStore && invocationCid && invocationData) {
-      const storedInvocation = {
-        cid: invocationCid,
-        invocation: invocationData,
-        invokerDid: actorDid,
-        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
-        executedAt: now ? now() : Date.now(),
-        flowId,
-        blockId: node.id,
-        result: "failure",
-        error: message,
-        proofCids: auth.proofCids || []
-      };
-      invocationStore.add(storedInvocation);
-    }
-    return { success: false, stage: "action", error: message, invocationCid };
-  }
-};
-
-// src/core/lib/flowEngine/triggers.ts
-import * as Y from "yjs";
-var RUN_RECORD_AUDIT_TYPE = "block.run";
-function computePendingInvocationId(args) {
-  const { sourceBlockId, sourceRunId, listenerBlockId, eventName, eventIndex } = args;
-  const input = `${sourceBlockId}:${sourceRunId}:${listenerBlockId}:${eventName}:${eventIndex}`;
-  return `pi-${fnv1a32(input)}`;
-}
-function snapshotInputRefs(inputs, getNodeOutput2) {
-  const snapshots = {};
-  walkRefs(inputs, (ref) => {
-    if (ref.$ref.startsWith("trigger.")) return;
-    const parsed = parseOutputRef(ref.$ref);
-    if (!parsed) return;
-    const output = getNodeOutput2(parsed.nodeId);
-    if (!output) return;
-    snapshots[ref.$ref] = getNestedValue3(output, parsed.fieldPath);
-  });
-  return snapshots;
-}
-function walkRefs(value, visit) {
-  if (isRuntimeRef(value)) {
-    visit(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) walkRefs(item, visit);
-    return;
-  }
-  if (typeof value === "object" && value !== null) {
-    for (const v of Object.values(value)) walkRefs(v, visit);
-  }
-}
-function parseOutputRef(ref) {
-  const outputIndex = ref.indexOf(".output.");
-  if (outputIndex === -1) return null;
-  return {
-    nodeId: ref.slice(0, outputIndex),
-    fieldPath: ref.slice(outputIndex + ".output.".length)
-  };
-}
-function getNestedValue3(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-function fnv1a32(input) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-var PENDING_INVOCATIONS_MAP_KEY = "pendingInvocations";
-function getPendingInvocationsMap(yDoc) {
-  return yDoc.getMap(PENDING_INVOCATIONS_MAP_KEY);
-}
-function getOrCreateBlockPendingMap(yDoc, blockId) {
-  const outer = getPendingInvocationsMap(yDoc);
-  let inner = outer.get(blockId);
-  if (!inner) {
-    inner = new Y.Map();
-    outer.set(blockId, inner);
-  }
-  return inner;
-}
-function readPendingInvocations(yDoc, blockId) {
-  const outer = getPendingInvocationsMap(yDoc);
-  const inner = outer.get(blockId);
-  if (!inner) return [];
-  const items = [];
-  inner.forEach((value) => {
-    if (value && typeof value === "object") {
-      items.push(value);
+  return inner;
+}
+function readPendingInvocations(yDoc, blockId) {
+  const outer = getPendingInvocationsMap(yDoc);
+  const inner = outer.get(blockId);
+  if (!inner) return [];
+  const items = [];
+  inner.forEach((value) => {
+    if (value && typeof value === "object") {
+      items.push(value);
     }
   });
   items.sort((a, b) => a.emittedAt.localeCompare(b.emittedAt));
@@ -9791,69 +9456,437 @@ function processBarrierRunRecord(yDoc, sourceBlockId, record, barrierListenersBy
     }
   }
 }
-function parseTrigger(block) {
-  const raw = block?.props?.trigger;
-  if (!raw || typeof raw !== "string") return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
-      return parsed;
+function parseTrigger(block) {
+  const raw = block?.props?.trigger;
+  if (!raw || typeof raw !== "string") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function parseInputs(block) {
+  const raw = block?.props?.inputs;
+  if (!raw || typeof raw !== "string") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return {};
+}
+function resolveAssignee(block) {
+  const raw = block?.props?.assignment;
+  if (!raw) return void 0;
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const did = parsed?.assignedActor?.did;
+    return typeof did === "string" && did.length > 0 ? did : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function computeExpiry(block, emittedAt) {
+  const ttlAbsolute = block?.props?.ttlAbsoluteDueDate;
+  if (typeof ttlAbsolute === "string" && ttlAbsolute) {
+    return ttlAbsolute;
+  }
+  const ttlFromEnablement = block?.props?.ttlFromEnablement;
+  if (typeof ttlFromEnablement === "string" && ttlFromEnablement) {
+    const ms = parseIsoDurationToMs(ttlFromEnablement);
+    if (ms != null) {
+      return new Date(new Date(emittedAt).getTime() + ms).toISOString();
+    }
+  }
+  return new Date(new Date(emittedAt).getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString();
+}
+function parseIsoDurationToMs(duration) {
+  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(duration);
+  if (!match) return null;
+  const [, d, h, m, s] = match;
+  let ms = 0;
+  if (d) ms += parseInt(d, 10) * 24 * 60 * 60 * 1e3;
+  if (h) ms += parseInt(h, 10) * 60 * 60 * 1e3;
+  if (m) ms += parseInt(m, 10) * 60 * 1e3;
+  if (s) ms += parseInt(s, 10) * 1e3;
+  return ms;
+}
+function getActionForBlock(block) {
+  const actionType = block?.props?.actionType;
+  if (typeof actionType !== "string") return void 0;
+  return getAction(actionType);
+}
+
+// src/core/lib/flowEngine/emitEvents.ts
+function writeRunRecordAndReconcile(editor, blockId, output, events, actorDid, detailsPatch = {}) {
+  const yDoc = editor._yDoc;
+  if (!yDoc) return;
+  if (events.length === 0) return;
+  const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const details = {
+    runId,
+    output,
+    events,
+    startedAt: now,
+    completedAt: now,
+    actorDid,
+    ...detailsPatch
+  };
+  appendRunRecord(yDoc, blockId, details, actorDid);
+  reconcilePendingInvocations(editor);
+}
+
+// src/core/lib/flowEngine/utils.ts
+var buildAuthzFromProps = (props) => {
+  const linkedClaimCollectionId = typeof props.linkedClaimCollectionId === "string" ? props.linkedClaimCollectionId.trim() : "";
+  const authz = {};
+  if (linkedClaimCollectionId) {
+    authz.linkedClaim = { collectionId: linkedClaimCollectionId };
+  }
+  return authz;
+};
+var buildFlowNodeFromBlock = (block) => {
+  const base = {
+    id: block.id,
+    type: block.type,
+    props: block.props || {}
+  };
+  const authz = buildAuthzFromProps(block.props || {});
+  return {
+    ...base,
+    ...authz
+  };
+};
+
+// src/core/lib/flowEngine/runtime.ts
+var XERO_WORK_ITEMS_MAP_NAME = "xeroWorkItems";
+var XERO_CONNECTION_MAP_NAME = "xeroConnection";
+var ensureStateObject = (value) => {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return { ...value };
+};
+var createYMapManager = (map) => {
+  return {
+    get: (nodeId) => {
+      const stored = map.get(nodeId);
+      return ensureStateObject(stored);
+    },
+    update: (nodeId, updates) => {
+      const current = ensureStateObject(map.get(nodeId));
+      map.set(nodeId, { ...current, ...updates });
+    }
+  };
+};
+var createMemoryManager = () => {
+  const memory = /* @__PURE__ */ new Map();
+  return {
+    get: (nodeId) => ensureStateObject(memory.get(nodeId)),
+    update: (nodeId, updates) => {
+      const current = ensureStateObject(memory.get(nodeId));
+      memory.set(nodeId, { ...current, ...updates });
+    }
+  };
+};
+var createRuntimeStateManager = (editor) => {
+  if (editor?._yRuntime) {
+    return createYMapManager(editor._yRuntime);
+  }
+  return createMemoryManager();
+};
+var createYDocRuntimeManager = (yDoc) => {
+  return createYMapManager(yDoc.getMap("runtime"));
+};
+function clearRuntimeForTemplateClone(yDoc) {
+  const runtime = yDoc.getMap("runtime");
+  const invocations = yDoc.getMap("invocations");
+  const pendingInvocations = yDoc.getMap("pendingInvocations");
+  const agentOutbox = yDoc.getMap("agentOutbox");
+  const agentLeases = yDoc.getMap("agentLeases");
+  const auditTrail = yDoc.getMap("auditTrail");
+  const xeroWorkItems = yDoc.getMap(XERO_WORK_ITEMS_MAP_NAME);
+  const xeroConnection = yDoc.getMap(XERO_CONNECTION_MAP_NAME);
+  yDoc.transact(() => {
+    runtime.forEach((_, key) => runtime.delete(key));
+    invocations.forEach((_, key) => invocations.delete(key));
+    pendingInvocations.forEach((_, key) => pendingInvocations.delete(key));
+    agentOutbox.forEach((_, key) => agentOutbox.delete(key));
+    agentLeases.forEach((_, key) => agentLeases.delete(key));
+    auditTrail.forEach((_, key) => auditTrail.delete(key));
+    xeroWorkItems.forEach((_, key) => xeroWorkItems.delete(key));
+    xeroConnection.forEach((_, key) => xeroConnection.delete(key));
+  });
+}
+
+// src/core/lib/flowCompiler/resolveRefs.ts
+function resolveRuntimeRefs(nb, getNodeOutput2, triggerContext) {
+  return resolveValue(nb, getNodeOutput2, triggerContext);
+}
+function resolveValue(value, getNodeOutput2, triggerContext) {
+  if (isRuntimeRef(value)) {
+    return resolveRef(value.$ref, getNodeOutput2, triggerContext);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, getNodeOutput2, triggerContext));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = resolveValue(val, getNodeOutput2, triggerContext);
+    }
+    return result;
+  }
+  return value;
+}
+function resolveRef(ref, getNodeOutput2, triggerContext) {
+  if (ref.startsWith("trigger.payload.")) {
+    if (!triggerContext) {
+      throw new Error(`Trigger ref "${ref}" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);
+    }
+    const fieldPath2 = ref.slice("trigger.payload.".length);
+    return getNestedValue3(triggerContext.payload, fieldPath2);
+  }
+  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
+    return triggerContext.refSnapshots[ref];
+  }
+  const outputIndex = ref.indexOf(".output.");
+  if (outputIndex === -1) {
+    throw new Error(`Invalid runtime reference "${ref}". Expected format: "nodeId.output.fieldPath" or "trigger.payload.fieldPath"`);
+  }
+  const nodeId = ref.slice(0, outputIndex);
+  const fieldPath = ref.slice(outputIndex + ".output.".length);
+  const output = getNodeOutput2(nodeId);
+  if (!output) {
+    return void 0;
+  }
+  return getNestedValue3(output, fieldPath);
+}
+function getNestedValue3(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+// src/core/lib/flowEngine/versionManifest.ts
+var VERSION_MANIFEST = {
+  "0.3": {
+    version: "0.3",
+    label: "Legacy",
+    ucanRequired: false,
+    delegationRootRequired: false,
+    whitelistOnlyAllowed: true,
+    unrestrictedAllowed: true,
+    executionPath: "legacy",
+    authorizationFn: "v1",
+    allowedAuthModes: ["anyone", "actors", "capability"],
+    ui: {
+      showDelegationPanel: false,
+      showWhitelistConfig: true,
+      showAnyoneConfig: true,
+      showMigrationBanner: true,
+      requirePinForExecution: false
+    },
+    description: "Legacy version. UCAN optional, whitelist-only authorization accepted."
+  },
+  "1.0.0": {
+    version: "1.0.0",
+    label: "UCAN Required",
+    /** TEMP Disablement - needs to be true TODO */
+    ucanRequired: false,
+    delegationRootRequired: true,
+    whitelistOnlyAllowed: false,
+    unrestrictedAllowed: false,
+    executionPath: "invocation",
+    authorizationFn: "v2",
+    allowedAuthModes: ["capability"],
+    ui: {
+      showDelegationPanel: true,
+      showWhitelistConfig: false,
+      showAnyoneConfig: false,
+      showMigrationBanner: false,
+      requirePinForExecution: true
+    },
+    description: "UCAN-enforced. Every block execution requires a valid delegation chain."
+  }
+};
+var LATEST_VERSION = "1.0.0";
+function getVersionPolicy(version) {
+  const policy = VERSION_MANIFEST[version];
+  if (!policy) {
+    return VERSION_MANIFEST[LATEST_VERSION];
+  }
+  return policy;
+}
+
+// src/core/lib/flowEngine/authorization.ts
+var isAuthorized = async (blockId, actorDid, ucanService, flowUri, schemaVersion) => {
+  const policy = schemaVersion ? getVersionPolicy(schemaVersion) : null;
+  if (policy && !policy.ucanRequired) {
+    return { authorized: true };
+  }
+  if (!ucanService) {
+    if (!policy) {
+      return { authorized: true };
     }
-  } catch {
+    return {
+      authorized: false,
+      reason: "UCAN service is not configured. This flow version requires UCAN authorization."
+    };
   }
-  return null;
-}
-function parseInputs(block) {
-  const raw = block?.props?.inputs;
-  if (!raw || typeof raw !== "string") return {};
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") return parsed;
-  } catch {
+  const capability = {
+    can: "flow/block/execute",
+    with: `${flowUri}:${blockId}`
+  };
+  const result = await ucanService.validateDelegationChain(actorDid, capability);
+  if (!result.valid) {
+    return {
+      authorized: false,
+      reason: result.error || "No valid capability chain found"
+    };
   }
-  return {};
-}
-function resolveAssignee(block) {
-  const raw = block?.props?.assignment;
-  if (!raw) return void 0;
-  try {
-    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
-    const did = parsed?.assignedActor?.did;
-    return typeof did === "string" && did.length > 0 ? did : void 0;
-  } catch {
-    return void 0;
+  const proofCids = result.proofChain?.map((d) => d.cid) || [];
+  return {
+    authorized: true,
+    capabilityId: proofCids[0],
+    proofCids
+  };
+};
+
+// src/core/lib/flowEngine/executor.ts
+var updateRuntimeAfterSuccess = (node, actorDid, runtime, actionResult, invocationCid, now) => {
+  const updates = {
+    submittedByDid: actionResult.submittedByDid || actorDid,
+    evaluationStatus: actionResult.evaluationStatus || "pending",
+    executionTimestamp: now ? now() : Date.now(),
+    lastInvocationCid: invocationCid
+  };
+  if (actionResult.claimId) {
+    updates.claimId = actionResult.claimId;
   }
-}
-function computeExpiry(block, emittedAt) {
-  const ttlAbsolute = block?.props?.ttlAbsoluteDueDate;
-  if (typeof ttlAbsolute === "string" && ttlAbsolute) {
-    return ttlAbsolute;
+  runtime.update(node.id, updates);
+};
+var executeNode = async ({ node, actorDid, actorType, entityRoomId, context, action, pin }) => {
+  const { runtime, ucanService, invocationStore, flowUri, flowId, schemaVersion, now } = context;
+  const auth = await isAuthorized(node.id, actorDid, ucanService, flowUri, schemaVersion);
+  if (!auth.authorized) {
+    return { success: false, stage: "authorization", error: auth.reason };
   }
-  const ttlFromEnablement = block?.props?.ttlFromEnablement;
-  if (typeof ttlFromEnablement === "string" && ttlFromEnablement) {
-    const ms = parseIsoDurationToMs(ttlFromEnablement);
-    if (ms != null) {
-      return new Date(new Date(emittedAt).getTime() + ms).toISOString();
+  if (node.linkedClaim && !node.linkedClaim.collectionId) {
+    return { success: false, stage: "claim", error: "Linked claim collection is required but missing." };
+  }
+  let invocationCid;
+  let invocationData;
+  if (ucanService && auth.proofCids && auth.proofCids.length > 0) {
+    const capability = {
+      can: "flow/block/execute",
+      with: `${flowUri}:${node.id}`
+    };
+    try {
+      const invocationResult = await ucanService.createAndValidateInvocation(
+        {
+          invokerDid: actorDid,
+          invokerType: actorType,
+          entityRoomId,
+          capability,
+          proofs: auth.proofCids,
+          pin
+        },
+        flowId,
+        node.id
+      );
+      if (!invocationResult.valid) {
+        return {
+          success: false,
+          stage: "authorization",
+          error: `Invocation validation failed: ${invocationResult.error}`
+        };
+      }
+      invocationCid = invocationResult.cid;
+      invocationData = invocationResult.invocation;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to create invocation";
+      return { success: false, stage: "authorization", error: message };
     }
   }
-  return new Date(new Date(emittedAt).getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString();
-}
-function parseIsoDurationToMs(duration) {
-  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(duration);
-  if (!match) return null;
-  const [, d, h, m, s] = match;
-  let ms = 0;
-  if (d) ms += parseInt(d, 10) * 24 * 60 * 60 * 1e3;
-  if (h) ms += parseInt(h, 10) * 60 * 60 * 1e3;
-  if (m) ms += parseInt(m, 10) * 60 * 1e3;
-  if (s) ms += parseInt(s, 10) * 1e3;
-  return ms;
-}
-function getActionForBlock(block) {
-  const actionType = block?.props?.actionType;
-  if (typeof actionType !== "string") return void 0;
-  return getAction(actionType);
-}
+  try {
+    const result = await action();
+    if (node.linkedClaim && !result.claimId) {
+      if (invocationStore && invocationCid && invocationData) {
+        const storedInvocation = {
+          cid: invocationCid,
+          invocation: invocationData,
+          invokerDid: actorDid,
+          capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+          executedAt: now ? now() : Date.now(),
+          flowId,
+          blockId: node.id,
+          result: "failure",
+          error: "Execution did not return a claimId for linked claim requirement.",
+          proofCids: auth.proofCids || []
+        };
+        invocationStore.add(storedInvocation);
+      }
+      return {
+        success: false,
+        stage: "claim",
+        error: "Execution did not return a claimId for linked claim requirement.",
+        invocationCid
+      };
+    }
+    if (invocationStore && invocationCid && invocationData) {
+      const storedInvocation = {
+        cid: invocationCid,
+        invocation: invocationData,
+        invokerDid: actorDid,
+        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+        executedAt: now ? now() : Date.now(),
+        flowId,
+        blockId: node.id,
+        result: "success",
+        proofCids: auth.proofCids || [],
+        claimId: result.claimId
+      };
+      invocationStore.add(storedInvocation);
+    }
+    updateRuntimeAfterSuccess(node, actorDid, runtime, result, invocationCid || auth.capabilityId, now);
+    return {
+      success: true,
+      stage: "complete",
+      result,
+      capabilityId: auth.capabilityId,
+      invocationCid
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Execution failed";
+    if (invocationStore && invocationCid && invocationData) {
+      const storedInvocation = {
+        cid: invocationCid,
+        invocation: invocationData,
+        invokerDid: actorDid,
+        capability: { can: "flow/block/execute", with: `${flowUri}:${node.id}` },
+        executedAt: now ? now() : Date.now(),
+        flowId,
+        blockId: node.id,
+        result: "failure",
+        error: message,
+        proofCids: auth.proofCids || []
+      };
+      invocationStore.add(storedInvocation);
+    }
+    return { success: false, stage: "action", error: message, invocationCid };
+  }
+};
 
 // src/core/lib/ucanDelegationStore.ts
 var ROOT_DELEGATION_KEY = "__root__";
@@ -10187,26 +10220,6 @@ var createMemoryInvocationStore = () => {
   };
 };
 
-// src/core/lib/flowEngine/emitEvents.ts
-function writeRunRecordAndReconcile(editor, blockId, output, events, actorDid, detailsPatch = {}) {
-  const yDoc = editor._yDoc;
-  if (!yDoc) return;
-  if (events.length === 0) return;
-  const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const details = {
-    runId,
-    output,
-    events,
-    startedAt: now,
-    completedAt: now,
-    actorDid,
-    ...detailsPatch
-  };
-  appendRunRecord(yDoc, blockId, details, actorDid);
-  reconcilePendingInvocations(editor);
-}
-
 // src/core/lib/flowEngine/actionExecutor.ts
 import * as Y3 from "yjs";
 
@@ -13225,6 +13238,8 @@ var FlowAgentService = class {
 };
 
 export {
+  STEP_COMPLETED_EVENT_NAME,
+  STEP_COMPLETED_EVENT,
   resolveActionType,
   registerAction,
   getAction,
@@ -13292,15 +13307,7 @@ export {
   formatCoin2 as formatCoin,
   formatCoinAmount,
   createUcanService,
-  buildAuthzFromProps,
-  buildFlowNodeFromBlock,
-  createRuntimeStateManager,
-  clearRuntimeForTemplateClone,
   isRuntimeRef,
-  resolveRuntimeRefs,
-  LATEST_VERSION,
-  isAuthorized,
-  executeNode,
   RUN_RECORD_AUDIT_TYPE,
   computePendingInvocationId,
   snapshotInputRefs,
@@ -13315,6 +13322,15 @@ export {
   replayFailedListenerRun,
   reconcilePendingInvocations,
   getActionForBlock,
+  writeRunRecordAndReconcile,
+  buildAuthzFromProps,
+  buildFlowNodeFromBlock,
+  createRuntimeStateManager,
+  clearRuntimeForTemplateClone,
+  resolveRuntimeRefs,
+  LATEST_VERSION,
+  isAuthorized,
+  executeNode,
   reconcileActionReadBack,
   buildActionRunInputs,
   executeActionBlock,
@@ -13322,7 +13338,6 @@ export {
   createMemoryUcanDelegationStore,
   createInvocationStore,
   createMemoryInvocationStore,
-  writeRunRecordAndReconcile,
   compileBlockProps,
   COMPILED_BLOCK_TYPE,
   toEvaluatorOperator,
@@ -13374,4 +13389,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-YWZJYSOP.js.map
+//# sourceMappingURL=chunk-KNMPGX5G.js.map