@ixo/editor 5.15.0 → 5.19.0

package/dist/{chunk-YK3XJ5HK.mjs → chunk-67477PYU.mjs}

@@ -337,17 +337,38 @@ registerAction({
   outputSchema: [
     { path: "selectedBlueprintDid", displayName: "Selected Blueprint DID", type: "string", description: "DID of the selected blueprint" },
     { path: "selectedBlueprintName", displayName: "Selected Blueprint Name", type: "string", description: "Display name of the selected blueprint" },
-    { path: "selectedBlueprintDescription", displayName: "Selected Blueprint Description", type: "string", description: "Description of the selected blueprint" }
+    { path: "selectedBlueprintDescription", displayName: "Selected Blueprint Description", type: "string", description: "Description of the selected blueprint" },
+    { path: "context", displayName: "Entity Context", type: "array", description: "Entity context entries derived from the selected blueprint" }
+  ],
+  events: [
+    {
+      name: "selected",
+      displayName: "Blueprint Selected",
+      description: "Fires when a blueprint is selected for the POD.",
+      payloadSchema: [
+        { path: "selectedBlueprintDid", displayName: "Selected Blueprint DID", type: "string", description: "DID of the selected blueprint" },
+        { path: "selectedBlueprintName", displayName: "Selected Blueprint Name", type: "string", description: "Display name of the selected blueprint" },
+        { path: "selectedBlueprintDescription", displayName: "Selected Blueprint Description", type: "string", description: "Description of the selected blueprint" },
+        { path: "context", displayName: "Entity Context", type: "array", description: "Entity context entries for createDomain, including class = selected blueprint DID" }
+      ],
+      pendingDisplayFields: ["selectedBlueprintName", "selectedBlueprintDid"]
+    }
   ],
   run: async (inputs) => {
     const selectedBlueprintDid = String(inputs.selectedBlueprintDid || "").trim();
     if (!selectedBlueprintDid) throw new Error("selectedBlueprintDid is required");
+    const selectedBlueprintName = String(inputs.selectedBlueprintName || "").trim();
+    const selectedBlueprintDescription = String(inputs.selectedBlueprintDescription || "").trim();
+    const context = [{ key: "class", val: selectedBlueprintDid }];
+    const output = {
+      selectedBlueprintDid,
+      selectedBlueprintName,
+      selectedBlueprintDescription,
+      context
+    };
     return {
-      output: {
-        selectedBlueprintDid,
-        selectedBlueprintName: String(inputs.selectedBlueprintName || "").trim(),
-        selectedBlueprintDescription: String(inputs.selectedBlueprintDescription || "").trim()
-      }
+      output,
+      events: [{ name: "selected", payload: output }]
     };
   }
 });
@@ -361,21 +382,51 @@ registerAction({
   outputSchema: [
     { path: "selectedEntityDid", displayName: "Selected Entity DID", type: "string", description: "DID of the selected parent entity, or null if skipped" },
     { path: "selectedEntityName", displayName: "Selected Entity Name", type: "string", description: "Display name of the selected parent entity" },
+    { path: "selectedEntityType", displayName: "Selected Entity Type", type: "string", description: "Entity type of the selected parent entity" },
     { path: "skipped", displayName: "Skipped", type: "boolean", description: "True if the user skipped this step" }
   ],
+  events: [
+    {
+      name: "selected",
+      displayName: "Entity Selected",
+      description: "Fires when a parent DAO or POD is selected.",
+      payloadSchema: [
+        { path: "selectedEntityDid", displayName: "Selected Entity DID", type: "string", description: "DID of the selected parent entity" },
+        { path: "selectedEntityName", displayName: "Selected Entity Name", type: "string", description: "Display name of the selected parent entity" },
+        { path: "selectedEntityType", displayName: "Selected Entity Type", type: "string", description: "Entity type of the selected parent entity" },
+        { path: "skipped", displayName: "Skipped", type: "boolean", description: "False when a parent entity was selected" }
+      ],
+      pendingDisplayFields: ["selectedEntityName", "selectedEntityDid"]
+    },
+    {
+      name: "skipped",
+      displayName: "Selection Skipped",
+      description: "Fires when parent entity selection is skipped.",
+      payloadSchema: [
+        { path: "selectedEntityDid", displayName: "Selected Entity DID", type: "string", description: "Null when skipped" },
+        { path: "skipped", displayName: "Skipped", type: "boolean", description: "True when skipped" }
+      ],
+      pendingDisplayFields: ["skipped"]
+    }
+  ],
   run: async (inputs) => {
     const skipped = !!inputs.skipped;
     if (skipped) {
-      return { output: { selectedEntityDid: null, selectedEntityName: "", skipped: true } };
+      const output2 = { selectedEntityDid: null, selectedEntityName: "", selectedEntityType: "", skipped: true };
+      return { output: output2, events: [{ name: "skipped", payload: output2 }] };
     }
     const selectedEntityDid = String(inputs.selectedEntityDid || "").trim();
     if (!selectedEntityDid) throw new Error("selectedEntityDid is required when not skipping");
+    const selectedEntityType = String(inputs.selectedEntityType || "").trim();
+    const output = {
+      selectedEntityDid,
+      selectedEntityName: String(inputs.selectedEntityName || "").trim(),
+      selectedEntityType,
+      skipped: false
+    };
     return {
-      output: {
-        selectedEntityDid,
-        selectedEntityName: String(inputs.selectedEntityName || "").trim(),
-        skipped: false
-      }
+      output,
+      events: [{ name: "selected", payload: output }]
     };
   }
 });
