@ixo/editor 5.3.1 → 5.5.0

package/dist/{chunk-GSW6ADEY.mjs → chunk-OO42QPEG.mjs}

@@ -49,6 +49,43 @@ function getActionByCan(can) {
   }
   return void 0;
 }
+function getEventsForBlock(action, inputs) {
+  if (!action) return [];
+  if (action.getDynamicEvents) {
+    const parsed = normalizeInputs(inputs);
+    try {
+      return action.getDynamicEvents(parsed) || [];
+    } catch {
+      return [];
+    }
+  }
+  return action.events || [];
+}
+function getOutputSchemaForBlock(action, inputs) {
+  if (!action) return [];
+  if (action.getDynamicOutputSchema) {
+    const parsed = normalizeInputs(inputs);
+    try {
+      return action.getDynamicOutputSchema(parsed) || [];
+    } catch {
+      return action.outputSchema || [];
+    }
+  }
+  return action.outputSchema || [];
+}
+function normalizeInputs(inputs) {
+  if (!inputs) return {};
+  if (typeof inputs === "object") return inputs;
+  if (typeof inputs === "string") {
+    try {
+      const parsed = JSON.parse(inputs || "{}");
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
 
 // src/core/lib/actionRegistry/canMapping.ts
 var CAN_TO_TYPE = {
@@ -76,6 +113,16 @@ var CAN_TO_TYPE = {
   "pod/governance-config": "qi/pod.governance-config",
   "pod/member-multi-select": "qi/pod.member-multi-select",
   "pod/list-domain-flows": "qi/pod.list-domain-flows",
+  // Calendar integration
+  "calendar.event/create": "qi/calendar.event.create",
+  "calendar.event/update": "qi/calendar.event.update",
+  "calendar.event/list": "qi/calendar.event.list",
+  // Xero integration
+  "xero.contact/create": "qi/xero.contact.create",
+  "xero.invoice/create": "qi/xero.invoice.create",
+  "xero.invoice/list": "qi/xero.invoice.list",
+  "xero.payment/create": "qi/xero.payment.create",
+  // Oracle / wallet / matrix lifecycle
   "wallet/generate": "qi/wallet.generate",
   "wallet/fund": "qi/wallet.fund",
   "iid/create": "qi/iid.create",
@@ -159,6 +206,11 @@ function buildServicesFromHandlers(handlers) {
     matrix: handlers?.storeMatrixCredential ? {
       storeCredential: async (params) => handlers.storeMatrixCredential(params)
     } : void 0,
+    integrations: handlers?.integrations?.executeTool ? {
+      executeTool: async (args) => handlers.integrations.executeTool(args),
+      fetchCurrentState: handlers.integrations.fetchCurrentState ? async (args) => handlers.integrations.fetchCurrentState(args) : void 0,
+      getEntityDid: handlers?.getEntityDid ? () => handlers.getEntityDid() : void 0
+    } : void 0,
     oracle: handlers?.generateWallet ? {
       generateWallet: async () => handlers.generateWallet(),
       fundWallet: async (params) => handlers.fundWallet(params),
@@ -853,21 +905,153 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/claim/surveySchema.ts
+var TYPE_MAP = {
+  text: "string",
+  comment: "string",
+  html: "string",
+  expression: "string",
+  dropdown: "string",
+  radiogroup: "string",
+  rating: "number",
+  number: "number",
+  boolean: "boolean",
+  checkbox: "array",
+  tagbox: "array",
+  ranking: "array",
+  imagepicker: "array",
+  file: "array",
+  paneldynamic: "array",
+  matrix: "object",
+  matrixdropdown: "object",
+  matrixdynamic: "object",
+  multipletext: "object",
+  panel: "object"
+};
+function extractSurveyAnswerSchema(survey) {
+  if (!survey || typeof survey !== "object") return [];
+  const json = survey;
+  const collected = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (elements) => {
+    if (!Array.isArray(elements)) return;
+    for (const el of elements) {
+      if (!el || typeof el !== "object") continue;
+      if (el.type === "panel" && Array.isArray(el.elements)) {
+        walk(el.elements);
+        continue;
+      }
+      const name = typeof el.name === "string" ? el.name.trim() : "";
+      if (!name) continue;
+      if (seen.has(name)) continue;
+      seen.add(name);
+      const rawType = typeof el.type === "string" ? el.type : "";
+      const mapped = TYPE_MAP[rawType] ?? "string";
+      let itemSchema;
+      if (rawType === "paneldynamic" && Array.isArray(el.templateElements) && el.templateElements.length > 0) {
+        const nested = [];
+        const nestedSeen = /* @__PURE__ */ new Set();
+        const walkNested = (inner) => {
+          for (const child of inner) {
+            if (!child || typeof child !== "object") continue;
+            if (child.type === "panel" && Array.isArray(child.elements)) {
+              walkNested(child.elements);
+              continue;
+            }
+            const childName = typeof child.name === "string" ? child.name.trim() : "";
+            if (!childName || nestedSeen.has(childName)) continue;
+            nestedSeen.add(childName);
+            const childType = typeof child.type === "string" ? child.type : "";
+            nested.push({
+              path: childName,
+              displayName: stripHtml(String(child.title || "").trim() || humanize(childName)),
+              type: TYPE_MAP[childType] ?? "string",
+              description: typeof child.description === "string" && child.description.trim() ? stripHtml(child.description.trim()) : void 0
+            });
+          }
+        };
+        walkNested(el.templateElements);
+        if (nested.length > 0) itemSchema = nested;
+      }
+      collected.push({
+        path: name,
+        displayName: stripHtml(String(el.title || "").trim() || humanize(name)),
+        type: mapped,
+        description: typeof el.description === "string" && el.description.trim() ? stripHtml(el.description.trim()) : void 0,
+        ...itemSchema ? { itemSchema } : {}
+      });
+    }
+  };
+  if (Array.isArray(json.pages) && json.pages.length > 0) {
+    for (const page of json.pages) walk(page.elements);
+  }
+  walk(json.elements);
+  return collected;
+}
+function prefixSurveyAnswerSchema(fields, namespace = "surveyAnswers") {
+  return fields.map((f) => ({
+    ...f,
+    path: `${namespace}.${f.path}`
+  }));
+}
+function humanize(name) {
+  return name.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function stripHtml(s) {
+  return s.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+}
+
 // src/core/lib/actionRegistry/actions/claim/claim.ts
+var BASELINE_OUTPUT = [
+  { path: "claimId", displayName: "Claim ID", type: "string", description: "The submitted claim identifier" },
+  { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "Submission transaction hash" },
+  { path: "collectionId", displayName: "Collection ID", type: "string", description: "Claim collection identifier" },
+  { path: "deedDid", displayName: "Deed DID", type: "string", description: "Deed identifier" },
+  { path: "submittedByDid", displayName: "Submitted By DID", type: "string", description: "Actor DID that submitted the claim" },
+  { path: "submittedAt", displayName: "Submitted At", type: "string", description: "ISO timestamp of submission" }
+];
 registerAction({
   type: "qi/claim.submit",
   can: "claim/submit",
   sideEffect: true,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
-  outputSchema: [
-    { path: "claimId", displayName: "Claim ID", type: "string", description: "The submitted claim identifier" },
-    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "Submission transaction hash" },
-    { path: "collectionId", displayName: "Collection ID", type: "string", description: "Claim collection identifier" },
-    { path: "deedDid", displayName: "Deed DID", type: "string", description: "Deed identifier" },
-    { path: "submittedByDid", displayName: "Submitted By DID", type: "string", description: "Actor DID that submitted the claim" },
-    { path: "submittedAt", displayName: "Submitted At", type: "string", description: "ISO timestamp of submission" }
-  ],
+  eligibleForEventTrigger: true,
+  // Static fallback — used until a collection is picked and the survey
+  // schema is materialised. `getDynamicOutputSchema` takes over after that.
+  outputSchema: BASELINE_OUTPUT,
+  /**
+   * Per-block output schema — same shape as `run()`'s `output`. Picks up the
+   * materialised survey schema so the DataInput reference picker can surface
+   * `output.surveyAnswers.<question>` alongside the baseline claim fields.
+   */
+  getDynamicOutputSchema: (inputs) => {
+    const schema = Array.isArray(inputs?.surveyAnswersSchema) ? inputs.surveyAnswersSchema : [];
+    if (schema.length === 0) return BASELINE_OUTPUT;
+    return [...BASELINE_OUTPUT, ...prefixSurveyAnswerSchema(schema)];
+  },
+  /**
+   * Per-block event resolver. Returns `[]` until a claim collection has been
+   * picked in template mode (which is when we can materialise the survey's
+   * answer schema into inputs). Once present, emits a `submitted` event with
+   * baseline claim fields plus `surveyAnswers.<question>` for every question
+   * in the survey template — letting listener blocks consume typed refs like
+   * `${sourceBlock.payload.surveyAnswers.email}`.
+   */
+  getDynamicEvents: (inputs) => {
+    const schema = Array.isArray(inputs?.surveyAnswersSchema) ? inputs.surveyAnswersSchema : [];
+    if (schema.length === 0) return [];
+    const surveyFields = prefixSurveyAnswerSchema(schema);
+    return [
+      {
+        name: "submitted",
+        displayName: "Claim submitted",
+        description: "Fires when a claim is submitted to this collection. Payload includes the submitted survey answers, fully typed to the collection survey.",
+        payloadSchema: [...BASELINE_OUTPUT, ...surveyFields],
+        pendingDisplayFields: ["claimId", "submittedAt"]
+      }
+    ];
+  },
   run: async (inputs, ctx) => {
     const service = ctx.services.claim;
     if (!service) {
@@ -912,20 +1096,59 @@ registerAction({
     if (!claimId) {
       throw new Error("submitClaim returned no claim identifier");
     }
+    const transactionHash = String(result?.transactionHash || "");
+    const submittedByDid = ctx.actorDid || "";
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const output = {
+      claimId,
+      transactionHash,
+      collectionId,
+      deedDid,
+      submittedByDid,
+      submittedAt,
+      surveyAnswers
+    };
     return {
-      output: {
-        claimId,
-        transactionHash: String(result?.transactionHash || ""),
-        collectionId,
-        deedDid,
-        submittedByDid: ctx.actorDid || "",
-        submittedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
+      output,
+      events: [
+        {
+          name: "submitted",
+          payload: output
+        }
+      ]
     };
   }
 });
 
 // src/core/lib/actionRegistry/actions/evaluateClaim/evaluateClaim.ts
+var BASELINE_OUTPUT2 = [
+  { path: "claimId", displayName: "Claim ID", type: "string", description: "Evaluated claim identifier" },
+  { path: "decision", displayName: "Decision", type: "string", description: "approve or reject" },
+  { path: "status", displayName: "Status", type: "string", description: "approved or rejected" },
+  { path: "verificationProof", displayName: "Verification Proof", type: "string", description: "UDID URL proof if generated" },
+  { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "On-chain evaluation transaction hash" },
+  { path: "collectionId", displayName: "Collection ID", type: "string", description: "Claim collection identifier" },
+  { path: "deedDid", displayName: "Deed DID", type: "string", description: "Deed identifier" },
+  { path: "evaluatedByDid", displayName: "Evaluated By DID", type: "string", description: "Actor DID that evaluated the claim" },
+  { path: "evaluatedAt", displayName: "Evaluated At", type: "string", description: "ISO timestamp of evaluation" }
+];
+var BASELINE_APPROVED_EVENT = [
+  { path: "claimId", displayName: "Claim ID", type: "string", description: "Approved claim identifier" },
+  { path: "collectionId", displayName: "Collection ID", type: "string" },
+  { path: "deedDid", displayName: "Deed DID", type: "string" },
+  { path: "evaluatedByDid", displayName: "Evaluated By DID", type: "string", description: "Actor DID that approved the claim" },
+  { path: "evaluatedAt", displayName: "Evaluated At", type: "string" },
+  { path: "verificationProof", displayName: "Verification Proof", type: "string" },
+  { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "On-chain approval transaction hash \u2014 proof of payout" }
+];
+var BASELINE_REJECTED_EVENT = [
+  { path: "claimId", displayName: "Claim ID", type: "string", description: "Rejected claim identifier" },
+  { path: "collectionId", displayName: "Collection ID", type: "string" },
+  { path: "deedDid", displayName: "Deed DID", type: "string" },
+  { path: "evaluatedByDid", displayName: "Evaluated By DID", type: "string", description: "Actor DID that rejected the claim" },
+  { path: "evaluatedAt", displayName: "Evaluated At", type: "string" },
+  { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "On-chain rejection transaction hash" }
+];
 function normalizeDecision2(value) {
   const normalized = String(value || "").trim().toLowerCase();
   if (normalized === "approve" || normalized === "reject") {
@@ -946,45 +1169,62 @@ registerAction({
   sideEffect: true,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
-  outputSchema: [
-    { path: "claimId", displayName: "Claim ID", type: "string", description: "Evaluated claim identifier" },
-    { path: "decision", displayName: "Decision", type: "string", description: "approve or reject" },
-    { path: "status", displayName: "Status", type: "string", description: "approved or rejected" },
-    { path: "verificationProof", displayName: "Verification Proof", type: "string", description: "UDID URL proof if generated" },
-    { path: "collectionId", displayName: "Collection ID", type: "string", description: "Claim collection identifier" },
-    { path: "deedDid", displayName: "Deed DID", type: "string", description: "Deed identifier" },
-    { path: "evaluatedByDid", displayName: "Evaluated By DID", type: "string", description: "Actor DID that evaluated the claim" },
-    { path: "evaluatedAt", displayName: "Evaluated At", type: "string", description: "ISO timestamp of evaluation" }
-  ],
+  // Static fallback — used until a collection is picked and the survey
+  // schema is materialised. `getDynamicOutputSchema` takes over after that.
+  outputSchema: BASELINE_OUTPUT2,
+  /**
+   * Per-block output schema. Surfaces `output.surveyAnswers.<question>`
+   * alongside the baseline evaluation fields once the template author has
+   * picked a collection and the survey schema has been materialised into
+   * inputs. Lets DataInput pickers reference typed survey fields downstream.
+   */
+  getDynamicOutputSchema: (inputs) => {
+    const schema = Array.isArray(inputs?.surveyAnswersSchema) ? inputs.surveyAnswersSchema : [];
+    if (schema.length === 0) return BASELINE_OUTPUT2;
+    return [...BASELINE_OUTPUT2, ...prefixSurveyAnswerSchema(schema)];
+  },
   events: [
     {
       name: "approved",
       displayName: "Approved",
       description: "Fires when an evaluator approves the claim.",
-      payloadSchema: [
-        { path: "claimId", displayName: "Claim ID", type: "string", description: "Approved claim identifier" },
-        { path: "collectionId", displayName: "Collection ID", type: "string" },
-        { path: "deedDid", displayName: "Deed DID", type: "string" },
-        { path: "evaluatedByDid", displayName: "Evaluated By DID", type: "string", description: "Actor DID that approved the claim" },
-        { path: "evaluatedAt", displayName: "Evaluated At", type: "string" },
-        { path: "verificationProof", displayName: "Verification Proof", type: "string" }
-      ],
+      payloadSchema: BASELINE_APPROVED_EVENT,
       pendingDisplayFields: ["claimId", "evaluatedAt"]
     },
     {
       name: "rejected",
       displayName: "Rejected",
       description: "Fires when an evaluator rejects the claim.",
-      payloadSchema: [
-        { path: "claimId", displayName: "Claim ID", type: "string", description: "Rejected claim identifier" },
-        { path: "collectionId", displayName: "Collection ID", type: "string" },
-        { path: "deedDid", displayName: "Deed DID", type: "string" },
-        { path: "evaluatedByDid", displayName: "Evaluated By DID", type: "string", description: "Actor DID that rejected the claim" },
-        { path: "evaluatedAt", displayName: "Evaluated At", type: "string" }
-      ],
+      payloadSchema: BASELINE_REJECTED_EVENT,
       pendingDisplayFields: ["claimId", "evaluatedAt"]
     }
   ],
+  /**
+   * Per-block event schema — same idea as `getDynamicOutputSchema`. Adds the
+   * survey-answer fields to both `approved` and `rejected` event payloads
+   * so listener blocks (e.g. `qi/xero.invoice.create`) can reference
+   * `${sourceBlock.payload.surveyAnswers.<field>}` with typed paths.
+   */
+  getDynamicEvents: (inputs) => {
+    const schema = Array.isArray(inputs?.surveyAnswersSchema) ? inputs.surveyAnswersSchema : [];
+    const surveyFields = schema.length > 0 ? prefixSurveyAnswerSchema(schema) : [];
+    return [
+      {
+        name: "approved",
+        displayName: "Approved",
+        description: "Fires when an evaluator approves the claim.",
+        payloadSchema: [...BASELINE_APPROVED_EVENT, ...surveyFields],
+        pendingDisplayFields: ["claimId", "evaluatedAt"]
+      },
+      {
+        name: "rejected",
+        displayName: "Rejected",
+        description: "Fires when an evaluator rejects the claim.",
+        payloadSchema: [...BASELINE_REJECTED_EVENT, ...surveyFields],
+        pendingDisplayFields: ["claimId", "evaluatedAt"]
+      }
+    ];
+  },
   run: async (inputs, ctx) => {
     const service = ctx.services.claim;
     if (!service) {
@@ -1032,18 +1272,19 @@ registerAction({
       if (!denom || !tokenAmount) return null;
       return { denom, amount: tokenAmount };
     };
-    let normalizedAmounts;
+    let normalizedCoin;
     if (Array.isArray(amount)) {
-      normalizedAmounts = amount.map(normalizeCoin).filter((coin) => !!coin);
-      if (normalizedAmounts.length !== amount.length) {
+      const coins = amount.map(normalizeCoin).filter((coin) => !!coin);
+      if (coins.length !== amount.length) {
         throw new Error("amount must contain valid coin objects with denom and amount");
       }
+      normalizedCoin = coins[0];
     } else if (amount != null) {
       const coin = normalizeCoin(amount);
       if (!coin) {
-        throw new Error("amount must be a coin object or an array of coin objects");
+        throw new Error("amount must be a coin object with denom and amount");
       }
-      normalizedAmounts = [coin];
+      normalizedCoin = coin;
     }
     let verificationProof = String(inputs.verificationProof || "").trim();
     const shouldCreateUdid = Boolean(inputs.createUdid);
@@ -1078,14 +1319,27 @@ registerAction({
     if (!granteeAddress) {
       throw new Error("granteeAddress could not be resolved");
     }
-    await service.evaluateClaim(granteeAddress, deedDid, {
+    const broadcastResult = await service.evaluateClaim(granteeAddress, deedDid, {
       claimId,
       collectionId,
       adminAddress,
       status: toStatus(decision),
       verificationProof,
-      amount: normalizedAmounts && normalizedAmounts.length > 0 ? normalizedAmounts.length === 1 ? normalizedAmounts[0] : normalizedAmounts : void 0
+      amount: normalizedCoin
     });
+    const transactionHash = String(broadcastResult?.transactionHash || "");
+    let surveyAnswers = {};
+    try {
+      const getClaimData = handlers?.getClaimData;
+      if (typeof getClaimData === "function") {
+        const claimData = await getClaimData(collectionId, claimId);
+        const candidate = claimData?.credentialSubject ?? claimData?.surveyAnswers ?? claimData;
+        if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+          surveyAnswers = candidate;
+        }
+      }
+    } catch {
+    }
     const evaluatedByDid = ctx.actorDid || granteeAddress;
     const evaluatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const output = {
@@ -1093,10 +1347,12 @@ registerAction({
       decision,
       status: decision === "approve" ? "approved" : "rejected",
       verificationProof,
+      transactionHash,
       collectionId,
       deedDid,
       evaluatedByDid,
-      evaluatedAt
+      evaluatedAt,
+      surveyAnswers
     };
     const eventName = decision === "approve" ? "approved" : "rejected";
     const eventPayload = decision === "approve" ? {
@@ -1105,13 +1361,17 @@ registerAction({
       deedDid,
       evaluatedByDid,
       evaluatedAt,
-      verificationProof
+      verificationProof,
+      transactionHash,
+      surveyAnswers
     } : {
       claimId,
       collectionId,
       deedDid,
       evaluatedByDid,
-      evaluatedAt
+      evaluatedAt,
+      transactionHash,
+      surveyAnswers
     };
     return {
       output,
@@ -2763,9 +3023,7 @@ registerAction({
   can: "wallet/fund",
   sideEffect: true,
   defaultRequiresConfirmation: true,
-  outputSchema: [
-    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The funding transaction hash" }
-  ],
+  outputSchema: [{ path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The funding transaction hash" }],
   run: async (inputs, ctx) => {
     if (!ctx.services.oracle?.fundWallet) {
       throw new Error("oracle.fundWallet handler not available");
@@ -2982,8 +3240,18 @@ registerAction({
   outputSchema: [
     { path: "entityDid", displayName: "Entity DID", type: "string", description: "The oracle entity DID" },
     { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The entity creation transaction hash" },
-    { path: "encryptionPublicKeyMultibase", displayName: "Encryption Public Key (multibase)", type: "string", description: "Multibase-encoded P-256 public key registered as a keyAgreement vm on the entity DID" },
-    { path: "encryptionVerificationMethodId", displayName: "Encryption Verification Method ID", type: "string", description: "DID verification method id of the P-256 keyAgreement key" }
+    {
+      path: "encryptionPublicKeyMultibase",
+      displayName: "Encryption Public Key (multibase)",
+      type: "string",
+      description: "Multibase-encoded P-256 public key registered as a keyAgreement vm on the entity DID"
+    },
+    {
+      path: "encryptionVerificationMethodId",
+      displayName: "Encryption Verification Method ID",
+      type: "string",
+      description: "DID verification method id of the P-256 keyAgreement key"
+    }
   ],
   run: async (rawInputs, ctx) => {
     const form = (() => {
@@ -3084,12 +3352,7 @@ registerAction({
 });
 
 // src/core/lib/actionRegistry/actions/oracleStoreSecrets.ts
-var SENSITIVE_PLAINTEXT_KEYS = [
-  "SECP_MNEMONIC",
-  "MATRIX_ORACLE_ADMIN_PASSWORD",
-  "MATRIX_RECOVERY_PHRASE",
-  "MATRIX_VALUE_PIN"
-];
+var SENSITIVE_PLAINTEXT_KEYS = ["SECP_MNEMONIC", "MATRIX_ORACLE_ADMIN_PASSWORD", "MATRIX_RECOVERY_PHRASE", "MATRIX_VALUE_PIN"];
 registerAction({
   type: "qi/oracle.storeSecrets",
   can: "oracle/storeSecrets",
@@ -3196,12 +3459,7 @@ registerAction({
 });
 
 // src/core/lib/actionRegistry/actions/oracleStoreSecretsAndConfig.ts
-var SENSITIVE_PLAINTEXT_KEYS2 = [
-  "SECP_MNEMONIC",
-  "MATRIX_ORACLE_ADMIN_PASSWORD",
-  "MATRIX_RECOVERY_PHRASE",
-  "MATRIX_VALUE_PIN"
-];
+var SENSITIVE_PLAINTEXT_KEYS2 = ["SECP_MNEMONIC", "MATRIX_ORACLE_ADMIN_PASSWORD", "MATRIX_RECOVERY_PHRASE", "MATRIX_VALUE_PIN"];
 registerAction({
   type: "qi/oracle.storeSecretsAndConfig",
   can: "oracle/storeSecretsAndConfig",
@@ -3304,12 +3562,7 @@ registerAction({
 });
 
 // src/core/lib/actionRegistry/actions/oracleConfigureOracle.ts
-var SENSITIVE_PLAINTEXT_KEYS3 = [
-  "SECP_MNEMONIC",
-  "MATRIX_ORACLE_ADMIN_PASSWORD",
-  "MATRIX_RECOVERY_PHRASE",
-  "MATRIX_VALUE_PIN"
-];
+var SENSITIVE_PLAINTEXT_KEYS3 = ["SECP_MNEMONIC", "MATRIX_ORACLE_ADMIN_PASSWORD", "MATRIX_RECOVERY_PHRASE", "MATRIX_VALUE_PIN"];
 registerAction({
   type: "qi/oracle.configureOracle",
   can: "oracle/configureOracle",
@@ -3546,6 +3799,628 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/calendar/eventCreate.types.ts
+var EMPTY = {
+  connection: null,
+  calendar_id: "primary",
+  summary: "",
+  description: "",
+  location: "",
+  timezone: "",
+  start_datetime: "",
+  end_datetime: "",
+  attendees: "",
+  send_updates: ""
+};
+function parseCalendarEventCreateInputs(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,
+      calendar_id: typeof parsed.calendar_id === "string" && parsed.calendar_id ? parsed.calendar_id : "primary",
+      summary: typeof parsed.summary === "string" ? parsed.summary : "",
+      description: typeof parsed.description === "string" ? parsed.description : "",
+      location: typeof parsed.location === "string" ? parsed.location : "",
+      timezone: typeof parsed.timezone === "string" ? parsed.timezone : "",
+      start_datetime: typeof parsed.start_datetime === "string" ? parsed.start_datetime : "",
+      end_datetime: typeof parsed.end_datetime === "string" ? parsed.end_datetime : "",
+      attendees: typeof parsed.attendees === "string" ? parsed.attendees : Array.isArray(parsed.attendees) ? JSON.stringify(parsed.attendees) : "",
+      send_updates: typeof parsed.send_updates === "string" ? parsed.send_updates : ""
+    };
+  } catch {
+    return { ...EMPTY };
+  }
+}
+function serializeCalendarEventCreateInputs(inputs) {
+  return JSON.stringify(inputs);
+}
+function parseAttendeesField(raw) {
+  const trimmed = (raw || "").trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) return parsed.filter((v) => typeof v === "string" && v.trim()).map((v) => v.trim());
+    } catch {
+    }
+  }
+  return trimmed.split(/[\n,]+/).map((s) => s.trim()).filter(Boolean);
+}
+
+// src/core/lib/actionRegistry/actions/calendar/eventCreate.ts
+var CALENDAR_EVENT_CREATE_SLUG = "GOOGLECALENDAR_CREATE_EVENT";
+registerAction({
+  type: "qi/calendar.event.create",
+  can: "calendar.event/create",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  outputSchema: [
+    { path: "eventId", displayName: "Event ID", type: "string", description: "Opaque identifier of the created event" },
+    { path: "htmlLink", displayName: "Event link", type: "string", description: "Web UI link to the created event" },
+    { path: "summary", displayName: "Summary", type: "string" },
+    { path: "startIso", displayName: "Start", type: "string", description: "Resolved start time (ISO 8601)" },
+    { path: "endIso", displayName: "End", type: "string", description: "Resolved end time (ISO 8601)" },
+    { path: "hangoutLink", displayName: "Meet link", type: "string" }
+  ],
+  events: [
+    {
+      name: "event.created",
+      displayName: "Calendar event created",
+      description: "Fired after a new event is written to Calendar",
+      payloadSchema: [
+        { path: "eventId", displayName: "Event ID", type: "string" },
+        { path: "htmlLink", displayName: "Event link", type: "string" },
+        { path: "summary", displayName: "Summary", type: "string" }
+      ],
+      pendingDisplayFields: ["summary", "eventId"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Calendar integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Calendar before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Calendar to use it here.");
+    }
+    const start = (inputs.start_datetime || "").trim();
+    if (!start) {
+      throw new Error("Start time is required.");
+    }
+    const args = {
+      start_datetime: start,
+      calendar_id: (inputs.calendar_id || "primary").trim() || "primary"
+    };
+    const end = (inputs.end_datetime || "").trim();
+    if (end) args.end_datetime = end;
+    if (inputs.summary) args.summary = inputs.summary;
+    if (inputs.description) args.description = inputs.description;
+    if (inputs.location) args.location = inputs.location;
+    if (inputs.timezone) args.timezone = inputs.timezone;
+    if (inputs.send_updates) args.send_updates = inputs.send_updates;
+    const attendees = parseAttendeesField(inputs.attendees || "");
+    if (attendees.length > 0) args.attendees = attendees;
+    const result = await svc.executeTool({
+      toolSlug: CALENDAR_EVENT_CREATE_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Calendar event creation failed");
+    }
+    const envelope = result.data;
+    const event = envelope?.response_data || envelope?.data?.response_data || envelope || {};
+    const eventId = String(event.id || "");
+    const htmlLink = String(event.htmlLink || envelope?.display_url || "");
+    const summary = String(event.summary || inputs.summary || "");
+    const startIso = String(event.start?.dateTime || event.start?.date || start);
+    const endIso = String(event.end?.dateTime || event.end?.date || end || "");
+    const hangoutLink = String(event.hangoutLink || "");
+    return {
+      output: {
+        eventId,
+        htmlLink,
+        summary,
+        startIso,
+        endIso,
+        hangoutLink
+      },
+      events: eventId ? [{ name: "event.created", payload: { eventId, htmlLink, summary } }] : void 0
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/calendar/eventUpdate.ts
+var CALENDAR_EVENT_UPDATE_SLUG = "GOOGLECALENDAR_UPDATE_EVENT";
+var CALENDAR_EVENT_GET_SLUG = "GOOGLECALENDAR_EVENTS_GET";
+registerAction({
+  type: "qi/calendar.event.update",
+  can: "calendar.event/update",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  outputSchema: [
+    { path: "eventId", displayName: "Event ID", type: "string" },
+    { path: "htmlLink", displayName: "Event link", type: "string" },
+    { path: "summary", displayName: "Summary", type: "string" },
+    { path: "startIso", displayName: "Start", type: "string" },
+    { path: "endIso", displayName: "End", type: "string" }
+  ],
+  events: [
+    {
+      name: "event.updated",
+      displayName: "Calendar event updated",
+      description: "Fired after an existing event is replaced",
+      payloadSchema: [
+        { path: "eventId", displayName: "Event ID", type: "string" },
+        { path: "htmlLink", displayName: "Event link", type: "string" },
+        { path: "summary", displayName: "Summary", type: "string" }
+      ],
+      pendingDisplayFields: ["summary", "eventId"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Calendar integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Calendar before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Calendar to use it here.");
+    }
+    const eventId = (inputs.event_id || "").trim();
+    if (!eventId) {
+      throw new Error("Event ID is required to update an event.");
+    }
+    const start = (inputs.start_datetime || "").trim();
+    if (!start) {
+      throw new Error("Start time is required.");
+    }
+    const args = {
+      event_id: eventId,
+      start_datetime: start,
+      calendar_id: (inputs.calendar_id || "primary").trim() || "primary"
+    };
+    const end = (inputs.end_datetime || "").trim();
+    if (end) args.end_datetime = end;
+    if (inputs.summary) args.summary = inputs.summary;
+    if (inputs.description) args.description = inputs.description;
+    if (inputs.location) args.location = inputs.location;
+    if (inputs.timezone) args.timezone = inputs.timezone;
+    if (inputs.send_updates) args.send_updates = inputs.send_updates;
+    const attendees = parseAttendeesField(inputs.attendees || "");
+    if (attendees.length > 0) args.attendees = attendees;
+    const result = await svc.executeTool({
+      toolSlug: CALENDAR_EVENT_UPDATE_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Calendar event update failed");
+    }
+    const envelope = result.data;
+    const event = envelope?.response_data || envelope?.data?.response_data || envelope || {};
+    const outId = String(event.id || eventId);
+    const htmlLink = String(event.htmlLink || envelope?.display_url || "");
+    const summary = String(event.summary || inputs.summary || "");
+    const startIso = String(event.start?.dateTime || event.start?.date || start);
+    const endIso = String(event.end?.dateTime || event.end?.date || end || "");
+    return {
+      output: {
+        eventId: outId,
+        htmlLink,
+        summary,
+        startIso,
+        endIso
+      },
+      events: [{ name: "event.updated", payload: { eventId: outId, htmlLink, summary } }]
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/calendar/eventList.ts
+var CALENDAR_EVENT_LIST_SLUG = "GOOGLECALENDAR_EVENTS_LIST";
+registerAction({
+  type: "qi/calendar.event.list",
+  can: "calendar.event/list",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: false,
+  outputSchema: [
+    { path: "items", displayName: "Events", type: "array", description: "Raw event objects as returned by Calendar" },
+    { path: "count", displayName: "Count", type: "number" },
+    { path: "firstId", displayName: "First event ID", type: "string" },
+    { path: "ids", displayName: "Event IDs", type: "array" },
+    { path: "nextPageToken", displayName: "Next page token", type: "string" }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Calendar integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Calendar before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Calendar to use it here.");
+    }
+    const args = {
+      calendarId: (inputs.calendarId || "primary").trim() || "primary"
+    };
+    if (inputs.q) args.q = inputs.q;
+    if (inputs.timeMin) args.timeMin = inputs.timeMin;
+    if (inputs.timeMax) args.timeMax = inputs.timeMax;
+    if (inputs.timeZone) args.timeZone = inputs.timeZone;
+    if (inputs.orderBy) args.orderBy = inputs.orderBy;
+    if (typeof inputs.singleEvents === "boolean") args.singleEvents = inputs.singleEvents;
+    if (inputs.maxResults) {
+      const n = Number.parseInt(inputs.maxResults, 10);
+      if (Number.isFinite(n) && n > 0) args.maxResults = n;
+    }
+    const result = await svc.executeTool({
+      toolSlug: CALENDAR_EVENT_LIST_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Calendar list failed");
+    }
+    const envelope = result.data;
+    const list = envelope?.items ? envelope : envelope?.data || envelope;
+    const items = Array.isArray(list?.items) ? list.items : [];
+    const ids = items.map((e) => String(e?.id || "")).filter(Boolean);
+    return {
+      output: {
+        items,
+        count: items.length,
+        firstId: ids[0] ?? null,
+        ids,
+        nextPageToken: String(list?.nextPageToken || "")
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/xero/contactCreate.ts
+var XERO_CREATE_CONTACT_SLUG = "XERO_CREATE_CONTACT";
+registerAction({
+  type: "qi/xero.contact.create",
+  can: "xero.contact/create",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  outputSchema: [
+    { path: "contactId", displayName: "Contact ID", type: "string" },
+    { path: "name", displayName: "Name", type: "string" },
+    { path: "emailAddress", displayName: "Email", type: "string" }
+  ],
+  events: [
+    {
+      name: "contact.created",
+      displayName: "Xero contact created",
+      description: "Fired after a new Xero contact is written",
+      payloadSchema: [
+        { path: "contactId", displayName: "Contact ID", type: "string" },
+        { path: "name", displayName: "Name", type: "string" }
+      ],
+      pendingDisplayFields: ["name", "contactId"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Xero integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Xero before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Xero to use it here.");
+    }
+    const name = (inputs.Name || "").trim();
+    if (!name) throw new Error("Name is required.");
+    const args = { Name: name };
+    if (inputs.tenant_id) args.tenant_id = inputs.tenant_id;
+    if (inputs.FirstName) args.FirstName = inputs.FirstName;
+    if (inputs.LastName) args.LastName = inputs.LastName;
+    if (inputs.EmailAddress) args.EmailAddress = inputs.EmailAddress;
+    if (inputs.phone_number) args.phone_number = inputs.phone_number;
+    if (inputs.mobile_number) args.mobile_number = inputs.mobile_number;
+    if (inputs.Website) args.Website = inputs.Website;
+    if (inputs.TaxNumber) args.TaxNumber = inputs.TaxNumber;
+    if (inputs.AccountNumber) args.AccountNumber = inputs.AccountNumber;
+    if (inputs.DefaultCurrency) args.DefaultCurrency = inputs.DefaultCurrency;
+    if (inputs.BankAccountDetails) args.BankAccountDetails = inputs.BankAccountDetails;
+    if (typeof inputs.IsCustomer === "boolean") args.IsCustomer = inputs.IsCustomer;
+    if (typeof inputs.IsSupplier === "boolean") args.IsSupplier = inputs.IsSupplier;
+    const result = await svc.executeTool({
+      toolSlug: XERO_CREATE_CONTACT_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Xero contact creation failed");
+    }
+    const envelope = result.data;
+    const contact = envelope?.Contacts?.[0] || envelope?.data?.Contacts?.[0] || envelope?.contact || envelope || {};
+    const contactId = String(contact.ContactID || contact.contactID || contact.id || "");
+    return {
+      output: {
+        contactId,
+        name: String(contact.Name || name),
+        emailAddress: String(contact.EmailAddress || inputs.EmailAddress || "")
+      },
+      events: contactId ? [{ name: "contact.created", payload: { contactId, name: String(contact.Name || name) } }] : void 0
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/xero/invoiceCreate.ts
+var XERO_CREATE_INVOICE_SLUG = "XERO_CREATE_INVOICE";
+registerAction({
+  type: "qi/xero.invoice.create",
+  can: "xero.invoice/create",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  outputSchema: [
+    { path: "invoiceId", displayName: "Invoice ID", type: "string" },
+    { path: "invoiceNumber", displayName: "Invoice number", type: "string" },
+    { path: "total", displayName: "Total", type: "number" },
+    { path: "status", displayName: "Status", type: "string" }
+  ],
+  events: [
+    {
+      name: "invoice.created",
+      displayName: "Xero invoice created",
+      description: "Fired after a new Xero invoice is written",
+      payloadSchema: [
+        { path: "invoiceId", displayName: "Invoice ID", type: "string" },
+        { path: "invoiceNumber", displayName: "Invoice number", type: "string" },
+        { path: "total", displayName: "Total", type: "number" }
+      ],
+      pendingDisplayFields: ["invoiceNumber", "total"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Xero integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Xero before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Xero to use it here.");
+    }
+    const type = (inputs.Type || "").trim().toUpperCase() || "ACCREC";
+    if (type !== "ACCREC" && type !== "ACCPAY") {
+      throw new Error("Invoice type must be ACCREC (sale) or ACCPAY (bill).");
+    }
+    if (!Array.isArray(inputs.LineItems) || inputs.LineItems.length === 0) {
+      throw new Error("At least one line item is required.");
+    }
+    const args = {
+      Type: type,
+      LineItems: inputs.LineItems
+    };
+    if (inputs.tenant_id) args.tenant_id = inputs.tenant_id;
+    if (inputs.Status) args.Status = inputs.Status;
+    if (inputs.Date) args.Date = inputs.Date;
+    if (inputs.DueDate) args.DueDate = inputs.DueDate;
+    if (inputs.ContactID) args.ContactID = inputs.ContactID;
+    else if (inputs.ContactName) args.ContactName = inputs.ContactName;
+    if (inputs.Reference) args.Reference = inputs.Reference;
+    if (inputs.InvoiceNumber) args.InvoiceNumber = inputs.InvoiceNumber;
+    if (inputs.CurrencyCode) args.CurrencyCode = inputs.CurrencyCode;
+    const result = await svc.executeTool({
+      toolSlug: XERO_CREATE_INVOICE_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Xero invoice creation failed");
+    }
+    const envelope = result.data;
+    const invoice = envelope?.Invoices?.[0] || envelope?.data?.Invoices?.[0] || envelope?.invoice || envelope || {};
+    const invoiceId = String(invoice.InvoiceID || invoice.invoiceID || invoice.id || "");
+    const invoiceNumber = String(invoice.InvoiceNumber || inputs.InvoiceNumber || "");
+    const total = typeof invoice.Total === "number" ? invoice.Total : Number(invoice.Total) || 0;
+    const status = String(invoice.Status || inputs.Status || "DRAFT");
+    return {
+      output: {
+        invoiceId,
+        invoiceNumber,
+        total,
+        status
+      },
+      events: invoiceId ? [{ name: "invoice.created", payload: { invoiceId, invoiceNumber, total } }] : void 0
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/xero/invoiceList.ts
+var XERO_LIST_INVOICES_SLUG = "XERO_LIST_INVOICES";
+registerAction({
+  type: "qi/xero.invoice.list",
+  can: "xero.invoice/list",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: false,
+  outputSchema: [
+    { path: "items", displayName: "Invoices", type: "array" },
+    { path: "count", displayName: "Count", type: "number" },
+    { path: "firstId", displayName: "First invoice ID", type: "string" },
+    { path: "ids", displayName: "Invoice IDs", type: "array" }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Xero integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Xero before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Xero to use it here.");
+    }
+    const args = {};
+    if (inputs.tenantId) args.tenantId = inputs.tenantId;
+    if (inputs.page) {
+      const p = Number.parseInt(inputs.page, 10);
+      if (Number.isFinite(p) && p >= 1) args.page = p;
+    }
+    if (inputs.order) args.order = inputs.order;
+    if (inputs.Statuses) args.Statuses = inputs.Statuses;
+    if (inputs.ContactIDs) args.ContactIDs = inputs.ContactIDs;
+    if (inputs.InvoiceIDs) args.InvoiceIDs = inputs.InvoiceIDs;
+    if (inputs.where) args.where = inputs.where;
+    if (typeof inputs.createdByMyApp === "boolean") args.createdByMyApp = inputs.createdByMyApp;
+    if (typeof inputs.includeArchived === "boolean") args.includeArchived = inputs.includeArchived;
+    const result = await svc.executeTool({
+      toolSlug: XERO_LIST_INVOICES_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Xero invoice list failed");
+    }
+    const envelope = result.data;
+    const list = envelope?.Invoices ? envelope : envelope?.data || envelope;
+    const items = Array.isArray(list?.Invoices) ? list.Invoices : Array.isArray(list?.items) ? list.items : [];
+    const ids = items.map((i) => String(i?.InvoiceID || i?.id || "")).filter(Boolean);
+    return {
+      output: {
+        items,
+        count: items.length,
+        firstId: ids[0] ?? null,
+        ids
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/xero/paymentCreate.ts
+var XERO_CREATE_PAYMENT_SLUG = "XERO_CREATE_PAYMENT";
+registerAction({
+  type: "qi/xero.payment.create",
+  can: "xero.payment/create",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  outputSchema: [
+    { path: "paymentId", displayName: "Payment ID", type: "string" },
+    { path: "invoiceId", displayName: "Invoice ID", type: "string" },
+    { path: "amount", displayName: "Amount", type: "number" },
+    { path: "date", displayName: "Date", type: "string" },
+    { path: "reference", displayName: "Reference", type: "string" },
+    { path: "status", displayName: "Status", type: "string" }
+  ],
+  events: [
+    {
+      name: "payment.created",
+      displayName: "Xero payment recorded",
+      description: "Fired after a payment is recorded against a Xero invoice \u2014 settles the bill in the books.",
+      payloadSchema: [
+        { path: "paymentId", displayName: "Payment ID", type: "string" },
+        { path: "invoiceId", displayName: "Invoice ID", type: "string" },
+        { path: "amount", displayName: "Amount", type: "number" },
+        { path: "reference", displayName: "Reference", type: "string" }
+      ],
+      pendingDisplayFields: ["invoiceId", "amount"]
+    }
+  ],
+  run: async (inputs, ctx) => {
+    const svc = ctx.services.integrations;
+    if (!svc?.executeTool) {
+      throw new Error("Xero integration is not configured");
+    }
+    const connection = inputs.connection;
+    if (!connection?.connectedAccountId) {
+      throw new Error("Connect Xero before running this action.");
+    }
+    const currentEntityDid = svc.getEntityDid?.();
+    if (currentEntityDid && connection.entityDid && currentEntityDid !== connection.entityDid) {
+      throw new Error("This block was configured for a different workspace. Reconnect Xero to use it here.");
+    }
+    const invoiceId = String(inputs.InvoiceID || "").trim();
+    if (!invoiceId) {
+      throw new Error("InvoiceID is required \u2014 usually wired from the upstream Capture Bill step.");
+    }
+    const accountId = String(inputs.AccountID || "").trim();
+    if (!accountId) {
+      throw new Error("AccountID is required \u2014 set the Xero bank/treasury account in template config.");
+    }
+    if (!Number.isFinite(inputs.Amount) || inputs.Amount <= 0) {
+      throw new Error("Amount must be a positive number.");
+    }
+    const date = String(inputs.Date || "").trim() || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const args = {
+      InvoiceID: invoiceId,
+      AccountID: accountId,
+      Date: date,
+      Amount: inputs.Amount
+    };
+    if (inputs.tenant_id) args.tenant_id = inputs.tenant_id;
+    if (inputs.Reference) args.Reference = inputs.Reference;
+    if (typeof inputs.CurrencyRate === "number" && Number.isFinite(inputs.CurrencyRate)) {
+      args.CurrencyRate = inputs.CurrencyRate;
+    }
+    const result = await svc.executeTool({
+      toolSlug: XERO_CREATE_PAYMENT_SLUG,
+      connectedAccountId: connection.connectedAccountId,
+      arguments: args
+    });
+    if (!result.successful) {
+      throw new Error(result.error || "Xero payment creation failed");
+    }
+    const envelope = result.data;
+    const payment = envelope?.Payments?.[0] || envelope?.data?.Payments?.[0] || envelope?.payment || envelope || {};
+    const paymentId = String(payment.PaymentID || payment.paymentID || payment.id || "");
+    const amount = typeof payment.Amount === "number" ? payment.Amount : Number(payment.Amount) || inputs.Amount;
+    const status = String(payment.Status || "AUTHORISED");
+    const reference = String(payment.Reference || inputs.Reference || "");
+    return {
+      output: {
+        paymentId,
+        invoiceId,
+        amount,
+        date,
+        reference,
+        status
+      },
+      events: paymentId ? [{ name: "payment.created", payload: { paymentId, invoiceId, amount, reference } }] : void 0
+    };
+  }
+});
+
 // src/core/lib/actionRegistry/actions/bid/bid.diff.ts
 registerDiffResolver("bid", {
   resolver: async (inputs, _ctx) => {
@@ -3828,6 +4703,344 @@ registerDiffResolver("evaluateClaim", {
   }
 });
 
+// src/core/lib/actionRegistry/actions/calendar/eventCreate.diff.ts
+registerDiffResolver("qi/calendar.event.create", {
+  resolver: async (inputs, _ctx) => {
+    const attendees = parseAttendeesField(String(inputs.attendees || ""));
+    const calendarId = String(inputs.calendar_id || "").trim() || "primary";
+    const results = [
+      {
+        key: "summary",
+        label: "Title",
+        before: null,
+        after: String(inputs.summary || "").trim() || "(no title)",
+        changeType: "add"
+      },
+      {
+        key: "start_datetime",
+        label: "Start",
+        before: null,
+        after: String(inputs.start_datetime || "").trim() || "(required \u2014 set start time)",
+        changeType: "add"
+      }
+    ];
+    const end = String(inputs.end_datetime || "").trim();
+    if (end) {
+      results.push({
+        key: "end_datetime",
+        label: "End",
+        before: null,
+        after: end,
+        changeType: "add"
+      });
+    }
+    const timezone = String(inputs.timezone || "").trim();
+    if (timezone) {
+      results.push({
+        key: "timezone",
+        label: "Timezone",
+        before: null,
+        after: timezone,
+        changeType: "add"
+      });
+    }
+    const location = String(inputs.location || "").trim();
+    if (location) {
+      results.push({
+        key: "location",
+        label: "Location",
+        before: null,
+        after: location,
+        changeType: "add"
+      });
+    }
+    if (attendees.length > 0) {
+      results.push({
+        key: "attendees",
+        label: "Attendees",
+        before: null,
+        after: attendees.join(", "),
+        changeType: "add"
+      });
+    }
+    results.push({
+      key: "calendar_id",
+      label: "Calendar",
+      before: null,
+      after: calendarId,
+      changeType: "add"
+    });
+    const description = String(inputs.description || "").trim();
+    if (description) {
+      results.push({
+        key: "description",
+        label: "Description",
+        before: null,
+        after: description.length > 120 ? description.slice(0, 117) + "..." : description,
+        changeType: "add"
+      });
+    }
+    return results;
+  }
+});
+
+// src/core/lib/actionRegistry/actions/calendar/eventUpdate.diff.ts
+registerDiffResolver("qi/calendar.event.update", {
+  resolver: async (inputs, ctx) => {
+    const connection = inputs.connection || {};
+    const connectedAccountId = connection.connectedAccountId;
+    const eventId = String(inputs.event_id || "").trim();
+    const calendarId = String(inputs.calendar_id || "").trim() || "primary";
+    let before = null;
+    if (connectedAccountId && eventId && ctx.handlers?.integrations?.fetchCurrentState) {
+      try {
+        const current = await ctx.handlers.integrations.fetchCurrentState({
+          toolSlug: CALENDAR_EVENT_GET_SLUG,
+          connectedAccountId,
+          arguments: { event_id: eventId, calendar_id: calendarId }
+        });
+        before = current?.data || current || null;
+      } catch {
+        before = null;
+      }
+    }
+    const results = [];
+    const afterSummary = String(inputs.summary || "").trim();
+    results.push({
+      key: "summary",
+      label: "Title",
+      before: before?.summary ?? null,
+      after: afterSummary || null,
+      changeType: diffChange(before?.summary, afterSummary)
+    });
+    const afterStart = String(inputs.start_datetime || "").trim();
+    const beforeStart = before?.start?.dateTime || before?.start?.date || null;
+    results.push({
+      key: "start_datetime",
+      label: "Start",
+      before: beforeStart,
+      after: afterStart || null,
+      changeType: diffChange(beforeStart, afterStart)
+    });
+    const afterEnd = String(inputs.end_datetime || "").trim();
+    const beforeEnd = before?.end?.dateTime || before?.end?.date || null;
+    if (afterEnd || beforeEnd) {
+      results.push({
+        key: "end_datetime",
+        label: "End",
+        before: beforeEnd,
+        after: afterEnd || null,
+        changeType: diffChange(beforeEnd, afterEnd)
+      });
+    }
+    const afterLocation = String(inputs.location || "").trim();
+    if (afterLocation || before?.location) {
+      results.push({
+        key: "location",
+        label: "Location",
+        before: before?.location ?? null,
+        after: afterLocation || null,
+        changeType: diffChange(before?.location, afterLocation)
+      });
+    }
+    const afterAttendees = parseAttendeesField(String(inputs.attendees || ""));
+    const beforeAttendees = Array.isArray(before?.attendees) ? before.attendees.map((a) => a?.email).filter(Boolean) : [];
+    if (afterAttendees.length > 0 || beforeAttendees.length > 0) {
+      const beforeStr = beforeAttendees.join(", ");
+      const afterStr = afterAttendees.join(", ");
+      results.push({
+        key: "attendees",
+        label: "Attendees",
+        before: beforeStr || null,
+        after: afterStr || null,
+        changeType: diffChange(beforeStr, afterStr)
+      });
+    }
+    const afterDescription = String(inputs.description || "").trim();
+    if (afterDescription || before?.description) {
+      const clip = (s) => s && s.length > 120 ? s.slice(0, 117) + "..." : s ?? null;
+      results.push({
+        key: "description",
+        label: "Description",
+        before: clip(before?.description),
+        after: clip(afterDescription) ?? null,
+        changeType: diffChange(before?.description, afterDescription)
+      });
+    }
+    return results;
+  }
+});
+function diffChange(beforeVal, afterVal) {
+  const b = beforeVal === void 0 || beforeVal === null ? "" : String(beforeVal).trim();
+  const a = afterVal === void 0 || afterVal === null ? "" : String(afterVal).trim();
+  if (b === a) return "unchanged";
+  if (!b && a) return "add";
+  if (b && !a) return "remove";
+  return "replace";
+}
+
+// src/core/lib/actionRegistry/actions/xero/contactCreate.diff.ts
+registerDiffResolver("qi/xero.contact.create", {
+  resolver: async (inputs, _ctx) => {
+    const results = [
+      {
+        key: "Name",
+        label: "Name",
+        before: null,
+        after: String(inputs.Name || "").trim() || "(required)",
+        changeType: "add"
+      }
+    ];
+    const fields = [
+      ["EmailAddress", "Email"],
+      ["phone_number", "Phone"],
+      ["mobile_number", "Mobile"],
+      ["Website", "Website"],
+      ["TaxNumber", "Tax number"],
+      ["AccountNumber", "Account number"],
+      ["DefaultCurrency", "Default currency"]
+    ];
+    for (const [key, label] of fields) {
+      const v = String(inputs[key] || "").trim();
+      if (v) {
+        results.push({ key: String(key), label, before: null, after: v, changeType: "add" });
+      }
+    }
+    const roles = [];
+    if (inputs.IsCustomer) roles.push("Customer");
+    if (inputs.IsSupplier) roles.push("Supplier");
+    if (roles.length > 0) {
+      results.push({ key: "role", label: "Role", before: null, after: roles.join(" + "), changeType: "add" });
+    }
+    if (inputs.tenant_id) {
+      results.push({ key: "tenant_id", label: "Xero org", before: null, after: String(inputs.tenant_id), changeType: "add" });
+    }
+    return results;
+  }
+});
+
+// src/core/lib/actionRegistry/actions/xero/invoiceCreate.diff.ts
+registerDiffResolver("qi/xero.invoice.create", {
+  resolver: async (inputs, _ctx) => {
+    const results = [
+      {
+        key: "Type",
+        label: "Type",
+        before: null,
+        after: String(inputs.Type || "ACCREC").toUpperCase() === "ACCPAY" ? "ACCPAY (bill)" : "ACCREC (sale)",
+        changeType: "add"
+      },
+      {
+        key: "Status",
+        label: "Status",
+        before: null,
+        after: String(inputs.Status || "DRAFT"),
+        changeType: "add"
+      }
+    ];
+    const contact = String(inputs.ContactID || "").trim() || String(inputs.ContactName || "").trim();
+    if (contact) {
+      results.push({
+        key: "Contact",
+        label: "Contact",
+        before: null,
+        after: contact,
+        changeType: "add"
+      });
+    }
+    let lineItemSummary = "(required)";
+    let totalAmount = 0;
+    const lineItems = inputs.LineItems;
+    if (lineItems && typeof lineItems === "object") {
+      if (lineItems.mode === "manual" && Array.isArray(lineItems.rows)) {
+        lineItemSummary = `${lineItems.rows.length} item${lineItems.rows.length === 1 ? "" : "s"}`;
+        totalAmount = lineItems.rows.reduce((sum, row) => {
+          const qty = Number(row?.Quantity) || 0;
+          const price = Number(row?.UnitAmount) || 0;
+          return sum + qty * price;
+        }, 0);
+      } else if (lineItems.mode === "iterative") {
+        lineItemSummary = lineItems.source ? `per item from ${String(lineItems.source).slice(0, 80)}` : "(source not picked)";
+      }
+    }
+    results.push({
+      key: "LineItems",
+      label: "Line items",
+      before: null,
+      after: lineItemSummary,
+      changeType: "add"
+    });
+    if (totalAmount > 0) {
+      const currency = String(inputs.CurrencyCode || "").trim();
+      results.push({
+        key: "Total",
+        label: "Total (est.)",
+        before: null,
+        after: currency ? `${totalAmount.toFixed(2)} ${currency}` : totalAmount.toFixed(2),
+        changeType: "add"
+      });
+    }
+    if (inputs.DueDate) {
+      results.push({ key: "DueDate", label: "Due", before: null, after: String(inputs.DueDate), changeType: "add" });
+    }
+    if (inputs.Reference) {
+      results.push({ key: "Reference", label: "Reference", before: null, after: String(inputs.Reference), changeType: "add" });
+    }
+    if (inputs.tenant_id) {
+      results.push({ key: "tenant_id", label: "Xero org", before: null, after: String(inputs.tenant_id), changeType: "add" });
+    }
+    return results;
+  }
+});
+
+// src/core/lib/actionRegistry/actions/xero/paymentCreate.diff.ts
+registerDiffResolver("qi/xero.payment.create", {
+  resolver: async (inputs, _ctx) => {
+    const results = [];
+    const invoiceId = String(inputs.InvoiceID || "").trim();
+    if (invoiceId) {
+      results.push({
+        key: "InvoiceID",
+        label: "Invoice",
+        before: null,
+        after: invoiceId,
+        changeType: "add"
+      });
+    }
+    const accountId = String(inputs.AccountID || "").trim();
+    if (accountId) {
+      results.push({
+        key: "AccountID",
+        label: "Bank account",
+        before: null,
+        after: accountId,
+        changeType: "add"
+      });
+    }
+    const amountRaw = String(inputs.Amount ?? "").trim();
+    if (amountRaw) {
+      const n = Number(amountRaw);
+      results.push({
+        key: "Amount",
+        label: "Amount",
+        before: null,
+        after: Number.isFinite(n) ? n.toFixed(2) : amountRaw,
+        changeType: "add"
+      });
+    }
+    if (inputs.Date) {
+      results.push({ key: "Date", label: "Date", before: null, after: String(inputs.Date), changeType: "add" });
+    }
+    if (inputs.Reference) {
+      results.push({ key: "Reference", label: "Reference (tx hash)", before: null, after: String(inputs.Reference), changeType: "add" });
+    }
+    if (inputs.tenant_id) {
+      results.push({ key: "tenant_id", label: "Xero org", before: null, after: String(inputs.tenant_id), changeType: "add" });
+    }
+    return results;
+  }
+});
+
 // src/core/lib/actionRegistry/actions/walletFund.diff.ts
 registerDiffResolver("qi/wallet.fund", {
   resolver: async (inputs, _ctx) => {
@@ -5519,7 +6732,7 @@ function compileBaseUcanFlow(plan, registry) {
       if (!source) {
         throw new Error(`Trigger on block "${nodeId}" references unknown source block "${sourceId}".`);
       }
-      const declaredEvents = source.action.events || [];
+      const declaredEvents = getEventsForBlock(source.action, source.cap.nb);
       if (declaredEvents.length === 0) {
         throw new Error(`Trigger on block "${nodeId}" references event "${eventName}" but source action "${source.action.type}" declares no events.`);
       }
@@ -5553,7 +6766,7 @@ function compileBaseUcanFlow(plan, registry) {
         if (!sourceEntry) {
           throw new Error(`Barrier trigger on block "${nodeId}" references unknown source block "${srcId}".`);
         }
-        const declaredEvents = sourceEntry.action.events || [];
+        const declaredEvents = getEventsForBlock(sourceEntry.action, sourceEntry.cap.nb);
         const found = declaredEvents.find((e) => e.name === evtName);
         if (!found) {
           const declared = declaredEvents.map((e) => e.name).join(", ");
@@ -6308,12 +7521,15 @@ export {
   getAllActions,
   hasAction,
   getActionByCan,
+  getEventsForBlock,
+  getOutputSchemaForBlock,
   canToType,
   typeToCan,
   getAllCanMappings,
   buildServicesFromHandlers,
   getDiffResolver,
   hasDiffResolver,
+  extractSurveyAnswerSchema,
   transformSurveyToCredentialSubject,
   buildVerifiableCredential,
   buildDomainCardLinkedResource,
@@ -6326,6 +7542,9 @@ export {
   didToMatrixUserId,
   findOrCreateDMRoom,
   sendDirectMessage,
+  parseCalendarEventCreateInputs,
+  serializeCalendarEventCreateInputs,
+  parseAttendeesField,
   createUcanService,
   createUcanDelegationStore,
   createMemoryUcanDelegationStore,
@@ -6365,4 +7584,4 @@ export {
   readFlow,
   setupFlowFromBaseUcan
 };
-//# sourceMappingURL=chunk-GSW6ADEY.mjs.map
+//# sourceMappingURL=chunk-OO42QPEG.mjs.map