@ixo/editor 5.25.0 → 5.26.0

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

@@ -206,6 +206,32 @@ function buildServicesFromHandlers(handlers) {
     matrix: handlers?.storeMatrixCredential ? {
       storeCredential: async (params) => handlers.storeMatrixCredential(params)
     } : void 0,
+    // Claim-collection lifecycle service (IXO-2573/2579). The consumer exposes
+    // a fully-formed `handlers.collection` service group (get + create + the
+    // five updates); wire each method straight through. The core run()
+    // dispatcher resolves admin from the on-chain collection.admin and
+    // re-fetches via `get` after every write, so we only forward calls here.
+    collection: handlers?.collection?.get && handlers?.collection?.create && handlers?.collection?.updateState && handlers?.collection?.updateDates && handlers?.collection?.updateQuota && handlers?.collection?.updatePayments && handlers?.collection?.updateIntents ? {
+      get: async (params) => handlers.collection.get(params),
+      create: async (params) => handlers.collection.create(params),
+      updateState: async (params) => handlers.collection.updateState(params),
+      updateDates: async (params) => handlers.collection.updateDates(params),
+      updateQuota: async (params) => handlers.collection.updateQuota(params),
+      updatePayments: async (params) => handlers.collection.updatePayments(params),
+      updateIntents: async (params) => handlers.collection.updateIntents(params)
+    } : void 0,
+    // Claim-collection user-management service (IXO-2586). The consumer exposes a
+    // fully-formed `handlers.collectionUsers` service group (grant + revoke +
+    // list + classifyAddress + enumerateMembers); wire each method straight
+    // through. The core run() dispatcher validates inputs and proof-guards the
+    // results, so we only forward calls here.
+    collectionUsers: handlers?.collectionUsers?.grant && handlers?.collectionUsers?.revoke && handlers?.collectionUsers?.list && handlers?.collectionUsers?.classifyAddress && handlers?.collectionUsers?.enumerateMembers ? {
+      grant: async (params) => handlers.collectionUsers.grant(params),
+      revoke: async (params) => handlers.collectionUsers.revoke(params),
+      list: async (params) => handlers.collectionUsers.list(params),
+      classifyAddress: async (params) => handlers.collectionUsers.classifyAddress(params),
+      enumerateMembers: async (params) => handlers.collectionUsers.enumerateMembers(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,
@@ -4866,6 +4892,350 @@ registerAction({
   }
 });
 
+// src/core/lib/actionRegistry/actions/collection/index.ts
+var COLLECTION_LIFECYCLE_ACTION_TYPE = "qi/collection.lifecycle";
+var COLLECTION_LIFECYCLE_OUTPUT_SCHEMA = [
+  { path: "collectionId", displayName: "Collection ID", type: "string", description: "Chain-assigned collection identifier" },
+  { path: "entity", displayName: "Entity DID", type: "string", description: "Entity (deed) DID the collection belongs to" },
+  { path: "protocol", displayName: "Protocol", type: "string", description: "Protocol DID/id the collection follows" },
+  { path: "admin", displayName: "Admin Address", type: "string", description: "Address authorised to mutate the collection" },
+  { path: "state", displayName: "State", type: "number", description: "Lifecycle state (0=OPEN, 1=PAUSED, 2=CLOSED)" },
+  { path: "startDate", displayName: "Start Date", type: "string", description: "ISO-8601 start date" },
+  { path: "endDate", displayName: "End Date", type: "string", description: "ISO-8601 end date" },
+  { path: "quota", displayName: "Quota", type: "string", description: "Max claims; 0 = unlimited" },
+  { path: "count", displayName: "Count", type: "string", description: "Number of claims submitted" },
+  { path: "evaluated", displayName: "Evaluated", type: "string", description: "Number of claims evaluated" },
+  { path: "approved", displayName: "Approved", type: "string", description: "Number of approved claims" },
+  { path: "rejected", displayName: "Rejected", type: "string", description: "Number of rejected claims" },
+  { path: "disputed", displayName: "Disputed", type: "string", description: "Number of disputed claims" },
+  { path: "payments", displayName: "Payments", type: "object", description: "Payment legs (submission/evaluation/approval/rejection)" },
+  { path: "intents", displayName: "Intents", type: "object", description: "Intent configuration" }
+];
+var COLLECTION_CREATED_EVENT_NAME = "created";
+var COLLECTION_CREATED_EVENT = {
+  name: COLLECTION_CREATED_EVENT_NAME,
+  displayName: "Collection created",
+  description: "Fires once when a new claim collection is created on-chain. Carries the collection id, entity (deed) DID and protocol so a listener can manage the new collection.",
+  payloadSchema: [
+    { path: "collectionId", displayName: "Collection ID", type: "string", description: "Chain-assigned collection identifier" },
+    { path: "entity", displayName: "Entity DID", type: "string", description: "Entity (deed) DID the collection belongs to" },
+    { path: "protocol", displayName: "Protocol", type: "string", description: "Protocol DID/id the collection follows" },
+    { path: "transactionHash", displayName: "Tx Hash", type: "string", description: "MsgCreateCollection broadcast transaction hash" }
+  ],
+  pendingDisplayFields: ["collectionId", "entity"]
+};
+
+// src/core/lib/actionRegistry/types.ts
+var CollectionStateEnum = /* @__PURE__ */ ((CollectionStateEnum2) => {
+  CollectionStateEnum2[CollectionStateEnum2["OPEN"] = 0] = "OPEN";
+  CollectionStateEnum2[CollectionStateEnum2["PAUSED"] = 1] = "PAUSED";
+  CollectionStateEnum2[CollectionStateEnum2["CLOSED"] = 2] = "CLOSED";
+  return CollectionStateEnum2;
+})(CollectionStateEnum || {});
+
+// src/core/lib/actionRegistry/actions/collection/collection.ts
+function normalizeQuota(quota) {
+  if (quota === void 0 || quota === null) return void 0;
+  const trimmed = String(quota).trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function assertQuotaNotBelowCount(quota, count) {
+  if (quota === "0") return;
+  const quotaNum = Number(quota);
+  const countNum = Number(count);
+  if (!Number.isFinite(quotaNum) || quotaNum < 0) {
+    throw new Error(`Invalid quota "${quota}". Quota must be a non-negative integer string ("0" = unlimited).`);
+  }
+  if (Number.isFinite(countNum) && quotaNum < countNum) {
+    throw new Error(`Quota ${quota} is below the current submitted count ${count} (ErrCollectionQuotaBelowCount). Quota must be 0 (unlimited) or >= ${count}.`);
+  }
+}
+function assertNonEmptyCollection(state, collectionId) {
+  if (!state || !String(state.collectionId || "").trim()) {
+    throw new Error(
+      `Collection read-back returned empty state for collectionId "${collectionId}". Broadcast may have succeeded but chain state is not yet readable \u2014 retry via refresh.`
+    );
+  }
+}
+registerAction({
+  type: COLLECTION_LIFECYCLE_ACTION_TYPE,
+  can: "collection/lifecycle",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  outputSchema: COLLECTION_LIFECYCLE_OUTPUT_SCHEMA,
+  getDynamicOutputSchema: () => COLLECTION_LIFECYCLE_OUTPUT_SCHEMA,
+  // Static vocabulary (used by the pending-invocation preview / compiler).
+  events: [COLLECTION_CREATED_EVENT],
+  // Only a CREATE entry point (no bound collectionId) can emit `created`, so a
+  // manage-mode block bound to an existing collection is hidden from the
+  // trigger picker as a source (IXO-2595).
+  getDynamicEvents: (inputs) => String(inputs?.collectionId || "").trim() ? [] : [COLLECTION_CREATED_EVENT],
+  run: async (inputs, ctx) => {
+    const service = ctx.services.collection;
+    if (!service) {
+      throw new Error("collection service not configured (ctx.services.collection is undefined)");
+    }
+    const operation = inputs.operation;
+    if (!operation) {
+      throw new Error("operation is required (create | updateState | updateDates | updateQuota | updatePayments | updateIntents | refresh)");
+    }
+    if (operation === "create") {
+      const entity = String(inputs.entity || "").trim();
+      const protocol = String(inputs.protocol || "").trim();
+      if (!entity) throw new Error("create: entity is required");
+      if (!protocol) throw new Error("create: protocol is required");
+      if (!protocol.startsWith("did:") || protocol.includes("#")) {
+        throw new Error(
+          `create: protocol "${protocol}" is not a valid DID. The selected claim protocol did not resolve to a ledgered did:ixo: identifier (it may be an unresolved template reference). Re-pick the protocol from the entity's linked claims.`
+        );
+      }
+      const quota = normalizeQuota(inputs.quota);
+      const createParams = {
+        entity,
+        protocol,
+        state: inputs.state,
+        startDate: inputs.startDate,
+        endDate: inputs.endDate,
+        quota,
+        payments: inputs.payments,
+        intents: inputs.intents
+      };
+      const result = await service.create(createParams);
+      const transactionHash2 = String(result?.transactionHash || "").trim();
+      const collectionId2 = String(result?.collectionId || "").trim();
+      if (!transactionHash2) {
+        throw new Error("create: service returned no transactionHash. Collection was not created.");
+      }
+      if (!collectionId2) {
+        throw new Error("create: service returned no collectionId. Cannot read back collection state.");
+      }
+      const state = await service.get({ collectionId: collectionId2 });
+      assertNonEmptyCollection(state, collectionId2);
+      return {
+        output: state,
+        events: [
+          {
+            name: COLLECTION_CREATED_EVENT_NAME,
+            payload: {
+              collectionId: String(state.collectionId || collectionId2),
+              entity: String(state.entity || entity),
+              protocol: String(state.protocol || protocol),
+              transactionHash: transactionHash2
+            }
+          }
+        ]
+      };
+    }
+    if (operation === "refresh") {
+      const collectionId2 = String(inputs.collectionId || "").trim();
+      if (!collectionId2) throw new Error("refresh: collectionId is required");
+      const state = await service.get({ collectionId: collectionId2 });
+      assertNonEmptyCollection(state, collectionId2);
+      return { output: state };
+    }
+    const writeOp = operation;
+    const collectionId = String(inputs.collectionId || "").trim();
+    if (!collectionId) throw new Error(`${writeOp}: collectionId is required`);
+    const current = await service.get({ collectionId });
+    assertNonEmptyCollection(current, collectionId);
+    const adminAddress = String(current.admin || "").trim();
+    if (!adminAddress) {
+      throw new Error(`${writeOp}: could not resolve admin address for collection "${collectionId}" (chain state has no admin). Cannot authorise the update.`);
+    }
+    let transactionHash = "";
+    switch (writeOp) {
+      case "updateState": {
+        const state = inputs.state;
+        if (state === void 0 || state === null) {
+          throw new Error("updateState: state is required (0=OPEN, 1=PAUSED, 2=CLOSED)");
+        }
+        if (!(state in CollectionStateEnum) || typeof state !== "number") {
+          throw new Error(`updateState: invalid state "${String(state)}". Expected 0 (OPEN), 1 (PAUSED) or 2 (CLOSED).`);
+        }
+        const res = await service.updateState({ collectionId, state, adminAddress });
+        transactionHash = String(res?.transactionHash || "").trim();
+        break;
+      }
+      case "updateDates": {
+        const startDate = inputs.startDate;
+        const endDate = inputs.endDate;
+        if (!startDate && !endDate) {
+          throw new Error("updateDates: at least one of startDate or endDate is required");
+        }
+        const res = await service.updateDates({ collectionId, startDate, endDate, adminAddress });
+        transactionHash = String(res?.transactionHash || "").trim();
+        break;
+      }
+      case "updateQuota": {
+        const quota = normalizeQuota(inputs.quota);
+        if (quota === void 0) {
+          throw new Error('updateQuota: quota is required ("0" = unlimited)');
+        }
+        assertQuotaNotBelowCount(quota, String(current.count || "0"));
+        const res = await service.updateQuota({ collectionId, quota, adminAddress });
+        transactionHash = String(res?.transactionHash || "").trim();
+        break;
+      }
+      case "updatePayments": {
+        const payments = inputs.payments;
+        if (!payments || typeof payments !== "object") {
+          throw new Error("updatePayments: payments is required");
+        }
+        const res = await service.updatePayments({ collectionId, payments, adminAddress });
+        transactionHash = String(res?.transactionHash || "").trim();
+        break;
+      }
+      case "updateIntents": {
+        const intents = inputs.intents;
+        if (!intents || typeof intents !== "object") {
+          throw new Error("updateIntents: intents is required");
+        }
+        const res = await service.updateIntents({ collectionId, intents, adminAddress });
+        transactionHash = String(res?.transactionHash || "").trim();
+        break;
+      }
+      default: {
+        const _exhaustive = writeOp;
+        throw new Error(`Unsupported collection operation: ${String(_exhaustive)}`);
+      }
+    }
+    if (!transactionHash) {
+      throw new Error(`${writeOp}: service returned no transactionHash. The update was not broadcast.`);
+    }
+    const updated = await service.get({ collectionId });
+    assertNonEmptyCollection(updated, collectionId);
+    return { output: updated };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/collectionUsers/index.ts
+var COLLECTION_USERS_ACTION_TYPE = "qi/collection.users";
+var COLLECTION_USERS_OUTPUT_SCHEMA = [
+  { path: "transactionHash", displayName: "Tx Hash", type: "string", description: "Broadcast transaction hash (add/revoke)" },
+  { path: "grantedCount", displayName: "Granted Count", type: "number", description: "Number of grants broadcast (fan-out)" },
+  { path: "role", displayName: "Role", type: "string", description: "submit or evaluate" },
+  { path: "collectionId", displayName: "Collection ID", type: "string", description: "Target claim collection identifier" },
+  { path: "granteeAddress", displayName: "Grantee Address", type: "string", description: "Address granted/revoked" },
+  {
+    path: "grantees",
+    displayName: "Grantees",
+    type: "array",
+    description: "Grantees holding a constraint for the collection (list)",
+    itemSchema: [
+      { path: "address", displayName: "Address", type: "string" },
+      { path: "role", displayName: "Role", type: "string" },
+      { path: "agentQuota", displayName: "Agent Quota", type: "string" },
+      { path: "intentDurationNs", displayName: "Intent Duration (ns)", type: "string" }
+    ]
+  }
+];
+
+// src/core/lib/actionRegistry/actions/collectionUsers/collectionUsers.ts
+function normalizeRole(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === "submit" || normalized === "evaluate") return normalized;
+  throw new Error('role must be either "submit" or "evaluate"');
+}
+registerAction({
+  type: COLLECTION_USERS_ACTION_TYPE,
+  can: "collection/users",
+  sideEffect: true,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  outputSchema: COLLECTION_USERS_OUTPUT_SCHEMA,
+  getDynamicOutputSchema: () => COLLECTION_USERS_OUTPUT_SCHEMA,
+  // Can be wired to a `block.event` trigger (IXO-2596) — e.g. listen for the
+  // `created` event from a Claim Collection block and manage the new
+  // collection's users. When invoked from a pending invocation, `collectionId`
+  // arrives via the event payload (merged into inputs by name); the FlowDetail
+  // resolves the entity admin account from the payload `entity` and passes it
+  // as `adminAddress`.
+  eligibleForEventTrigger: true,
+  run: async (inputs, ctx) => {
+    const service = ctx.services.collectionUsers;
+    if (!service) {
+      throw new Error("collectionUsers service not configured (ctx.services.collectionUsers is undefined)");
+    }
+    const operation = inputs.operation;
+    if (!operation) {
+      throw new Error("operation is required (add | revoke | list)");
+    }
+    const collectionId = String(inputs.collectionId || "").trim();
+    const adminAddress = String(inputs.adminAddress || "").trim();
+    if (operation === "list") {
+      if (!collectionId) throw new Error("list: collectionId is required");
+      if (!adminAddress) throw new Error("list: adminAddress (entity admin account) is required");
+      const result2 = await service.list({ granterAdminAddress: adminAddress, collectionId });
+      const grantees = Array.isArray(result2?.grantees) ? result2.grantees : void 0;
+      if (!grantees) {
+        throw new Error("list: service returned no grantees array. Check the [collection:list] handler logs.");
+      }
+      return { output: { grantees, collectionId } };
+    }
+    if (!collectionId) throw new Error(`${operation}: collectionId is required`);
+    if (!adminAddress) throw new Error(`${operation}: adminAddress (entity admin account) is required`);
+    const role = normalizeRole(inputs.role);
+    const deedDid = String(inputs.deedDid || "").trim() || void 0;
+    if (operation === "revoke") {
+      const granteeAddress2 = String(inputs.granteeAddress || "").trim();
+      if (!granteeAddress2) throw new Error("revoke: granteeAddress is required");
+      const result2 = await service.revoke({ granterAdminAddress: adminAddress, granteeAddress: granteeAddress2, collectionId, role });
+      const transactionHash2 = String(result2?.transactionHash || "").trim();
+      if (!transactionHash2) {
+        throw new Error("revoke: service returned no transactionHash. The revoke was not broadcast.");
+      }
+      return { output: { transactionHash: transactionHash2, role, collectionId, granteeAddress: granteeAddress2 } };
+    }
+    const granteeKind = inputs.granteeKind || "user";
+    const agentQuota = inputs.agentQuota !== void 0 && inputs.agentQuota !== null ? String(inputs.agentQuota).trim() || void 0 : void 0;
+    const maxAmount = Array.isArray(inputs.maxAmount) ? inputs.maxAmount : void 0;
+    const intentDurationNs = String(inputs.intentDurationNs || "").trim() || void 0;
+    if (granteeKind === "group-members") {
+      const members = Array.isArray(inputs.members) ? inputs.members.filter((m) => !!String(m?.address || "").trim()) : [];
+      if (members.length === 0) {
+        throw new Error("add (group-members): no members resolved to grant to. Enumerate the group members before signing.");
+      }
+      const transactionHashes = [];
+      for (const member of members) {
+        const granteeAddress2 = String(member.address).trim();
+        const res = await service.grant({ granterAdminAddress: adminAddress, granteeAddress: granteeAddress2, collectionId, role, agentQuota, maxAmount, intentDurationNs, deedDid });
+        const hash = String(res?.transactionHash || "").trim();
+        if (!hash) {
+          throw new Error(`add (group-members): grant to ${granteeAddress2} returned no transactionHash. ${transactionHashes.length} of ${members.length} grants completed.`);
+        }
+        transactionHashes.push(hash);
+      }
+      return {
+        output: {
+          transactionHash: transactionHashes[transactionHashes.length - 1],
+          transactionHashes,
+          grantedCount: transactionHashes.length,
+          role,
+          collectionId
+        }
+      };
+    }
+    const granteeAddress = String(inputs.granteeAddress || "").trim();
+    if (!granteeAddress) throw new Error("add: granteeAddress is required");
+    const result = await service.grant({ granterAdminAddress: adminAddress, granteeAddress, collectionId, role, agentQuota, maxAmount, intentDurationNs, deedDid });
+    const transactionHash = String(result?.transactionHash || "").trim();
+    if (!transactionHash) {
+      throw new Error("add: service returned no transactionHash. The grant was not broadcast.");
+    }
+    return {
+      output: {
+        transactionHash,
+        transactionHashes: [transactionHash],
+        grantedCount: 1,
+        role,
+        collectionId,
+        granteeAddress
+      }
+    };
+  }
+});
+
 // src/core/lib/actionRegistry/actions/calendar/eventCreate.types.ts
 var EMPTY = {
   connection: null,
@@ -5494,7 +5864,7 @@ registerDiffResolver("bid", {
     if (!inputs.surveyStarted) return [];
     const collectionId = String(inputs.collectionId || "").trim();
     const role = String(inputs.role || "").trim();
-    const roleLabel = role === "evaluation_agent" || role === "ea" ? "Evaluator" : role ? "Contributor" : "Selected at runtime";
+    const roleLabel2 = role === "evaluation_agent" || role === "ea" ? "Evaluator" : role ? "Contributor" : "Selected at runtime";
     return [
       {
         key: "applicationStatus",
@@ -5508,7 +5878,7 @@ registerDiffResolver("bid", {
         key: "role",
         label: "Role",
         before: "None",
-        after: roleLabel,
+        after: roleLabel2,
         changeType: role ? "replace" : "unchanged"
       },
       {
@@ -5545,7 +5915,7 @@ registerDiffResolver("evaluateBid", {
     const applicantDid = String(inputs.applicantDid || "").trim();
     const roleLower = role.toLowerCase();
     const isEvaluator = roleLower === "evaluation_agent" || roleLower === "ea";
-    const roleLabel = isEvaluator ? "Evaluator" : roleLower === "service_agent" || roleLower === "sa" ? "Contributor" : role || "Unknown";
+    const roleLabel2 = isEvaluator ? "Evaluator" : roleLower === "service_agent" || roleLower === "sa" ? "Contributor" : role || "Unknown";
     const isApprove = decision === "approve";
     const isReject = decision === "reject";
     const decisionLabel = isApprove ? "Approve" : isReject ? "Reject" : "Not selected";
@@ -5569,8 +5939,8 @@ registerDiffResolver("evaluateBid", {
       {
         key: "applicantRole",
         label: "Applicant Role",
-        before: roleLabel,
-        after: roleLabel,
+        before: roleLabel2,
+        after: roleLabel2,
         changeType: "unchanged"
       },
       {
@@ -6178,6 +6548,367 @@ registerDiffResolver("qi/wallet.fund", {
   }
 });
 
+// src/core/lib/actionRegistry/actions/collection/collection.diff.ts
+var STATE_LABELS = {
+  [0 /* OPEN */]: "Open",
+  [1 /* PAUSED */]: "Paused",
+  [2 /* CLOSED */]: "Closed"
+};
+function stateLabel(value) {
+  if (value === void 0 || value === null || value === "") return null;
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return null;
+  return STATE_LABELS[n] ?? `Unknown (${n})`;
+}
+function readCurrentState(inputs) {
+  const candidate = inputs?.currentState ?? inputs?.__currentState ?? inputs?.__currentOutput ?? inputs?.currentOutput ?? inputs?.output ?? void 0;
+  if (candidate && typeof candidate === "object") return candidate;
+  return {};
+}
+function formatQuota(value) {
+  if (value === void 0 || value === null || value === "") return "Unlimited";
+  const s = String(value).trim();
+  if (s === "" || s === "0") return "Unlimited";
+  return s;
+}
+function toNumberOrNull(value) {
+  if (value === void 0 || value === null || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function formatDate(value) {
+  if (value === void 0 || value === null || value === "") return "Not set";
+  return String(value);
+}
+var USDC_IBC_DENOM = "ibc/6BBE9BD4246F8E04948D5A4EEE7164B2630263B9EBB5E7DC5F0A46C62A2FF97B";
+function formatCoin3(amount, denom) {
+  const rawAmount = amount ?? "?";
+  if (denom === "uixo") {
+    const n = Number(rawAmount);
+    return `${Number.isFinite(n) ? n / 1e6 : rawAmount} IXO`;
+  }
+  if (denom === USDC_IBC_DENOM || (denom ?? "").startsWith("ibc/")) {
+    const n = Number(rawAmount);
+    return `${Number.isFinite(n) ? n / 1e6 : rawAmount} USDC`;
+  }
+  return `${rawAmount} ${denom ?? ""}`.trim();
+}
+function summarisePaymentLeg(leg) {
+  if (!leg || typeof leg !== "object") return "None";
+  const parts = [];
+  const coins = Array.isArray(leg.amount) ? leg.amount : [];
+  if (coins.length > 0) {
+    parts.push(coins.map((c) => formatCoin3(c?.amount, c?.denom)).join(", "));
+  }
+  if (Array.isArray(leg.cw20Payment) && leg.cw20Payment.length > 0) {
+    parts.push(`${leg.cw20Payment.length} CW20`);
+  }
+  if (leg.contract_1155Payment) {
+    parts.push("1155");
+  }
+  if (leg.account) {
+    parts.push(`\u2192 ${leg.account}`);
+  }
+  if (leg.isOraclePayment) {
+    parts.push("(oracle)");
+  }
+  return parts.length > 0 ? parts.join(" ") : "None";
+}
+function summarisePayments(payments) {
+  const p = payments && typeof payments === "object" ? payments : {};
+  return {
+    submission: summarisePaymentLeg(p.submission),
+    evaluation: summarisePaymentLeg(p.evaluation),
+    approval: summarisePaymentLeg(p.approval),
+    rejection: summarisePaymentLeg(p.rejection)
+  };
+}
+function summariseIntents(intents) {
+  const i = intents && typeof intents === "object" ? intents : {};
+  return {
+    allowed: i.allowed === void 0 ? "Not set" : i.allowed ? "Allowed" : "Disallowed",
+    timeout: i.timeoutNs ? String(i.timeoutNs) : "Not set",
+    payment: summarisePaymentLeg(i.payment)
+  };
+}
+function changeFor(before, after) {
+  if (before === after) return "unchanged";
+  if (before === null || before === void 0 || before === "") return "add";
+  if (after === null || after === void 0 || after === "") return "remove";
+  if (typeof before === "number" && typeof after === "number") {
+    if (after > before) return "increase";
+    if (after < before) return "decrease";
+  }
+  return "replace";
+}
+function diffCreate(inputs) {
+  const results = [];
+  if (inputs.entity) {
+    results.push({ key: "entity", label: "Entity", before: null, after: String(inputs.entity), changeType: "add" });
+  }
+  if (inputs.protocol) {
+    results.push({ key: "protocol", label: "Protocol", before: null, after: String(inputs.protocol), changeType: "add" });
+  }
+  results.push({
+    key: "state",
+    label: "State",
+    before: null,
+    after: stateLabel(inputs.state) ?? STATE_LABELS[0 /* OPEN */],
+    changeType: "add"
+  });
+  results.push({
+    key: "startDate",
+    label: "Start Date",
+    before: null,
+    after: inputs.startDate ? String(inputs.startDate) : "Not set",
+    changeType: inputs.startDate ? "add" : "unchanged"
+  });
+  results.push({
+    key: "endDate",
+    label: "End Date",
+    before: null,
+    after: inputs.endDate ? String(inputs.endDate) : "Not set",
+    changeType: inputs.endDate ? "add" : "unchanged"
+  });
+  results.push({
+    key: "quota",
+    label: "Quota",
+    before: null,
+    after: formatQuota(inputs.quota),
+    changeType: "add",
+    severity: "warning",
+    unit: formatQuota(inputs.quota) === "Unlimited" ? void 0 : "claims"
+  });
+  if (inputs.payments) {
+    const after = summarisePayments(inputs.payments);
+    ["submission", "evaluation", "approval", "rejection"].forEach((leg) => {
+      if (after[leg] !== "None") {
+        results.push({
+          key: `payments.${leg}`,
+          label: `Payment \u2014 ${leg.charAt(0).toUpperCase()}${leg.slice(1)}`,
+          before: null,
+          after: after[leg],
+          changeType: "add"
+        });
+      }
+    });
+  }
+  if (inputs.intents) {
+    const after = summariseIntents(inputs.intents);
+    results.push({ key: "intents.allowed", label: "Intents \u2014 Allowed", before: null, after: after.allowed, changeType: "add" });
+    if (after.timeout !== "Not set") {
+      results.push({ key: "intents.timeout", label: "Intents \u2014 Timeout (ns)", before: null, after: after.timeout, changeType: "add" });
+    }
+    if (after.payment !== "None") {
+      results.push({ key: "intents.payment", label: "Intents \u2014 Payment", before: null, after: after.payment, changeType: "add" });
+    }
+  }
+  return results;
+}
+function diffUpdateState(inputs, current) {
+  const before = stateLabel(current.state);
+  const after = stateLabel(inputs.state);
+  return [
+    {
+      key: "state",
+      label: "State",
+      before: before ?? "Unknown",
+      after: after ?? "Unchanged",
+      changeType: changeFor(before, after),
+      severity: after === STATE_LABELS[2 /* CLOSED */] ? "warning" : "info"
+    }
+  ];
+}
+function diffUpdateDates(inputs, current) {
+  const results = [];
+  const beforeStart = formatDate(current.startDate);
+  const afterStart = inputs.startDate !== void 0 ? formatDate(inputs.startDate) : beforeStart;
+  results.push({
+    key: "startDate",
+    label: "Start Date",
+    before: beforeStart,
+    after: afterStart,
+    changeType: changeFor(beforeStart === "Not set" ? null : beforeStart, afterStart === "Not set" ? null : afterStart)
+  });
+  const beforeEnd = formatDate(current.endDate);
+  const afterEnd = inputs.endDate !== void 0 ? formatDate(inputs.endDate) : beforeEnd;
+  results.push({
+    key: "endDate",
+    label: "End Date",
+    before: beforeEnd,
+    after: afterEnd,
+    changeType: changeFor(beforeEnd === "Not set" ? null : beforeEnd, afterEnd === "Not set" ? null : afterEnd)
+  });
+  return results;
+}
+function diffUpdateQuota(inputs, current) {
+  const beforeQuotaStr = formatQuota(current.quota);
+  const afterQuotaStr = formatQuota(inputs.quota);
+  const beforeNum = beforeQuotaStr === "Unlimited" ? null : toNumberOrNull(current.quota);
+  const afterNum = afterQuotaStr === "Unlimited" ? null : toNumberOrNull(inputs.quota);
+  let changeType;
+  if (beforeQuotaStr === afterQuotaStr) {
+    changeType = "unchanged";
+  } else if (beforeNum !== null && afterNum !== null) {
+    changeType = afterNum > beforeNum ? "increase" : afterNum < beforeNum ? "decrease" : "replace";
+  } else {
+    changeType = "replace";
+  }
+  const count = toNumberOrNull(current.count);
+  const belowCount = afterNum !== null && count !== null && afterNum < count;
+  return [
+    {
+      key: "quota",
+      label: "Quota",
+      before: beforeQuotaStr,
+      after: belowCount ? `${afterQuotaStr} (below current count ${count} \u2014 chain will reject)` : afterQuotaStr,
+      changeType,
+      severity: belowCount ? "critical" : "info",
+      unit: afterQuotaStr === "Unlimited" ? void 0 : "claims"
+    }
+  ];
+}
+function diffUpdatePayments(inputs, current) {
+  const before = summarisePayments(current.payments);
+  const after = summarisePayments(inputs.payments);
+  return ["submission", "evaluation", "approval", "rejection"].map((leg) => ({
+    key: `payments.${leg}`,
+    label: `Payment \u2014 ${leg.charAt(0).toUpperCase()}${leg.slice(1)}`,
+    before: before[leg],
+    after: after[leg],
+    changeType: changeFor(before[leg] === "None" ? null : before[leg], after[leg] === "None" ? null : after[leg])
+  }));
+}
+function diffUpdateIntents(inputs, current) {
+  const before = summariseIntents(current.intents);
+  const after = summariseIntents(inputs.intents);
+  return [
+    {
+      key: "intents.allowed",
+      label: "Intents \u2014 Allowed",
+      before: before.allowed,
+      after: after.allowed,
+      changeType: changeFor(before.allowed === "Not set" ? null : before.allowed, after.allowed === "Not set" ? null : after.allowed)
+    },
+    {
+      key: "intents.timeout",
+      label: "Intents \u2014 Timeout (ns)",
+      before: before.timeout,
+      after: after.timeout,
+      changeType: changeFor(before.timeout === "Not set" ? null : before.timeout, after.timeout === "Not set" ? null : after.timeout)
+    },
+    {
+      key: "intents.payment",
+      label: "Intents \u2014 Payment",
+      before: before.payment,
+      after: after.payment,
+      changeType: changeFor(before.payment === "None" ? null : before.payment, after.payment === "None" ? null : after.payment)
+    }
+  ];
+}
+registerDiffResolver(COLLECTION_LIFECYCLE_ACTION_TYPE, {
+  resolver: async (inputs, _ctx) => {
+    const safeInputs = inputs && typeof inputs === "object" ? inputs : {};
+    const operation = String(safeInputs.operation || "").trim();
+    const current = readCurrentState(safeInputs);
+    switch (operation) {
+      case "create":
+        return diffCreate(safeInputs);
+      case "updateState":
+        return diffUpdateState(safeInputs, current);
+      case "updateDates":
+        return diffUpdateDates(safeInputs, current);
+      case "updateQuota":
+        return diffUpdateQuota(safeInputs, current);
+      case "updatePayments":
+        return diffUpdatePayments(safeInputs, current);
+      case "updateIntents":
+        return diffUpdateIntents(safeInputs, current);
+      case "refresh":
+        return [];
+      default:
+        return [];
+    }
+  }
+});
+
+// src/core/lib/actionRegistry/actions/collectionUsers/collectionUsers.diff.ts
+function formatQuota2(value) {
+  if (value === void 0 || value === null) return "\u2014";
+  const s = String(value).trim();
+  if (s === "") return "\u2014";
+  return s;
+}
+function roleLabel(value) {
+  const r = String(value || "").trim().toLowerCase();
+  if (r === "submit") return "Submit (Contributor)";
+  if (r === "evaluate") return "Evaluate (Evaluator)";
+  return "Unknown role";
+}
+function diffAdd(inputs) {
+  const results = [];
+  const kind = String(inputs.granteeKind || "user");
+  results.push({ key: "role", label: "Role", before: null, after: roleLabel(inputs.role), changeType: "add" });
+  if (inputs.collectionId) {
+    results.push({ key: "collectionId", label: "Collection", before: null, after: String(inputs.collectionId), changeType: "add" });
+  }
+  if (kind === "group-members") {
+    const count = Array.isArray(inputs.members) ? inputs.members.filter((m) => !!String(m?.address || "").trim()).length : 0;
+    results.push({
+      key: "grantees",
+      label: "Grantees (fan-out)",
+      before: null,
+      after: `${count} group member${count === 1 ? "" : "s"}`,
+      changeType: "add",
+      severity: "warning"
+    });
+  } else {
+    const label = kind === "group-account" ? "Grantee (group account)" : "Grantee";
+    results.push({ key: "grantee", label, before: null, after: String(inputs.granteeAddress || "\u2014"), changeType: "add" });
+  }
+  results.push({
+    key: "agentQuota",
+    label: "Agent Quota",
+    before: null,
+    after: formatQuota2(inputs.agentQuota),
+    changeType: "add",
+    unit: formatQuota2(inputs.agentQuota) === "\u2014" ? void 0 : "claims"
+  });
+  return results;
+}
+function diffRevoke(inputs) {
+  const results = [];
+  results.push({ key: "role", label: "Role", before: roleLabel(inputs.role), after: null, changeType: "remove", severity: "warning" });
+  if (inputs.collectionId) {
+    results.push({ key: "collectionId", label: "Collection", before: String(inputs.collectionId), after: null, changeType: "remove", severity: "warning" });
+  }
+  results.push({
+    key: "grantee",
+    label: "Grantee",
+    before: String(inputs.granteeAddress || "\u2014"),
+    after: null,
+    changeType: "remove",
+    severity: "warning"
+  });
+  return results;
+}
+registerDiffResolver(COLLECTION_USERS_ACTION_TYPE, {
+  resolver: async (inputs, _ctx) => {
+    const safeInputs = inputs && typeof inputs === "object" ? inputs : {};
+    const operation = String(safeInputs.operation || "").trim();
+    switch (operation) {
+      case "add":
+        return diffAdd(safeInputs);
+      case "revoke":
+        return diffRevoke(safeInputs);
+      case "list":
+        return [];
+      default:
+        return [];
+    }
+  }
+});
+
 // src/core/services/ucanService.ts
 import {
   createDelegation as ucanCreateDelegation,
@@ -10799,4 +11530,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-UMS6GCME.mjs.map
+//# sourceMappingURL=chunk-RIDIYR53.mjs.map