@ixo/editor 3.8.0 → 3.9.0

package/dist/{chunk-QIJA3CMG.mjs → chunk-JHQO6FAQ.mjs}

@@ -62,7 +62,13 @@ var CAN_TO_TYPE = {
   "protocol/select": "qi/protocol.select",
   "human/checkbox": "qi/human.checkbox.set",
   "human/form": "qi/human.form.submit",
-  "oracle/query": "oracle"
+  "oracle/query": "oracle",
+  "pod/domain-indexer-lookup": "qi/pod.domain-indexer-lookup",
+  "pod/domain-single-selection": "qi/pod.domain-single-selection",
+  "pod/entity-single-selection": "qi/pod.entity-single-selection",
+  "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"
 };
 var TYPE_TO_CAN = Object.fromEntries(Object.entries(CAN_TO_TYPE).map(([can, type]) => [type, can]));
 function canToType(can) {
@@ -206,6 +212,184 @@ function hasDiffResolver(actionType) {
   return diffResolvers.has(actionType);
 }
 
+// src/core/lib/actionRegistry/actions/pod/domainIndexerLookup.ts
+registerAction({
+  type: "qi/pod.domain-indexer-lookup",
+  can: "pod/domain-indexer-lookup",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  outputSchema: [
+    { path: "purposeDescription", displayName: "Purpose Description", type: "string", description: "The user-provided purpose text" },
+    { path: "blueprintCandidates", displayName: "Blueprint Candidates", type: "array", description: "Ranked array of matching blueprint DIDs and metadata" }
+  ],
+  run: async (inputs) => {
+    const purposeDescription = String(inputs.userMessage || inputs.purposeDescription || "").trim();
+    if (!purposeDescription) throw new Error("userMessage is required");
+    return {
+      output: {
+        purposeDescription,
+        blueprintCandidates: []
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/pod/domainSingleSelection.ts
+registerAction({
+  type: "qi/pod.domain-single-selection",
+  can: "pod/domain-single-selection",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  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" }
+  ],
+  run: async (inputs) => {
+    const selectedBlueprintDid = String(inputs.selectedBlueprintDid || "").trim();
+    if (!selectedBlueprintDid) throw new Error("selectedBlueprintDid is required");
+    return {
+      output: {
+        selectedBlueprintDid,
+        selectedBlueprintName: String(inputs.selectedBlueprintName || "").trim(),
+        selectedBlueprintDescription: String(inputs.selectedBlueprintDescription || "").trim()
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/pod/entitySingleSelection.ts
+registerAction({
+  type: "qi/pod.entity-single-selection",
+  can: "pod/entity-single-selection",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  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: "skipped", displayName: "Skipped", type: "boolean", description: "True if the user skipped this step" }
+  ],
+  run: async (inputs) => {
+    const skipped = !!inputs.skipped;
+    if (skipped) {
+      return { output: { selectedEntityDid: null, selectedEntityName: "", skipped: true } };
+    }
+    const selectedEntityDid = String(inputs.selectedEntityDid || "").trim();
+    if (!selectedEntityDid) throw new Error("selectedEntityDid is required when not skipping");
+    return {
+      output: {
+        selectedEntityDid,
+        selectedEntityName: String(inputs.selectedEntityName || "").trim(),
+        skipped: false
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/pod/memberMultiSelect.ts
+registerAction({
+  type: "qi/pod.member-multi-select",
+  can: "pod/member-multi-select",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  outputSchema: [
+    { path: "members", displayName: "Members", type: "array", description: "Array of { did, role, votingPower } \u2014 categorical/multisig only" },
+    { path: "multisigThreshold", displayName: "Multisig Threshold", type: "number", description: "Minimum signers required \u2014 multisig only" },
+    { path: "nftContractAddress", displayName: "NFT Contract Address", type: "string", description: "NFT staking contract address \u2014 nftStaking only" },
+    { path: "tokenConfig", displayName: "Token Config", type: "object", description: "Token configuration \u2014 tokenStaking only" }
+  ],
+  run: async (inputs) => {
+    const groupType = inputs.groupType || "categorical";
+    if (groupType === "nftStaking") {
+      const addr = String(inputs.nftContractAddress || "").trim();
+      if (!addr) throw new Error("NFT contract address is required for nftStaking groups");
+      return { output: { nftContractAddress: addr } };
+    }
+    if (groupType === "tokenStaking") {
+      const tokenConfig = inputs.tokenConfig;
+      if (!tokenConfig) throw new Error("tokenConfig is required for tokenStaking groups");
+      if (tokenConfig.isExistingToken) {
+        if (!String(tokenConfig.tokenAddress || "").trim()) throw new Error("Token contract address is required");
+      } else {
+        if (!String(tokenConfig.tokenName || "").trim()) throw new Error("Token name is required");
+        if (!String(tokenConfig.tokenSymbol || "").trim()) throw new Error("Token symbol is required");
+        const supply = Number(tokenConfig.tokenSupply);
+        if (isNaN(supply) || supply <= 0) throw new Error("Token supply must be a positive number");
+      }
+      return { output: { tokenConfig } };
+    }
+    const members = Array.isArray(inputs.members) ? inputs.members : [];
+    if (members.length === 0) throw new Error("At least one member is required");
+    const dids = members.map((m) => String(m.did || ""));
+    const uniqueDids = new Set(dids);
+    if (uniqueDids.size !== dids.length) throw new Error("Duplicate member DIDs are not allowed");
+    if (groupType === "multisig") {
+      const threshold = Number(inputs.multisigThreshold);
+      if (!Number.isInteger(threshold) || threshold < 1) throw new Error("Multisig threshold must be a positive integer");
+      if (threshold > members.length) throw new Error(`Threshold (${threshold}) cannot exceed member count (${members.length})`);
+      return { output: { members, multisigThreshold: threshold } };
+    }
+    const hasAdmin = members.some((m) => String(m.role || "").toLowerCase() === "admin");
+    if (!hasAdmin) throw new Error("At least one member must have the Admin role");
+    for (const m of members) {
+      const vp = Number(m.votingPower);
+      if (!Number.isInteger(vp) || vp <= 0) throw new Error(`Voting power must be a positive integer (got ${m.votingPower} for ${m.did})`);
+    }
+    return { output: { members } };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/pod/governanceConfig.ts
+var VALID_GROUP_TYPES = ["categorical", "multisig", "nftStaking", "tokenStaking"];
+registerAction({
+  type: "qi/pod.governance-config",
+  can: "pod/governance-config",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  outputSchema: [
+    { path: "groupType", displayName: "Group Type", type: "string", description: "Governance group type (categorical | multisig | nftStaking | tokenStaking)" },
+    { path: "governance", displayName: "Governance Settings", type: "object", description: "Cosmos group decision policy parameters" }
+  ],
+  run: async (inputs) => {
+    const groupType = inputs.groupType;
+    if (!groupType || !VALID_GROUP_TYPES.includes(groupType)) {
+      throw new Error(`groupType must be one of: ${VALID_GROUP_TYPES.join(", ")}`);
+    }
+    const governance = inputs.governance;
+    if (!governance) throw new Error("governance settings are required");
+    if (!governance.votingPeriod) throw new Error("votingPeriod is required");
+    if (groupType === "multisig") {
+      const threshold = parseInt(governance.threshold, 10);
+      if (isNaN(threshold) || threshold < 1) throw new Error("multisig threshold must be a positive integer");
+    } else {
+      const quorum = parseFloat(governance.quorum);
+      if (isNaN(quorum) || quorum <= 0 || quorum > 1) throw new Error("quorum must be between 0 and 1 (e.g. 0.33)");
+      const threshold = parseFloat(governance.threshold);
+      if (isNaN(threshold) || threshold <= 0 || threshold > 1) throw new Error("threshold must be between 0 and 1 (e.g. 0.51)");
+      const vetoThreshold = parseFloat(governance.vetoThreshold);
+      if (!isNaN(vetoThreshold) && vetoThreshold + threshold > 1) {
+        throw new Error("threshold + vetoThreshold cannot exceed 1.0");
+      }
+    }
+    return { output: { groupType, governance } };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/pod/listDomainFlows.ts
+registerAction({
+  type: "qi/pod.list-domain-flows",
+  can: "pod/list-domain-flows",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  outputSchema: [
+    { path: "selectedFlowDids", displayName: "Selected Flow DIDs", type: "array", description: "Array of selected flow template DIDs" }
+  ],
+  run: async (inputs) => {
+    const selectedFlowDids = Array.isArray(inputs.selectedFlowDids) ? inputs.selectedFlowDids : [];
+    return { output: { selectedFlowDids } };
+  }
+});
+
 // src/core/lib/actionRegistry/actions/httpRequest.ts
 registerAction({
   type: "qi/http.request",
@@ -2990,6 +3174,29 @@ function removePendingInvocation(yDoc, listenerBlockId, pendingInvocationId) {
   inner.delete(pendingInvocationId);
   return true;
 }
+function appendRunRecord(yDoc, blockId, details, userId) {
+  const auditMap = yDoc.getMap("auditTrail");
+  yDoc.transact(() => {
+    let arr = auditMap.get(blockId);
+    if (!arr) {
+      arr = new Y.Array();
+      auditMap.set(blockId, arr);
+    }
+    const event = {
+      id: `${details.runId}`,
+      blockId,
+      type: RUN_RECORD_AUDIT_TYPE,
+      details,
+      message: void 0,
+      meta: {
+        timestamp: details.completedAt,
+        userId,
+        editable: false
+      }
+    };
+    arr.push([event]);
+  });
+}
 function readRunRecords(yDoc, blockId) {
   const auditMap = yDoc.getMap("auditTrail");
   const arr = auditMap.get(blockId);
@@ -3004,6 +3211,39 @@ function readRunRecords(yDoc, blockId) {
   });
   return records;
 }
+function findFailedListenersForSourceRun(yDoc, sourceBlockId, sourceRunId, listenerBlockIds) {
+  const failures = [];
+  for (const listenerBlockId of listenerBlockIds) {
+    const records = readRunRecords(yDoc, listenerBlockId);
+    for (const record of records) {
+      if (!record.error) continue;
+      if (record.triggeredBy?.sourceBlockId !== sourceBlockId) continue;
+      if (record.fromPendingInvocationId == null) continue;
+      const sourceRunIdField = record.sourceRunId;
+      if (sourceRunIdField && sourceRunIdField !== sourceRunId) continue;
+      failures.push({ listenerBlockId, record });
+    }
+  }
+  return failures;
+}
+function replayFailedListenerRun(yDoc, failedRecord, listenerBlockId, originalPayload, originalRefSnapshots, assigneeDid) {
+  if (!failedRecord.triggeredBy) return false;
+  const replayId = `${failedRecord.runId}:replay-${Date.now().toString(36)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const replay = {
+    id: replayId,
+    triggeringBlockId: failedRecord.triggeredBy.sourceBlockId,
+    sourceRunId: failedRecord.sourceRunId || failedRecord.runId,
+    eventName: failedRecord.triggeredBy.eventName,
+    eventIndex: 0,
+    payload: originalPayload,
+    refSnapshots: originalRefSnapshots,
+    assigneeDid,
+    emittedAt: now,
+    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+  };
+  return queuePendingInvocation(yDoc, listenerBlockId, replay);
+}
 
 // src/core/lib/flowEngine/reconcile.ts
 function reconcilePendingInvocations(editor) {
@@ -3142,6 +3382,11 @@ function parseIsoDurationToMs(duration) {
   if (s) ms += parseInt(s, 10) * 1e3;
   return ms;
 }
+function getActionForBlock(block) {
+  const actionType = block?.props?.actionType;
+  if (typeof actionType !== "string") return void 0;
+  return getAction(actionType);
+}
 
 // src/core/lib/flowEngine/migration.ts
 var MIGRATION_REGISTRY = {};
@@ -4163,9 +4408,20 @@ export {
   isAuthorized,
   executeNode,
   isRuntimeRef,
+  RUN_RECORD_AUDIT_TYPE,
+  computePendingInvocationId,
+  snapshotInputRefs,
+  getPendingInvocationsMap,
+  getOrCreateBlockPendingMap,
   readPendingInvocations,
+  queuePendingInvocation,
   removePendingInvocation,
+  appendRunRecord,
+  readRunRecords,
+  findFailedListenersForSourceRun,
+  replayFailedListenerRun,
   reconcilePendingInvocations,
+  getActionForBlock,
   compileBaseUcanFlow,
   readCompiledFlowFromYDoc,
   mergeCompiledFlows,
@@ -4177,4 +4433,4 @@ export {
   readFlow,
   setupFlowFromBaseUcan
 };
-//# sourceMappingURL=chunk-QIJA3CMG.mjs.map
+//# sourceMappingURL=chunk-JHQO6FAQ.mjs.map