@ixo/editor 5.20.2 → 5.25.0

package/dist/{chunk-HETRTQWL.mjs → chunk-UMS6GCME.mjs}

@@ -1255,6 +1255,505 @@ registerAction({
   }
 });
 
+// src/core/lib/xeroWorkItems.ts
+function getXeroWorkItemsMap(editor) {
+  return editor?._yXeroWorkItems || null;
+}
+function readMapItems(map) {
+  if (!map) return [];
+  const items = [];
+  map.forEach((value) => {
+    if (value && typeof value === "object" && "id" in value) {
+      items.push({ ...value });
+    }
+  });
+  return items;
+}
+function mergeItem(existing, next) {
+  if (existing.status === "completed") {
+    return existing;
+  }
+  return {
+    ...existing,
+    ...next,
+    id: existing.id,
+    attempts: existing.attempts ?? [],
+    originalPayload: existing.originalPayload,
+    submittedPayload: existing.submittedPayload,
+    result: existing.result,
+    completedAt: existing.completedAt,
+    completedByDid: existing.completedByDid
+  };
+}
+function buildXeroInvoiceWorkKey(params) {
+  return ["xero", "invoice.create", params.flowId, params.evaluationBlockId, params.claimId, params.invoiceBlockId].join(":");
+}
+function buildXeroPaymentWorkKey(params) {
+  return ["xero", "payment.create", params.flowId, params.evaluationBlockId, params.claimId, params.paymentBlockId, params.invoiceWorkItemId].join(":");
+}
+function findXeroWorkItemsForEditor(editor, filter) {
+  return readMapItems(getXeroWorkItemsMap(editor)).filter((item) => {
+    if (filter.kind && item.kind !== filter.kind) return false;
+    if (filter.assignedBlockId && item.assignedBlockId !== filter.assignedBlockId) return false;
+    if (filter.statuses && !filter.statuses.includes(item.status)) return false;
+    return true;
+  });
+}
+function upsertXeroWorkItemForEditor(editor, next) {
+  const map = getXeroWorkItemsMap(editor);
+  if (!map) {
+    return next;
+  }
+  let existing;
+  map.forEach((item) => {
+    if (item?.idempotencyKey === next.idempotencyKey) existing = item;
+  });
+  const stored = existing ? mergeItem(existing, next) : next;
+  map.set(stored.id, stored);
+  return stored;
+}
+function updateXeroWorkReviewPayloadForEditor(editor, itemId, reviewPayload) {
+  const map = getXeroWorkItemsMap(editor);
+  if (!map) return null;
+  const item = map.get(itemId);
+  if (!item) return null;
+  const updatedItem = { ...item, reviewPayload };
+  map.set(itemId, updatedItem);
+  return updatedItem;
+}
+function markXeroWorkFailedForEditor(editor, itemId, params) {
+  const map = getXeroWorkItemsMap(editor);
+  if (!map) return null;
+  const item = map.get(itemId);
+  if (!item) return null;
+  const at = params.at ?? Date.now();
+  const updatedItem = {
+    ...item,
+    status: "failed",
+    reviewPayload: params.payload,
+    error: { message: params.error, at },
+    attempts: [...item.attempts ?? [], { at, byDid: params.byDid, payload: params.payload, error: params.error }]
+  };
+  map.set(itemId, updatedItem);
+  return updatedItem;
+}
+function markXeroWorkCompletedForEditor(editor, itemId, params) {
+  const map = getXeroWorkItemsMap(editor);
+  if (!map) return null;
+  const item = map.get(itemId);
+  if (!item) return null;
+  const at = params.at ?? Date.now();
+  const updatedItem = {
+    ...item,
+    status: "completed",
+    reviewPayload: params.payload,
+    submittedPayload: params.payload,
+    result: params.result,
+    error: void 0,
+    completedAt: at,
+    completedByDid: params.byDid,
+    attempts: [...item.attempts ?? [], { at, byDid: params.byDid, payload: params.payload, result: params.result }]
+  };
+  map.set(itemId, updatedItem);
+  return updatedItem;
+}
+
+// src/core/lib/actionRegistry/actions/xero/invoiceCreate.types.ts
+var LINE_ITEM_FIELD_KEYS = ["Description", "Quantity", "UnitAmount", "AccountCode", "TaxType", "ItemCode", "DiscountRate"];
+function emptyLineItemCells() {
+  return {
+    Description: "",
+    Quantity: "1",
+    UnitAmount: "",
+    AccountCode: "",
+    TaxType: "",
+    ItemCode: "",
+    DiscountRate: ""
+  };
+}
+function emptyLineItems() {
+  return { mode: "manual", rows: [emptyLineItemCells()] };
+}
+function coerceCells(raw) {
+  const base = emptyLineItemCells();
+  if (!raw || typeof raw !== "object") return base;
+  for (const key of LINE_ITEM_FIELD_KEYS) {
+    const v = raw[key];
+    if (typeof v === "string") base[key] = v;
+    else if (typeof v === "number") base[key] = String(v);
+    else if (typeof v === "boolean") base[key] = v ? "true" : "false";
+  }
+  return base;
+}
+function normaliseLineItems(raw) {
+  if (raw && typeof raw === "object") {
+    const candidate = raw;
+    if (candidate.mode === "iterative") {
+      return {
+        mode: "iterative",
+        source: typeof candidate.source === "string" ? candidate.source : "",
+        map: coerceCells(candidate.map)
+      };
+    }
+    if (candidate.mode === "manual") {
+      const rows = Array.isArray(candidate.rows) ? candidate.rows.map(coerceCells) : [];
+      return { mode: "manual", rows: rows.length > 0 ? rows : [emptyLineItemCells()] };
+    }
+  }
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (!trimmed) return emptyLineItems();
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        return { mode: "manual", rows: parsed.map(coerceCells) };
+      }
+    } catch {
+    }
+  }
+  return emptyLineItems();
+}
+function parseXeroInvoiceCreateInputs(raw) {
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw || "{}") : raw || {};
+    const conn = parsed.connection;
+    const connection = conn && typeof conn === "object" && typeof conn.connectedAccountId === "string" && typeof conn.entityDid === "string" ? { connectedAccountId: conn.connectedAccountId, entityDid: conn.entityDid } : null;
+    return {
+      connection,
+      tenant_id: typeof parsed.tenant_id === "string" ? parsed.tenant_id : "",
+      Type: typeof parsed.Type === "string" && parsed.Type ? parsed.Type : "ACCREC",
+      Status: typeof parsed.Status === "string" ? parsed.Status : "DRAFT",
+      Date: typeof parsed.Date === "string" ? parsed.Date : "",
+      DueDate: typeof parsed.DueDate === "string" ? parsed.DueDate : "",
+      ContactID: typeof parsed.ContactID === "string" ? parsed.ContactID : "",
+      ContactName: typeof parsed.ContactName === "string" ? parsed.ContactName : "",
+      Reference: typeof parsed.Reference === "string" ? parsed.Reference : "",
+      InvoiceNumber: typeof parsed.InvoiceNumber === "string" ? parsed.InvoiceNumber : "",
+      CurrencyCode: typeof parsed.CurrencyCode === "string" ? parsed.CurrencyCode : "",
+      LineItems: normaliseLineItems(parsed.LineItems)
+    };
+  } catch {
+    return {
+      connection: null,
+      tenant_id: "",
+      Type: "ACCREC",
+      Status: "DRAFT",
+      Date: "",
+      DueDate: "",
+      ContactID: "",
+      ContactName: "",
+      Reference: "",
+      InvoiceNumber: "",
+      CurrencyCode: "",
+      LineItems: emptyLineItems()
+    };
+  }
+}
+function serializeXeroInvoiceCreateInputs(inputs) {
+  return JSON.stringify(inputs);
+}
+var NUMERIC_LINE_ITEM_FIELDS = ["Quantity", "UnitAmount", "DiscountRate"];
+function finaliseLineItem(cells) {
+  const out = {};
+  for (const key of LINE_ITEM_FIELD_KEYS) {
+    const raw = (cells[key] ?? "").trim();
+    if (!raw) continue;
+    if (NUMERIC_LINE_ITEM_FIELDS.includes(key)) {
+      const n = Number(raw);
+      if (!Number.isFinite(n)) {
+        throw new Error(`Line item field ${key} must be a number; got "${raw}"`);
+      }
+      out[key] = n;
+    } else {
+      out[key] = raw;
+    }
+  }
+  if (!out.Description) {
+    out.Description = "payment";
+  }
+  return out;
+}
+
+// src/core/lib/actionRegistry/actions/xero/paymentCreate.types.ts
+function parseXeroPaymentCreateInputs(raw) {
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw || "{}") : raw || {};
+    const conn = parsed.connection;
+    const connection = conn && typeof conn === "object" && typeof conn.connectedAccountId === "string" && typeof conn.entityDid === "string" ? { connectedAccountId: conn.connectedAccountId, entityDid: conn.entityDid } : null;
+    return {
+      connection,
+      tenant_id: typeof parsed.tenant_id === "string" ? parsed.tenant_id : "",
+      InvoiceID: typeof parsed.InvoiceID === "string" ? parsed.InvoiceID : "",
+      AccountID: typeof parsed.AccountID === "string" ? parsed.AccountID : "",
+      Date: typeof parsed.Date === "string" ? parsed.Date : "",
+      Amount: typeof parsed.Amount === "string" ? parsed.Amount : typeof parsed.Amount === "number" ? String(parsed.Amount) : "",
+      Reference: typeof parsed.Reference === "string" ? parsed.Reference : "",
+      CurrencyRate: typeof parsed.CurrencyRate === "string" ? parsed.CurrencyRate : ""
+    };
+  } catch {
+    return {
+      connection: null,
+      tenant_id: "",
+      InvoiceID: "",
+      AccountID: "",
+      Date: "",
+      Amount: "",
+      Reference: "",
+      CurrencyRate: ""
+    };
+  }
+}
+function serializeXeroPaymentCreateInputs(inputs) {
+  return JSON.stringify(inputs);
+}
+
+// src/mantine/utils/referenceResolver.ts
+var REFERENCE_REGEX = /\{\{([a-zA-Z0-9_-]+)\.([a-zA-Z0-9_.:]+)\}\}/g;
+function parseReferences(input) {
+  const references = [];
+  const regex = new RegExp(REFERENCE_REGEX);
+  let match;
+  while ((match = regex.exec(input)) !== null) {
+    references.push({
+      fullMatch: match[0],
+      blockId: match[1],
+      propPath: match[2],
+      startIndex: match.index,
+      endIndex: match.index + match[0].length
+    });
+  }
+  return references;
+}
+function getNestedValue(obj, path) {
+  return path.split(".").reduce((current, key) => {
+    return current?.[key];
+  }, obj);
+}
+function resolveSingleReference(blockId, propPath, editorDocument, yRuntime, scope) {
+  if (scope && Object.prototype.hasOwnProperty.call(scope, blockId)) {
+    const root = scope[blockId];
+    if (root == null) return void 0;
+    return getNestedValue(root, propPath);
+  }
+  if (!editorDocument || !Array.isArray(editorDocument)) {
+    return void 0;
+  }
+  const block = editorDocument.find((b) => b.id === blockId);
+  if (!block) {
+    return void 0;
+  }
+  if (propPath.startsWith("output.")) {
+    if (!yRuntime) return void 0;
+    const runtimeState = yRuntime.get(blockId);
+    if (!runtimeState?.output) return void 0;
+    const innerPath = propPath.substring("output.".length);
+    const direct = getNestedValue(runtimeState.output, innerPath);
+    if (direct !== void 0) return direct;
+    if (runtimeState.output.data !== void 0) {
+      return getNestedValue(runtimeState.output.data, innerPath);
+    }
+    if (runtimeState.output.http?.data !== void 0) {
+      return getNestedValue(runtimeState.output.http.data, innerPath);
+    }
+    return void 0;
+  }
+  if (propPath.startsWith("response.")) {
+    const responseData = block.props.response;
+    if (!responseData) {
+      return void 0;
+    }
+    try {
+      const parsedResponse = typeof responseData === "string" ? JSON.parse(responseData) : responseData;
+      const innerPath = propPath.substring("response.".length);
+      const value2 = getNestedValue(parsedResponse, innerPath);
+      return value2;
+    } catch (error) {
+      return void 0;
+    }
+  }
+  const value = getNestedValue(block.props, propPath);
+  return value;
+}
+function resolveReferences(input, editorDocument, options = {}) {
+  const { fallback = "", stringifyObjects = true, yRuntime, scope } = options;
+  if (input == null) {
+    return "";
+  }
+  const inputStr = String(input);
+  const references = parseReferences(inputStr);
+  if (references.length === 0) {
+    return inputStr;
+  }
+  let result = inputStr;
+  for (let i = references.length - 1; i >= 0; i--) {
+    const ref = references[i];
+    const resolvedValue = resolveSingleReference(ref.blockId, ref.propPath, editorDocument, yRuntime, scope);
+    let replacementStr;
+    if (resolvedValue === void 0 || resolvedValue === null) {
+      replacementStr = fallback;
+    } else if (typeof resolvedValue === "object") {
+      replacementStr = stringifyObjects ? JSON.stringify(resolvedValue) : fallback;
+    } else {
+      replacementStr = String(resolvedValue);
+    }
+    result = result.substring(0, ref.startIndex) + replacementStr + result.substring(ref.endIndex);
+  }
+  return result;
+}
+function hasReferences(input) {
+  if (input == null) return false;
+  return parseReferences(String(input)).length > 0;
+}
+function createReference(blockId, propPath) {
+  return `{{${blockId}.${propPath}}}`;
+}
+
+// src/core/lib/xeroWorkItemPayloads.ts
+function resolveXeroBindings(editorDocument, invoiceBlockId, paymentBlockId) {
+  if (!Array.isArray(editorDocument)) return { invoiceCreateBlock: null, paymentCreateBlock: null, evaluateBlockId: null };
+  const findById = (id, expectedActionType) => {
+    const trimmed = String(id || "").trim();
+    if (!trimmed) return null;
+    const block = editorDocument.find((b) => b?.id === trimmed);
+    if (!block || block.type !== "action" || block.props?.actionType !== expectedActionType) return null;
+    return block;
+  };
+  return {
+    invoiceCreateBlock: findById(invoiceBlockId, "qi/xero.invoice.create"),
+    paymentCreateBlock: findById(paymentBlockId, "qi/xero.payment.create"),
+    evaluateBlockId: null
+  };
+}
+function buildClaimScope(claim, claimData, evaluateBlockId, evaluateContext) {
+  const surveyAnswers = claimData && typeof claimData === "object" ? claimData.credentialSubject ?? claimData.surveyAnswers ?? claimData : {};
+  const evaluationOutput = evaluateContext?.evaluationOutput ?? {};
+  const scope = {
+    claim: {
+      claimId: claim?.claimId || evaluationOutput.claimId || "",
+      agentDid: claim?.agentDid || "",
+      agentAddress: claim?.agentAddress || "",
+      submissionDate: claim?.submissionDate || "",
+      surveyAnswers,
+      ...surveyAnswers
+    },
+    evaluation: {
+      transactionHash: evaluationOutput.transactionHash || "",
+      amount: evaluationOutput.amount || "",
+      date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+    }
+  };
+  const trimmedId = String(evaluateBlockId || "").trim();
+  if (trimmedId) {
+    scope[trimmedId] = {
+      output: {
+        claimId: claim?.claimId || evaluationOutput.claimId || "",
+        collectionId: evaluateContext?.collectionId || "",
+        deedDid: evaluateContext?.deedDid || "",
+        surveyAnswers,
+        ...evaluationOutput
+      }
+    };
+  }
+  return scope;
+}
+function resolveIterativeSource(source, editorDocument, opts) {
+  const refs = parseReferences(source || "");
+  if (refs.length === 0) return [];
+  const ref = refs[0];
+  const value = resolveSingleReference(ref.blockId, ref.propPath, editorDocument, opts.yRuntime, opts.scope);
+  return Array.isArray(value) ? value : [];
+}
+function resolveCells(cells, editorDocument, opts) {
+  const out = {};
+  for (const key of LINE_ITEM_FIELD_KEYS) {
+    out[key] = resolveReferences(cells[key] || "", editorDocument, opts);
+  }
+  return out;
+}
+function buildLineItemsArray(config, editorDocument, opts) {
+  if (config.mode === "manual") {
+    if (config.rows.length === 0) throw new Error("At least one line item is required.");
+    return config.rows.map((row) => finaliseLineItem(resolveCells(row, editorDocument, opts)));
+  }
+  const elements = resolveIterativeSource(config.source, editorDocument, opts);
+  if (elements.length === 0) throw new Error("The bound source list is empty or could not be resolved.");
+  return elements.map((element) => {
+    const perItemOpts = { ...opts, scope: { ...opts.scope || {}, item: element } };
+    return finaliseLineItem(resolveCells(config.map, editorDocument, perItemOpts));
+  });
+}
+async function resolveInvoiceWorkPayload(block, editorDocument, scope) {
+  const parsed = parseXeroInvoiceCreateInputs(block?.props?.inputs);
+  const opts = { scope };
+  const resolveStr = (v) => resolveReferences(v || "", editorDocument, opts);
+  const payload = {
+    connection: parsed.connection,
+    tenant_id: resolveStr(parsed.tenant_id),
+    Type: resolveStr(parsed.Type) || "ACCREC",
+    Status: resolveStr(parsed.Status) || "DRAFT",
+    Date: resolveStr(parsed.Date),
+    DueDate: resolveStr(parsed.DueDate),
+    ContactID: resolveStr(parsed.ContactID),
+    ContactName: resolveStr(parsed.ContactName),
+    Reference: resolveStr(parsed.Reference),
+    InvoiceNumber: resolveStr(parsed.InvoiceNumber),
+    CurrencyCode: resolveStr(parsed.CurrencyCode),
+    LineItems: buildLineItemsArray(parsed.LineItems, editorDocument, opts)
+  };
+  let preview = [];
+  const resolver = getDiffResolver("qi/xero.invoice.create");
+  if (resolver) {
+    try {
+      preview = await resolver.resolver({ ...payload, LineItems: parsed.LineItems }, {});
+    } catch {
+      preview = [];
+    }
+  }
+  return { payload, preview };
+}
+async function resolvePaymentWorkPayload(block, editorDocument, baseScope, settlement) {
+  const parsed = parseXeroPaymentCreateInputs(block?.props?.inputs);
+  const scope = {
+    ...baseScope,
+    invoice: { invoiceId: settlement.invoiceId, InvoiceID: settlement.invoiceId },
+    evaluation: {
+      transactionHash: settlement.transactionHash,
+      amount: settlement.amount,
+      date: settlement.date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+    }
+  };
+  const opts = { scope };
+  const resolveStr = (v) => resolveReferences(v || "", editorDocument, opts);
+  const currencyRateRaw = resolveStr(parsed.CurrencyRate);
+  const currencyRate = currencyRateRaw ? Number(currencyRateRaw) : void 0;
+  const amountRaw = resolveStr(parsed.Amount);
+  const amount = Number.isFinite(Number(amountRaw)) && Number(amountRaw) > 0 ? Number(amountRaw) : settlement.amount;
+  const payload = {
+    connection: parsed.connection,
+    tenant_id: resolveStr(parsed.tenant_id),
+    InvoiceID: resolveStr(parsed.InvoiceID) || settlement.invoiceId,
+    AccountID: resolveStr(parsed.AccountID),
+    Date: resolveStr(parsed.Date) || settlement.date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    Amount: amount,
+    Reference: resolveStr(parsed.Reference) || settlement.transactionHash,
+    CurrencyRate: typeof currencyRate === "number" && Number.isFinite(currencyRate) ? currencyRate : void 0
+  };
+  let preview = [];
+  const resolver = getDiffResolver("qi/xero.payment.create");
+  if (resolver) {
+    try {
+      preview = await resolver.resolver({ ...payload, Amount: String(payload.Amount) }, {});
+    } catch {
+      preview = [];
+    }
+  }
+  return { payload, preview };
+}
+function getInvoiceTotal(output) {
+  const total = typeof output.total === "number" ? output.total : Number(output.total);
+  return Number.isFinite(total) && total > 0 ? total : 0;
+}
+
 // src/core/lib/actionRegistry/actions/evaluateClaim/evaluateClaim.ts
 var BASELINE_OUTPUT2 = [
   { path: "claimId", displayName: "Claim ID", type: "string", description: "Evaluated claim identifier" },
@@ -1463,11 +1962,12 @@ registerAction({
       amount: normalizedCoin
     });
     const transactionHash = String(broadcastResult?.transactionHash || "");
+    let claimData = null;
     let surveyAnswers = {};
     try {
       const getClaimData = handlers?.getClaimData;
       if (typeof getClaimData === "function") {
-        const claimData = await getClaimData(collectionId, claimId, { entityDid: deedDid });
+        claimData = await getClaimData(collectionId, claimId, { entityDid: deedDid });
         const candidate = claimData?.credentialSubject ?? claimData?.surveyAnswers ?? claimData;
         if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
           surveyAnswers = candidate;
@@ -1489,6 +1989,56 @@ registerAction({
       evaluatedAt,
       surveyAnswers
     };
+    const xeroInvoiceBlockId = String(inputs.xeroInvoiceBlockId || "").trim();
+    if (decision === "approve" && xeroInvoiceBlockId) {
+      const editorDoc = ctx.editor?.document || [];
+      const runtime = ctx.runtime;
+      if (!runtime) {
+        throw new Error("Cannot queue Xero invoice work: runtime state manager is unavailable");
+      }
+      const bindings = resolveXeroBindings(editorDoc, xeroInvoiceBlockId, String(inputs.xeroPaymentBlockId || ""));
+      const invoiceBlock = bindings.invoiceCreateBlock;
+      if (!invoiceBlock) {
+        throw new Error("Cannot queue Xero invoice work: bound invoice block was not found");
+      }
+      const flowId = String(ctx.flowId || ctx.flowUri || "flow");
+      const scope = buildClaimScope(inputs.claimSnapshot || { claimId }, claimData || surveyAnswers, ctx.nodeId, {
+        deedDid,
+        collectionId,
+        evaluationOutput: output
+      });
+      const { payload } = await resolveInvoiceWorkPayload(invoiceBlock, editorDoc, scope);
+      const idempotencyKey = buildXeroInvoiceWorkKey({
+        flowId,
+        evaluationBlockId: ctx.nodeId,
+        claimId,
+        invoiceBlockId: invoiceBlock.id
+      });
+      upsertXeroWorkItemForEditor(ctx.editor, {
+        id: idempotencyKey,
+        kind: "invoice.create",
+        status: "pending",
+        assignedBlockId: invoiceBlock.id,
+        idempotencyKey,
+        source: {
+          claimId,
+          evaluationBlockId: ctx.nodeId,
+          deedDid,
+          collectionId
+        },
+        originalPayload: payload,
+        reviewPayload: payload,
+        provenance: {
+          createdAt: Date.now(),
+          createdByDid: ctx.actorDid,
+          templateBlockId: invoiceBlock.id,
+          templateInputsSnapshot: invoiceBlock.props?.inputs,
+          evaluationOutput: output,
+          claimSnapshot: inputs.claimSnapshot
+        },
+        attempts: []
+      });
+    }
     const eventName = decision === "approve" ? "approved" : "rejected";
     const eventPayload = decision === "approve" ? {
       claimId,
@@ -4889,7 +5439,7 @@ registerAction({
     }
     const invoiceId = String(inputs.InvoiceID || "").trim();
     if (!invoiceId) {
-      throw new Error("InvoiceID is required \u2014 usually wired from the upstream Capture Bill step.");
+      throw new Error("InvoiceID is required; work items usually supply it from invoice.create completion.");
     }
     const accountId = String(inputs.AccountID || "").trim();
     if (!accountId) {
@@ -6422,6 +6972,8 @@ var buildFlowNodeFromBlock = (block) => {
 };
 
 // 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 {};
@@ -6466,6 +7018,8 @@ function clearRuntimeForTemplateClone(yDoc) {
   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));
@@ -6473,6 +7027,8 @@ function clearRuntimeForTemplateClone(yDoc) {
     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));
   });
 }
 
@@ -6507,7 +7063,7 @@ function resolveRef(ref, getNodeOutput2, 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 getNestedValue(triggerContext.payload, fieldPath2);
+    return getNestedValue2(triggerContext.payload, fieldPath2);
   }
   if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
     return triggerContext.refSnapshots[ref];
@@ -6522,9 +7078,9 @@ function resolveRef(ref, getNodeOutput2, triggerContext) {
   if (!output) {
     return void 0;
   }
-  return getNestedValue(output, fieldPath);
+  return getNestedValue2(output, fieldPath);
 }
-function getNestedValue(obj, path) {
+function getNestedValue2(obj, path) {
   const parts = path.split(".");
   let current = obj;
   for (const part of parts) {
@@ -6762,7 +7318,7 @@ function snapshotInputRefs(inputs, getNodeOutput2) {
     if (!parsed) return;
     const output = getNodeOutput2(parsed.nodeId);
     if (!output) return;
-    snapshots[ref.$ref] = getNestedValue2(output, parsed.fieldPath);
+    snapshots[ref.$ref] = getNestedValue3(output, parsed.fieldPath);
   });
   return snapshots;
 }
@@ -6787,7 +7343,7 @@ function parseOutputRef(ref) {
     fieldPath: ref.slice(outputIndex + ".output.".length)
   };
 }
-function getNestedValue2(obj, path) {
+function getNestedValue3(obj, path) {
   const parts = path.split(".");
   let current = obj;
   for (const part of parts) {
@@ -7119,7 +7675,9 @@ function processBarrierRunRecord(yDoc, sourceBlockId, record, barrierListenersBy
       }
       const allSources = trigger.sources || [];
       const currentState = readBarrierState(yDoc, listenerBlockId);
-      const allFired = allSources.length > 0 && allSources.every((s) => currentState.some((e) => e.sourceBlockId === s.sourceBlockId && e.eventName === s.eventName));
+      const requiredSources = allSources.filter((s) => s.optional !== true);
+      const gatingSources = requiredSources.length > 0 ? requiredSources : allSources;
+      const allFired = gatingSources.length > 0 && gatingSources.every((s) => currentState.some((e) => e.sourceBlockId === s.sourceBlockId && e.eventName === s.eventName));
       if (!allFired) continue;
       const assigneeDid = resolveAssignee(listenerBlock) || "unassigned";
       const id = computeBarrierInvocationId(currentState, listenerBlockId);
@@ -10127,6 +10685,28 @@ export {
   hasDiffResolver,
   extractDid,
   extractSurveyAnswerSchema,
+  buildXeroPaymentWorkKey,
+  findXeroWorkItemsForEditor,
+  upsertXeroWorkItemForEditor,
+  updateXeroWorkReviewPayloadForEditor,
+  markXeroWorkFailedForEditor,
+  markXeroWorkCompletedForEditor,
+  LINE_ITEM_FIELD_KEYS,
+  emptyLineItemCells,
+  parseXeroInvoiceCreateInputs,
+  serializeXeroInvoiceCreateInputs,
+  finaliseLineItem,
+  parseXeroPaymentCreateInputs,
+  serializeXeroPaymentCreateInputs,
+  parseReferences,
+  resolveSingleReference,
+  resolveReferences,
+  hasReferences,
+  createReference,
+  resolveXeroBindings,
+  buildClaimScope,
+  resolvePaymentWorkPayload,
+  getInvoiceTotal,
   transformSurveyToCredentialSubject,
   buildVerifiableCredential,
   buildDomainCardLinkedResource,
@@ -10219,4 +10799,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-HETRTQWL.mjs.map
+//# sourceMappingURL=chunk-UMS6GCME.mjs.map