@@ -1887,7 +1938,7 @@ function parseLinkedEntities(entitiesString) {
 }
 function buildGovernanceGroupLinkedEntities(linkedEntities) {
   return linkedEntities.filter((entity) => entity.type === "governanceGroup" && entity.coreAddress).map((entity) => ({
-    id: entity.coreAddress,
+    id: `{id}#${entity.coreAddress}`,
     type: "group",
     relationship: "governs",
     service: ""
@@ -2601,6 +2652,23 @@ function parseJsonInput(value) {
   }
   return null;
 }
+function parseContextInput(value) {
+  let raw = value;
+  if (typeof value === "string") {
+    try {
+      raw = JSON.parse(value);
+    } catch {
+      raw = [];
+    }
+  }
+  if (!Array.isArray(raw)) return [];
+  return raw.map((entry) => {
+    if (!entry || typeof entry !== "object") return null;
+    const key = String(entry.key || "").trim();
+    const val = String(entry.val || "").trim();
+    return key && val ? { key, val } : null;
+  }).filter((entry) => entry !== null);
+}
 function parseDuration(raw) {
   const seconds = parseInt(raw, 10) || 0;
   if (seconds % (7 * 86400) === 0) return { amount: seconds / (7 * 86400), unit: "weeks" };
@@ -2681,7 +2749,13 @@ registerAction({
       type: "string",
       description: "The core address of the created governance group, when one was created"
     },
-    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The on-chain transaction hash for domain creation" }
+    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The on-chain transaction hash for domain creation" },
+    {
+      path: "linkedResourceTransactionHash",
+      displayName: "Linked Resource Transaction Hash",
+      type: "string",
+      description: "The on-chain transaction hash for adding the domain card linked resource"
+    }
   ],
   events: [
     {
@@ -2696,7 +2770,13 @@ registerAction({
           type: "string",
           description: "Core address of the created governance group, when present"
         },
-        { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "On-chain transaction hash" }
+        { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "On-chain transaction hash" },
+        {
+          path: "linkedResourceTransactionHash",
+          displayName: "Linked Resource Transaction Hash",
+          type: "string",
+          description: "On-chain transaction hash for adding the domain card linked resource"
+        }
       ],
       pendingDisplayFields: ["entityDid", "governanceGroupCoreAddress"]
     }
@@ -2710,6 +2790,8 @@ registerAction({
     if (!handlers.signCredential) throw new Error("signCredential handler not implemented");
     if (!handlers.publicFileUpload) throw new Error("publicFileUpload handler not available");
     if (!handlers.createDomain) throw new Error("createDomain handler not implemented");
+    if (!handlers.createAddLinkedResourceMessage) throw new Error("createAddLinkedResourceMessage handler not implemented");
+    if (!handlers.executeTransaction) throw new Error("executeTransaction handler not implemented");
     let domainCardData;
     if (typeof inputs.domainCardData === "string") {
       try {
@@ -2726,21 +2808,53 @@ registerAction({
       throw new Error("domainCardData is missing or invalid (credentialSubject.name required)");
     }
     const entityType = String(inputs.entityType || "").trim() || (domainCardData.credentialSubject?.type?.[0] ? resolveEntityTypeFromSchema(domainCardData.credentialSubject.type[0]) : "dao/pod");
-    const issuerDid = handlers.getEntityDid?.() || handlers.getCurrentUser?.()?.address;
-    if (!issuerDid) throw new Error("Unable to determine issuer DID");
-    const entityDidPlaceholder = "did:ixo:entity:pending";
     const validFrom = domainCardData.validFrom || (/* @__PURE__ */ new Date()).toISOString();
     const validUntil = domainCardData.validUntil || (() => {
       const d = /* @__PURE__ */ new Date();
       d.setFullYear(d.getFullYear() + 100);
       return d.toISOString();
     })();
+    let governanceGroupLinkedEntities = [];
+    let governanceGroupCoreAddress = "";
+    const govConfig = parseJsonInput(inputs.governanceConfig);
+    const memberConfig = parseJsonInput(inputs.memberConfig);
+    const context = parseContextInput(inputs.context);
+    if (govConfig && handlers.createGovernanceGroup) {
+      const groupType = govConfig.groupType;
+      const governance = govConfig.governance || {};
+      const config = buildGroupConfig(groupType, governance, memberConfig);
+      const groupResult = await handlers.createGovernanceGroup({
+        groupType,
+        name: govConfig.groupName || domainCardData.credentialSubject?.name || "Governance Group",
+        config
+      });
+      governanceGroupCoreAddress = groupResult.coreAddress;
+      governanceGroupLinkedEntities = [
+        {
+          id: `{id}#${governanceGroupCoreAddress}`,
+          type: "group",
+          relationship: "governs",
+          service: ""
+        }
+      ];
+    }
+    const endDate = domainCardData.endDate || validUntil;
+    const { entityDid: newEntityDid, transactionHash } = await handlers.createDomain({
+      entityType,
+      context: context.length > 0 ? context : void 0,
+      linkedResource: [],
+      linkedEntity: governanceGroupLinkedEntities.length > 0 ? governanceGroupLinkedEntities : void 0,
+      startDate: validFrom,
+      endDate
+    });
+    const issuerDid = handlers.getEntityDid?.() || handlers.getCurrentUser?.()?.address;
+    if (!issuerDid) throw new Error("Unable to determine issuer DID");
     const credentialSubject = {
       ...domainCardData.credentialSubject,
-      id: entityDidPlaceholder
+      id: newEntityDid
     };
     const unsignedCredential = buildVerifiableCredential({
-      entityDid: entityDidPlaceholder,
+      entityDid: newEntityDid,
       issuerDid,
       credentialSubject,
       validFrom,
@@ -2765,50 +2879,33 @@ registerAction({
     });
     const uploadResult = await handlers.publicFileUpload(credentialFile);
     const domainCardLinkedResource = buildDomainCardLinkedResource({
-      entityDid: entityDidPlaceholder,
+      entityDid: newEntityDid,
       cid: uploadResult.cid,
       serviceEndpoint: uploadResult.url,
       description: `Domain Card for ${domainCardData.credentialSubject?.name || "Domain"}`
     });
-    let governanceGroupLinkedEntities = [];
-    let governanceGroupCoreAddress = "";
-    const govConfig = parseJsonInput(inputs.governanceConfig);
-    const memberConfig = parseJsonInput(inputs.memberConfig);
-    if (govConfig && handlers.createGovernanceGroup) {
-      const groupType = govConfig.groupType;
-      const governance = govConfig.governance || {};
-      const config = buildGroupConfig(groupType, governance, memberConfig);
-      const groupResult = await handlers.createGovernanceGroup({
-        groupType,
-        name: govConfig.groupName || domainCardData.credentialSubject?.name || "Governance Group",
-        config
-      });
-      governanceGroupCoreAddress = groupResult.coreAddress;
-      governanceGroupLinkedEntities = [
-        {
-          id: governanceGroupCoreAddress,
-          type: "group",
-          relationship: "governs",
-          service: ""
-        }
-      ];
-    }
-    const endDate = domainCardData.endDate || validUntil;
-    const { entityDid: newEntityDid, transactionHash } = await handlers.createDomain({
-      entityType,
-      linkedResource: [domainCardLinkedResource],
-      linkedEntity: governanceGroupLinkedEntities.length > 0 ? governanceGroupLinkedEntities : void 0,
-      startDate: validFrom,
-      endDate
+    const addLinkedResourceMessage = await handlers.createAddLinkedResourceMessage({
+      entityDid: newEntityDid,
+      linkedResource: domainCardLinkedResource
     });
+    const addLinkedResourceResult = await handlers.executeTransaction({
+      messages: [addLinkedResourceMessage],
+      memo: ""
+    });
+    const linkedResourceTransactionHash = String(addLinkedResourceResult?.transactionHash || "");
+    if (!linkedResourceTransactionHash) {
+      throw new Error("Linked resource transaction completed but no transaction hash received");
+    }
     return {
       output: {
         entityDid: newEntityDid,
         governanceGroupCoreAddress,
         linkedEntities: governanceGroupLinkedEntities,
-        transactionHash
+        linkedResources: [domainCardLinkedResource],
+        transactionHash,
+        linkedResourceTransactionHash
       },
-      events: [{ name: "created", payload: { entityDid: newEntityDid, governanceGroupCoreAddress, transactionHash } }]
+      events: [{ name: "created", payload: { entityDid: newEntityDid, governanceGroupCoreAddress, transactionHash, linkedResourceTransactionHash } }]
     };
   }
 });
@@ -2958,33 +3055,59 @@ registerAction({
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: [
-    { path: "transactionId", displayName: "Transaction ID", type: "string", description: "Payment transaction identifier from the provider" },
-    { path: "status", displayName: "Status", type: "string", description: "Payment status (proposed, submitted, pending, completed, failed)" },
-    { path: "proposal", displayName: "Proposal", type: "object", description: "Payment proposal object for review before execution" },
-    { path: "summary", displayName: "Summary", type: "object", description: "Human-readable payment summary" }
+    { path: "verb", displayName: "Action verb", type: "string" },
+    { path: "rowCount", displayName: "Rows targeted", type: "number" },
+    { path: "paymentBlockId", displayName: "Payment block ID", type: "string" }
+  ],
+  events: [
+    {
+      name: "rows.completed",
+      displayName: "Payment rows completed",
+      description: "Fires after the oracle writes terminal status for one or more rows in this batch. Listeners can react to the just-completed payouts.",
+      payloadSchema: [
+        { path: "paymentBlockId", displayName: "Payment block ID", type: "string" },
+        { path: "completedRowIds", displayName: "Completed row IDs", type: "string" },
+        { path: "failedRowIds", displayName: "Failed row IDs", type: "string" }
+      ]
+    }
   ],
   run: async (inputs, ctx) => {
-    const config = inputs.paymentConfig;
-    if (!config || typeof config === "string" && !config.trim()) {
-      throw new Error("paymentConfig is required");
+    const rowIds = Array.isArray(inputs.rowIds) ? inputs.rowIds.filter((v) => typeof v === "string" && v.length > 0) : [];
+    if (rowIds.length === 0) {
+      throw new Error("rowIds is required \u2014 pick at least one row before sending");
+    }
+    const verb = String(inputs.verb || "").trim().toLowerCase();
+    if (verb !== "propose" && verb !== "execute" && verb !== "check") {
+      throw new Error(
+        'verb is required and must be one of: "propose", "execute", "check"'
+      );
+    }
+    const paymentBlockId = String(inputs.paymentBlockId || "").trim();
+    if (!paymentBlockId) {
+      throw new Error("paymentBlockId is required");
     }
+    const delegationCid = typeof inputs.delegationCid === "string" ? inputs.delegationCid : "";
+    const skillCtx = inputs.skill && typeof inputs.skill === "object" ? inputs.skill : null;
     if (!ctx.handlers?.askCompanion) {
       throw new Error("askCompanion handler is not available");
     }
-    const parsed = typeof config === "string" ? JSON.parse(config) : config;
-    const configJson = JSON.stringify(parsed, null, 2);
-    await ctx.handlers.askCompanion(
-      [
-        "Execute payment action with this configuration.",
-        "IMPORTANT: First read the flow context and settings \u2014 the flow may contain parameters required by the skill. Also review all blocks in the flow to understand the basic workflow before executing.",
-        `Payment configuration JSON:
-${configJson}`
-      ].join("\n")
+    const verbDescription = verb === "propose" ? "Make payout proposals for the rows listed below." : verb === "execute" ? "Execute the previously-proposed payouts for the rows listed below." : "Check status for the rows listed below.";
+    const lines = [verbDescription];
+    lines.push(
+      "Read the flow context and the payment block to find the worker base URL, sender info, defaults, and the rows. Follow the skill's SKILL.md for the workflow.",
+      `Payment block ID: ${paymentBlockId}`,
+      `Verb: ${verb}`,
+      `Row IDs (in this batch): ${rowIds.join(", ")}`
     );
+    if (skillCtx?.name) lines.push(`Skill name: ${skillCtx.name}`);
+    if (skillCtx?.cid) lines.push(`Skill CID: ${skillCtx.cid}`);
+    if (delegationCid) lines.push(`UCAN delegation CID: ${delegationCid}`);
+    await ctx.handlers.askCompanion(lines.join("\n"));
     return {
       output: {
-        status: "requested",
-        paymentConfig: parsed
+        verb,
+        rowCount: rowIds.length,
+        paymentBlockId
       }
     };
   }
@@ -5192,7 +5315,6 @@ function getCidFromDelegation(delegation) {
 }
 var createUcanService = (config) => {
   const { delegationStore, invocationStore, handlers, flowOwnerDid } = config;
-  const normalizedFlowOwnerDid = normalizeDid(flowOwnerDid);
   const delegationCache = /* @__PURE__ */ new Map();
   const isConfigured = () => {
     const hasSessionHandlers = !!(handlers.createSignerSession && handlers.signWithSession);
@@ -5225,11 +5347,49 @@ var createUcanService = (config) => {
     }
     return proofs;
   };
+  const getProofCars = async (proofCids) => {
+    const cars = [];
+    for (const cid of proofCids) {
+      const stored = delegationStore.get(cid);
+      if (stored && stored.delegation) {
+        cars.push(stored.delegation);
+      }
+    }
+    return cars;
+  };
   const createRootDelegation = async (params) => {
     const { flowOwnerDid: ownerDid, issuerType, entityRoomId, flowUri: uri, pin } = params;
     const normalizedOwnerDid = normalizeDid(ownerDid);
-    const signer = await getSigner(handlers, normalizedOwnerDid, issuerType, entityRoomId, pin);
     const capabilities = [{ can: "flow/*", with: uri }];
+    if (handlers.createSignerSession && handlers.createDelegationWithSession) {
+      const session = await handlers.createSignerSession({
+        did: ownerDid,
+        didType: issuerType,
+        entityRoomId,
+        pin,
+        scope: "operation"
+      });
+      const result = await handlers.createDelegationWithSession({
+        sessionId: session.sessionId,
+        audience: ownerDid,
+        capabilities,
+        proofs: []
+      });
+      const storedDelegation2 = {
+        cid: result.cid,
+        delegation: result.delegation,
+        issuerDid: ownerDid,
+        audienceDid: ownerDid,
+        capabilities,
+        createdAt: Date.now(),
+        format: "car",
+        proofCids: []
+      };
+      delegationStore.set(storedDelegation2);
+      delegationStore.setRootCid(result.cid);
+      return storedDelegation2;
+    }
+    const signer = await getSigner(handlers, ownerDid, issuerType, entityRoomId, pin);
     const delegation = await ucanCreateDelegation({
       issuer: signer,
       audience: toInvocationAudienceDID(normalizedOwnerDid),
@@ -5257,8 +5417,38 @@ var createUcanService = (config) => {
     const { issuerDid, issuerType, entityRoomId, audience, capabilities, proofs = [], expiration, pin } = params;
     const normalizedIssuerDid = normalizeDid(issuerDid);
     const normalizedAudienceDid = normalizeDid(audience);
-    const signer = await getSigner(handlers, normalizedIssuerDid, issuerType, entityRoomId, pin);
-    const proofCids = proofs.length > 0 ? proofs : [delegationStore.getRootCid()].filter(Boolean);
+    const proofCids = proofs;
+    if (handlers.createSignerSession && handlers.createDelegationWithSession) {
+      const session = await handlers.createSignerSession({
+        did: issuerDid,
+        didType: issuerType,
+        entityRoomId,
+        pin,
+        scope: "operation"
+      });
+      const proofCars = await getProofCars(proofCids);
+      const result = await handlers.createDelegationWithSession({
+        sessionId: session.sessionId,
+        audience,
+        capabilities,
+        proofs: proofCars,
+        expiration: expiration ? Math.floor(expiration / 1e3) : void 0
+      });
+      const storedDelegation2 = {
+        cid: result.cid,
+        delegation: result.delegation,
+        issuerDid,
+        audienceDid: audience,
+        capabilities,
+        expiration,
+        createdAt: Date.now(),
+        format: "car",
+        proofCids
+      };
+      delegationStore.set(storedDelegation2);
+      return storedDelegation2;
+    }
+    const signer = await getSigner(handlers, issuerDid, issuerType, entityRoomId, pin);
     const proofDelegations = await getProofDelegations(proofCids);
     const delegation = await ucanCreateDelegation({
       issuer: signer,
@@ -5354,9 +5544,12 @@ var createUcanService = (config) => {
         };
       }
     }
-    const root = proofChain[proofChain.length - 1];
-    if (normalizeDid(root.issuerDid) !== normalizedFlowOwnerDid) {
-      return { valid: false, error: `Root issuer ${root.issuerDid} is not flow owner ${flowOwnerDid}` };
+    const isFlowScoped = capability.can === "flow/*" || capability.can.startsWith("flow/");
+    if (isFlowScoped) {
+      const root = proofChain[proofChain.length - 1];
+      if (root.issuerDid !== flowOwnerDid) {
+        return { valid: false, error: `Root issuer ${root.issuerDid} is not flow owner ${flowOwnerDid}` };
+      }
     }
     return { valid: true, proofChain };
   };
@@ -5371,6 +5564,41 @@ var createUcanService = (config) => {
         error: validation.error
       };
     }
+    const audience = params.audience ?? flowOwnerDid;
+    if (handlers.createSignerSession && handlers.createInvocationWithSession) {
+      try {
+        const session = await handlers.createSignerSession({
+          did: invokerDid,
+          didType: invokerType,
+          entityRoomId,
+          pin,
+          scope: "operation"
+        });
+        const proofCars = await getProofCars(proofs);
+        const result = await handlers.createInvocationWithSession({
+          sessionId: session.sessionId,
+          audience,
+          capability: {
+            can: capability.can,
+            with: capability.with,
+            ...capability.nb && { nb: capability.nb }
+          },
+          proofs: proofCars
+        });
+        return {
+          cid: result.cid,
+          invocation: result.invocation,
+          valid: true
+        };
+      } catch (err) {
+        return {
+          cid: "",
+          invocation: "",
+          valid: false,
+          error: err instanceof Error ? err.message : "Failed to create invocation via session"
+        };
+      }
+    }
     const signer = await getSigner(handlers, invokerDid, invokerType, entityRoomId, pin);
     const proofDelegations = await getProofDelegations(proofs);
     const ucantoCapability = {
@@ -5380,7 +5608,7 @@ var createUcanService = (config) => {
     };
     const invocation = await ucanCreateInvocation({
       issuer: signer,
-      audience: toInvocationAudienceDID(normalizedFlowOwnerDid),
+      audience,
       capability: ucantoCapability,
       proofs: proofDelegations
     });
@@ -8915,4 +9143,4 @@ export {
   executeQueuedFlowAgentCoreCommands,
   FlowAgentService
 };
-//# sourceMappingURL=chunk-YK3XJ5HK.mjs.map
+//# sourceMappingURL=chunk-67477PYU.mjs.map