@ixo/editor 3.8.1 → 4.0.0

package/dist/{chunk-QIJA3CMG.mjs → chunk-4ETFMWQR.mjs}

@@ -15,8 +15,16 @@ var ACTION_TYPE_ALIASES = {
   "proposal.vote": "qi/proposal.vote",
   "protocol.select": "qi/protocol.select",
   "domain.sign": "qi/domain.sign",
-  "domain.create": "qi/domain.create",
+  "domain.card-build": "qi/domain.card-build",
+  "domain.card-preview": "qi/domain.card-preview",
   "credential.store": "qi/credential.store",
+  // POD setup flow — camelCase orchestrator labels → canonical action types
+  DomainIndexerLookup: "qi/pod.domain-indexer-lookup",
+  DomainSingleSelection: "qi/pod.domain-single-selection",
+  EntitySingleSelection: "qi/pod.entity-single-selection",
+  MemberMultiSelect: "qi/pod.member-multi-select",
+  governanceConfig: "qi/pod.governance-config",
+  listDomainFlows: "qi/pod.list-domain-flows",
   payment: "qi/payment.execute",
   "matrix.dm": "qi/matrix.dm"
 };
@@ -54,7 +62,8 @@ var CAN_TO_TYPE = {
   "matrix/dm": "qi/matrix.dm",
   "proposal/create": "qi/proposal.create",
   "proposal/vote": "qi/proposal.vote",
-  "domain/create": "qi/domain.create",
+  "domain/card-build": "qi/domain.card-build",
+  "domain/card-preview": "qi/domain.card-preview",
   "domain/sign": "qi/domain.sign",
   "credential/store": "qi/credential.store",
   "payment/execute": "qi/payment.execute",
@@ -62,7 +71,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 +221,190 @@ 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: "groupName", displayName: "Group Name", type: "string", description: "Human-readable name for the governance group" },
+    { 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 groupName = String(inputs.groupName || "").trim();
+    if (!groupName) throw new Error("groupName is required");
+    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 raw = String(governance.threshold ?? "").trim();
+      const threshold = Number(raw);
+      if (!raw || !Number.isFinite(threshold) || !Number.isInteger(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: { groupName, 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",
@@ -985,211 +1184,7 @@ registerAction({
   }
 });
 
-// src/mantine/blocks/domainCreator/utils/buildVerifiableCredential.ts
-var DOMAIN_CARD_CONTEXT = [
-  "https://w3id.org/ixo/context/v1",
-  {
-    schema: "https://schema.org/",
-    ixo: "https://w3id.org/ixo/vocab/v1",
-    prov: "http://www.w3.org/ns/prov#",
-    proj: "http://www.w3.org/ns/project#",
-    id: "@id",
-    type: "@type",
-    "@protected": true
-  }
-];
-var DOMAIN_CARD_SCHEMA = {
-  id: "https://w3id.org/ixo/protocol/schema/v1#domainCard",
-  type: "JsonSchema"
-};
-function toISOString(dateInput, fallback = /* @__PURE__ */ new Date()) {
-  if (!dateInput) {
-    return fallback.toISOString();
-  }
-  if (dateInput instanceof Date) {
-    return dateInput.toISOString();
-  }
-  if (/^\d{4}-\d{2}-\d{2}$/.test(dateInput)) {
-    return (/* @__PURE__ */ new Date(dateInput + "T00:00:00.000Z")).toISOString();
-  }
-  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(dateInput)) {
-    return (/* @__PURE__ */ new Date(dateInput + ":00.000Z")).toISOString();
-  }
-  const parsed = new Date(dateInput);
-  if (!isNaN(parsed.getTime())) {
-    return parsed.toISOString();
-  }
-  return fallback.toISOString();
-}
-function getDefaultValidUntil(validFrom) {
-  const fromDate = new Date(validFrom);
-  const untilDate = new Date(fromDate);
-  untilDate.setFullYear(untilDate.getFullYear() + 5);
-  return untilDate.toISOString();
-}
-function buildVerifiableCredential(params) {
-  const { entityDid, issuerDid, credentialSubject, validFrom, validUntil } = params;
-  const validFromISO = toISOString(validFrom);
-  const validUntilISO = validUntil ? toISOString(validUntil) : getDefaultValidUntil(validFromISO);
-  return {
-    "@context": DOMAIN_CARD_CONTEXT,
-    id: `${entityDid}#dmn`,
-    type: ["VerifiableCredential", "ixo:DomainCard"],
-    issuer: {
-      id: issuerDid
-    },
-    validFrom: validFromISO,
-    validUntil: validUntilISO,
-    credentialSchema: DOMAIN_CARD_SCHEMA,
-    credentialSubject: {
-      ...credentialSubject,
-      // Ensure the subject ID matches the entity DID
-      id: entityDid
-    }
-  };
-}
-function buildDomainCardLinkedResource(params) {
-  return {
-    id: `${params.entityDid}#dmn`,
-    type: "domainCard",
-    proof: params.cid,
-    right: "",
-    encrypted: "false",
-    mediaType: "application/json",
-    description: params.description || "Domain Card",
-    serviceEndpoint: params.serviceEndpoint
-  };
-}
-
-// src/mantine/blocks/domainCreatorSign/utils/buildLinkedEntityResource.ts
-function parseLinkedEntities(entitiesString) {
-  if (!entitiesString || entitiesString === "[]") return [];
-  try {
-    return JSON.parse(entitiesString);
-  } catch {
-    return [];
-  }
-}
-function buildGovernanceGroupLinkedEntities(linkedEntities) {
-  return linkedEntities.filter((entity) => entity.type === "governanceGroup" && entity.coreAddress).map((entity) => ({
-    id: entity.coreAddress,
-    type: "group",
-    relationship: "governs",
-    service: ""
-  }));
-}
-
-// src/core/lib/actionRegistry/actions/domainSign.ts
-registerAction({
-  type: "qi/domain.sign",
-  can: "domain/sign",
-  sideEffect: true,
-  defaultRequiresConfirmation: true,
-  requiredCapability: "flow/block/execute",
-  outputSchema: [
-    { path: "entityDid", displayName: "Entity DID", type: "string", description: "The DID of the newly created domain entity" },
-    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The on-chain transaction hash for domain creation" }
-  ],
-  run: async (inputs, ctx) => {
-    const handlers = ctx.handlers;
-    if (!handlers) {
-      throw new Error("Handlers not available");
-    }
-    if (!handlers.requestPin) throw new Error("requestPin handler not available");
-    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");
-    let domainCardData;
-    if (typeof inputs.domainCardData === "string") {
-      try {
-        domainCardData = JSON.parse(inputs.domainCardData);
-      } catch {
-        throw new Error("domainCardData must be valid JSON");
-      }
-    } else if (inputs.domainCardData && typeof inputs.domainCardData === "object") {
-      domainCardData = inputs.domainCardData;
-    } else {
-      throw new Error("domainCardData is required");
-    }
-    if (!domainCardData?.credentialSubject?.name) {
-      throw new Error("domainCardData is missing or invalid (credentialSubject.name required)");
-    }
-    const extractEntityType = (type) => type.replace(/^schema:/i, "").toLowerCase();
-    const entityType = String(inputs.entityType || "").trim() || (domainCardData.credentialSubject?.type?.[0] ? extractEntityType(domainCardData.credentialSubject.type[0]) : "dao");
-    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();
-    })();
-    const credentialSubject = {
-      ...domainCardData.credentialSubject,
-      id: entityDidPlaceholder
-    };
-    const unsignedCredential = buildVerifiableCredential({
-      entityDid: entityDidPlaceholder,
-      issuerDid,
-      credentialSubject,
-      validFrom,
-      validUntil
-    });
-    const pin = await handlers.requestPin({
-      title: "Sign Domain Card",
-      description: "Enter your PIN to sign the Domain Card credential",
-      submitText: "Sign"
-    });
-    const { signedCredential } = await handlers.signCredential({
-      issuerDid,
-      issuerType: "user",
-      credential: unsignedCredential,
-      pin
-    });
-    const credentialBlob = new Blob([JSON.stringify(signedCredential, null, 2)], {
-      type: "application/json"
-    });
-    const credentialFile = new File([credentialBlob], "domainCard.json", {
-      type: "application/json"
-    });
-    const uploadResult = await handlers.publicFileUpload(credentialFile);
-    const domainCardLinkedResource = buildDomainCardLinkedResource({
-      entityDid: entityDidPlaceholder,
-      cid: uploadResult.cid,
-      serviceEndpoint: uploadResult.url,
-      description: `Domain Card for ${domainCardData.credentialSubject?.name || "Domain"}`
-    });
-    let linkedEntitiesData = [];
-    if (inputs.linkedEntities) {
-      if (typeof inputs.linkedEntities === "string") {
-        try {
-          linkedEntitiesData = JSON.parse(inputs.linkedEntities);
-        } catch {
-        }
-      } else if (Array.isArray(inputs.linkedEntities)) {
-        linkedEntitiesData = inputs.linkedEntities;
-      }
-    }
-    const governanceGroupLinkedEntities = buildGovernanceGroupLinkedEntities(parseLinkedEntities(JSON.stringify(linkedEntitiesData)));
-    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
-    });
-    return {
-      output: {
-        entityDid: newEntityDid,
-        transactionHash
-      }
-    };
-  }
-});
-
-// src/mantine/blocks/domainCreator/utils/transformSurveyToCredentialSubject.ts
+// src/core/lib/domainCard/transformSurveyToCredentialSubject.ts
 function extractPanelDynamicItems(surveyData, panelName, itemMapper) {
   const items = surveyData[panelName];
   if (!Array.isArray(items)) return [];
@@ -1421,91 +1416,837 @@ function transformSurveyToCredentialSubject(surveyData, entityDid) {
   return credentialSubject;
 }
 
-// src/mantine/blocks/domainCreator/utils/extractSurveyAnswersTemplate.ts
-function extractFieldsFromElements(elements, fields) {
-  for (const element of elements) {
-    if (element.type === "panel" && element.elements) {
-      extractFieldsFromElements(element.elements, fields);
-      continue;
-    }
-    if (element.type === "paneldynamic" && element.name) {
-      fields[element.name] = [];
-      if (element.templateElements) {
-        extractFieldsFromElements(element.templateElements, fields);
-      }
-      continue;
-    }
-    if (element.name && element.type !== "panel") {
-      switch (element.type) {
-        case "boolean":
-          fields[element.name] = false;
-          break;
-        case "checkbox":
-          fields[element.name] = [];
-          break;
-        case "file":
-          fields[element.name] = [];
-          break;
-        default:
-          fields[element.name] = "";
-      }
-    }
-    if (element.elements) {
-      extractFieldsFromElements(element.elements, fields);
-    }
+// src/core/lib/domainCard/buildVerifiableCredential.ts
+var DOMAIN_CARD_CONTEXT = [
+  "https://w3id.org/ixo/context/v1",
+  {
+    schema: "https://schema.org/",
+    ixo: "https://w3id.org/ixo/vocab/v1",
+    prov: "http://www.w3.org/ns/prov#",
+    proj: "http://www.w3.org/ns/project#",
+    id: "@id",
+    type: "@type",
+    "@protected": true
+  }
+];
+var DOMAIN_CARD_SCHEMA = {
+  id: "https://w3id.org/ixo/protocol/schema/v1#domainCard",
+  type: "JsonSchema"
+};
+function toISOString(dateInput, fallback = /* @__PURE__ */ new Date()) {
+  if (!dateInput) {
+    return fallback.toISOString();
+  }
+  if (dateInput instanceof Date) {
+    return dateInput.toISOString();
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateInput)) {
+    return (/* @__PURE__ */ new Date(dateInput + "T00:00:00.000Z")).toISOString();
+  }
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(dateInput)) {
+    return (/* @__PURE__ */ new Date(dateInput + ":00.000Z")).toISOString();
   }
+  const parsed = new Date(dateInput);
+  if (!isNaN(parsed.getTime())) {
+    return parsed.toISOString();
+  }
+  return fallback.toISOString();
+}
+function getDefaultValidUntil(validFrom) {
+  const fromDate = new Date(validFrom);
+  const untilDate = new Date(fromDate);
+  untilDate.setFullYear(untilDate.getFullYear() + 5);
+  return untilDate.toISOString();
+}
+function buildVerifiableCredential(params) {
+  const { entityDid, issuerDid, credentialSubject, validFrom, validUntil } = params;
+  const validFromISO = toISOString(validFrom);
+  const validUntilISO = validUntil ? toISOString(validUntil) : getDefaultValidUntil(validFromISO);
+  return {
+    "@context": DOMAIN_CARD_CONTEXT,
+    id: `${entityDid}#dmn`,
+    type: ["VerifiableCredential", "ixo:DomainCard"],
+    issuer: {
+      id: issuerDid
+    },
+    validFrom: validFromISO,
+    validUntil: validUntilISO,
+    credentialSchema: DOMAIN_CARD_SCHEMA,
+    credentialSubject: {
+      ...credentialSubject,
+      // Ensure the subject ID matches the entity DID
+      id: entityDid
+    }
+  };
+}
+function buildDomainCardLinkedResource(params) {
+  return {
+    id: `${params.entityDid}#dmn`,
+    type: "domainCard",
+    proof: params.cid,
+    right: "",
+    encrypted: "false",
+    mediaType: "application/json",
+    description: params.description || "Domain Card",
+    serviceEndpoint: params.serviceEndpoint
+  };
 }
-function extractSurveyAnswersTemplate(surveyDef) {
-  const fields = {};
-  for (const page of surveyDef.pages) {
-    extractFieldsFromElements(page.elements, fields);
+
+// src/core/lib/domainCard/buildLinkedEntityResource.ts
+function parseLinkedEntities(entitiesString) {
+  if (!entitiesString || entitiesString === "[]") return [];
+  try {
+    return JSON.parse(entitiesString);
+  } catch {
+    return [];
   }
-  return fields;
 }
+function buildGovernanceGroupLinkedEntities(linkedEntities) {
+  return linkedEntities.filter((entity) => entity.type === "governanceGroup" && entity.coreAddress).map((entity) => ({
+    id: entity.coreAddress,
+    type: "group",
+    relationship: "governs",
+    service: ""
+  }));
+}
+
+// src/core/lib/domainCard/defaultSurvey.ts
+var tempDomainCreatorSurvey = {
+  title: "Domain Card Creation",
+  description: "This survey collects structured information required to create a Domain Card Verifiable Credential in compliance with W3C standards.",
+  pages: [
+    {
+      name: "domainDetails",
+      title: "Domain Information",
+      description: "Provide identifying and descriptive information about the domain entity represented by this credential.",
+      elements: [
+        {
+          type: "boolean",
+          name: "ixo:advancedDomainSettings",
+          title: "Show Advanced Options",
+          defaultValue: "false"
+        },
+        {
+          type: "dropdown",
+          name: "type_1",
+          visible: false,
+          title: "Domain Type (Primary)",
+          defaultValue: "dao",
+          choices: [
+            {
+              value: "dao",
+              text: "DAO"
+            },
+            {
+              value: "protocol",
+              text: "Protocol"
+            }
+          ]
+        },
+        {
+          type: "dropdown",
+          name: "type_2",
+          title: "Domain Type ",
+          isRequired: true,
+          choicesByUrl: {
+            url: "https://test.studio.ixo.earth/api/survey-choices?url=https://raw.githubusercontent.com/ixofoundation/ns/refs/heads/GraemeLeightonIXO-patch-4/protocol/entities/v1/index.json&path=entities.dao.types",
+            valueName: "Value",
+            titleName: "Text"
+          }
+        },
+        {
+          type: "dropdown",
+          name: "daoType",
+          title: "DAO Type",
+          isRequired: true,
+          choicesByUrl: {
+            url: "https://test.studio.ixo.earth/api/survey-choices?url=https://raw.githubusercontent.com/ixofoundation/ns/refs/heads/GraemeLeightonIXO-patch-4/protocol/tags/v1/index.json&path=daoType",
+            valueName: "Value",
+            titleName: "Text"
+          }
+        },
+        {
+          type: "text",
+          name: "schema:validFrom",
+          title: "Valid From",
+          defaultValueExpression: "today()",
+          isRequired: true,
+          inputType: "date"
+        },
+        {
+          type: "text",
+          name: "schema:validUntil",
+          title: "Vaid Untill",
+          defaultValueExpression: "today()",
+          isRequired: true,
+          inputType: "date"
+        },
+        {
+          type: "text",
+          name: "schema:name",
+          title: "Domain Name",
+          description: "The official name of the domain.",
+          isRequired: true
+        },
+        {
+          type: "paneldynamic",
+          name: "pannel_schema:alternateName",
+          title: "Alternate Names",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:alternateName",
+              title: "Alternate Name"
+            }
+          ]
+        },
+        {
+          type: "text",
+          name: "schema:url",
+          title: "URL",
+          description: "Primary URL for the domain",
+          inputType: "url"
+        },
+        {
+          type: "paneldynamic",
+          name: "schema:sameAs",
+          title: "Additional URLs",
+          description: "Additional URLs associated with the domain (Twitter, Github, Medium)",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:sameAs.url",
+              title: "URL",
+              inputType: "url"
+            }
+          ]
+        },
+        {
+          type: "comment",
+          name: "schema.description",
+          title: "Canonical Description",
+          description: "A concise, one-paragraph description of the domain.",
+          isRequired: true
+        },
+        {
+          type: "panel",
+          name: "pannel_schema:media",
+          title: "Domain Images",
+          elements: [
+            {
+              type: "text",
+              name: "ixo:imageProfile_url",
+              title: "Profile Image URL",
+              inputType: "url"
+            },
+            {
+              type: "file",
+              name: "ixo:imageProfile",
+              title: "Profile Image"
+            },
+            {
+              type: "text",
+              name: "ixo:imageLogo_url",
+              title: "Logo URL",
+              inputType: "url"
+            },
+            {
+              type: "file",
+              name: "ixo:imageLogo",
+              title: "Logo"
+            }
+          ]
+        },
+        {
+          type: "comment",
+          name: "schema:keywords",
+          title: "Keywords",
+          description: "List of  comma separated keywords describing the domain\u2019s focus areas."
+        },
+        {
+          type: "paneldynamic",
+          name: "pannel_ixo:knowsAbout",
+          title: "Topics /Primary Knowledge Areas",
+          description: "Subjects or fields the domain is knowledgeable in.",
+          templateElements: [
+            {
+              type: "text",
+              name: "ixo:knowsAbout",
+              title: "Knows About"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "contactAndLocation",
+      visibleIf: "{ixo:advancedDomainSettings} = true",
+      title: "Contact & Location",
+      description: "Provide address and contact information for the domain.",
+      elements: [
+        {
+          type: "panel",
+          name: "schema:address",
+          title: "Postal Address",
+          elements: [
+            {
+              type: "text",
+              name: "schema:streetAddress",
+              title: "Street Address"
+            },
+            {
+              type: "text",
+              name: "schema:addressLocality",
+              title: "City"
+            },
+            {
+              type: "text",
+              name: "schema:addressRegion",
+              title: "Region/State"
+            },
+            {
+              type: "text",
+              name: "schema:postalCode",
+              title: "Postal Code"
+            },
+            {
+              type: "text",
+              name: "schema:addressCountry",
+              title: "Country"
+            }
+          ]
+        },
+        {
+          type: "text",
+          name: "schema:AdministrativeArea",
+          title: "Area Served"
+        },
+        {
+          type: "paneldynamic",
+          name: "pannel:schema_contactPoint",
+          title: "Contact Points",
+          description: "List available contact methods for support, business, or technical inquiries.",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:contactType",
+              title: "Contact Type",
+              description: "Example: General, Support, Sales"
+            },
+            {
+              type: "text",
+              name: "schema:email",
+              title: "Email Address",
+              inputType: "email"
+            },
+            {
+              type: "text",
+              name: "schema:telephone",
+              title: "Telephone ",
+              inputType: "tel"
+            },
+            {
+              type: "text",
+              name: "schema:availableLanguage",
+              title: "Languages Supported",
+              description: "Comma separated two letter language code (English = en)"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "composition",
+      visibleIf: "{ixo:advancedDomainSettings} = true",
+      title: "Composition",
+      elements: [
+        {
+          type: "paneldynamic",
+          name: "schema:hasPart",
+          title: "Domain Components",
+          description: "Describes the specific items, documents, linked domains, or components that belong to this domain.",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:hasPart.id",
+              title: "Identifier",
+              description: "URI or URL "
+            },
+            {
+              type: "text",
+              name: "schema:hasPart.name",
+              title: "Name"
+            },
+            {
+              type: "text",
+              name: "schema:hasPart.description",
+              title: "Description"
+            },
+            {
+              type: "text",
+              name: "schema:hasPart.url",
+              title: "URL",
+              description: "If different to the identifier",
+              inputType: "url"
+            },
+            {
+              type: "text",
+              name: "schema:hasPart.creator.name",
+              title: "Creator",
+              description: "Component creator (Organisation Name)"
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "schema:subjectOf",
+          title: "Publications",
+          description: "Publications produced by the domain or where the domain is the subject.",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:subjectOf.name",
+              title: "Publication Title"
+            },
+            {
+              type: "text",
+              name: "schema:subjectOf.url",
+              title: "URL"
+            },
+            {
+              type: "text",
+              name: "schema:subjectOf.author.name",
+              title: "Author"
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "schema:makesOffer",
+          title: "Offers (Product and/or Services)",
+          templateElements: [
+            {
+              type: "dropdown",
+              name: "schema:itemOffered.type",
+              title: "Catagory",
+              choices: [
+                {
+                  value: "product",
+                  text: "Product"
+                },
+                {
+                  value: "service",
+                  text: "Service"
+                }
+              ]
+            },
+            {
+              type: "text",
+              name: "schema:itemOffered.name",
+              title: "Name"
+            },
+            {
+              type: "text",
+              name: "schema:itemOffered.description",
+              title: "Description"
+            },
+            {
+              type: "text",
+              name: "schema:itemOffered.url",
+              title: "URL",
+              inputType: "url"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "relationshipsAndOffers",
+      visibleIf: "{ixo:advancedDomainSettings} = true",
+      title: "Relationships & Funding",
+      description: "Describe the domain\u2019s relationships with other organizations and its software or service offerings.",
+      elements: [
+        {
+          type: "paneldynamic",
+          name: "schema:memberOf",
+          title: "Memberships",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:memberOf.name",
+              title: "Organization Name"
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "schema:wasAssociatedWith",
+          title: "Partner/Associated Organizations",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:wasAssociatedWith.name",
+              title: "Organization Name"
+            },
+            {
+              type: "text",
+              name: "schema:wasAssociatedWith.url",
+              title: "URL"
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "schema:funding",
+          title: "Funding Sources",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:funder.name",
+              title: "Funder Organization"
+            },
+            {
+              type: "text",
+              name: "schema:amount.currency",
+              title: "Currency Code"
+            },
+            {
+              type: "text",
+              name: "schema:amount.value",
+              title: "Funding Amount"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "events",
+      visibleIf: "{ixo:advancedDomainSettings} = true",
+      title: "Events",
+      elements: [
+        {
+          type: "paneldynamic",
+          name: "schema:event",
+          title: "Event",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:event.name",
+              title: "Name"
+            },
+            {
+              type: "text",
+              name: "schema:startDate",
+              title: "Start Date"
+            },
+            {
+              type: "text",
+              name: "schema:endDate",
+              title: "End Date"
+            },
+            {
+              type: "text",
+              name: "schema:event.location",
+              title: "Location Name"
+            },
+            {
+              type: "panel",
+              name: "schema:event.address",
+              title: "Postal Address",
+              elements: [
+                {
+                  type: "text",
+                  name: "schema:event.streetAddress",
+                  title: "Street Address"
+                },
+                {
+                  type: "text",
+                  name: "schema:event.addressLocality",
+                  title: "City"
+                },
+                {
+                  type: "text",
+                  name: "schema:event.addressRegion",
+                  title: "Region/State"
+                },
+                {
+                  type: "text",
+                  name: "schema:event.postalCode",
+                  title: "Postal Code"
+                },
+                {
+                  type: "text",
+                  name: "schema:event.addressCountry",
+                  title: "Country"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "agentsCredentialsAndAttributes",
+      visibleIf: "{ixo:advancedDomainSettings} = true",
+      title: "Agents, Credentials, and Attributes",
+      elements: [
+        {
+          type: "paneldynamic",
+          name: "ixo:agentCard",
+          title: "Agents",
+          templateElements: [
+            {
+              type: "text",
+              name: "ixo:agentCard.id",
+              title: "Agent ID"
+            },
+            {
+              type: "text",
+              name: "ixo:agentCard.name",
+              title: "Name"
+            },
+            {
+              type: "text",
+              name: "ixo:agentCard.description",
+              title: "Description"
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "ixo:verifiableCredential",
+          title: "Credentials",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:ID",
+              title: "Credential ID"
+            },
+            {
+              type: "text",
+              name: "schema:Name",
+              title: "Name"
+            },
+            {
+              type: "text",
+              name: "schema:description",
+              title: "Description"
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "ixo:attribute",
+          title: "Attributes",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:ID_2",
+              title: "Attribute ID"
+            },
+            {
+              type: "text",
+              name: "schema:name_2",
+              title: "Name"
+            },
+            {
+              type: "text",
+              name: "schema:description_2",
+              title: "Description"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "project",
+      visibleIf: "{ixo:advancedDomainSettings} = true",
+      title: "Project Information",
+      description: "Provide details about the related project(s), including objectives, sponsors, and deliverables.",
+      elements: [
+        {
+          type: "paneldynamic",
+          name: "pannel_proj:project",
+          title: "Projects",
+          templateElements: [
+            {
+              type: "text",
+              name: "proj:project.name",
+              title: "Project Title"
+            },
+            {
+              type: "comment",
+              name: "proj:project.description",
+              title: "Project Mission",
+              description: "High-level purpose or mission statement of the project."
+            },
+            {
+              type: "paneldynamic",
+              name: "proj:project.hadObjective",
+              title: "Project Objectives",
+              templateElements: [
+                {
+                  type: "comment",
+                  name: "proj:hadObjective",
+                  title: "Project Objective"
+                }
+              ]
+            },
+            {
+              type: "text",
+              name: "proj:plannedStart",
+              title: "Planned Start Date",
+              inputType: "datetime-local"
+            },
+            {
+              type: "text",
+              name: "proj:plannedEnd",
+              title: "Planned End Date",
+              inputType: "datetime-local"
+            },
+            {
+              type: "paneldynamic",
+              name: "proj:wasFundedThrough",
+              title: "Project Funding",
+              templateElements: [
+                {
+                  type: "text",
+                  name: "proj:moneyAmount",
+                  title: "Funding Amount"
+                },
+                {
+                  type: "text",
+                  name: "proj:moneyCurrency",
+                  title: "Funding Currency"
+                },
+                {
+                  type: "text",
+                  name: "prov.agent.name",
+                  title: "Funder Name"
+                },
+                {
+                  type: "text",
+                  name: "prov:agent.id",
+                  title: "Funder URL",
+                  inputType: "url"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "researchProfile",
+      title: "Research Profile",
+      description: "Provide information about the research profile associated with the domain.",
+      elements: [
+        {
+          type: "paneldynamic",
+          name: "ixo:ResearchProfile",
+          title: "Seed Queries",
+          templateElements: [
+            {
+              type: "comment",
+              name: "ixo:seedQueries",
+              title: "Seed Query",
+              description: "Seed keywords or queries that define the research scope."
+            }
+          ]
+        },
+        {
+          type: "paneldynamic",
+          name: "schema:creativeWork",
+          title: "Citations",
+          templateElements: [
+            {
+              type: "text",
+              name: "schema:creativeWork.name",
+              title: "Citation Title"
+            },
+            {
+              type: "text",
+              name: "schema:creativeWork.url",
+              title: "Citation URL"
+            },
+            {
+              type: "text",
+              name: "schema:creativeWork.publisher",
+              title: "Publisher"
+            },
+            {
+              type: "text",
+              name: "schema:creativeWork.datePublished",
+              title: "Date Published",
+              inputType: "datetime-local"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  showPageTitles: false,
+  showQuestionNumbers: "on",
+  showProgressBar: true,
+  progressBarLocation: "top"
+};
 
-// src/core/lib/actionRegistry/actions/domainCreate.ts
+// src/core/lib/actionRegistry/actions/domainSign.ts
 registerAction({
-  type: "qi/domain.create",
-  can: "domain/create",
+  type: "qi/domain.sign",
+  can: "domain/sign",
   sideEffect: true,
   defaultRequiresConfirmation: true,
   requiredCapability: "flow/block/execute",
   outputSchema: [
-    { path: "entityDid", displayName: "Entity DID", type: "string", description: "The created domain entity DID" },
-    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "Blockchain transaction hash" },
-    { path: "credentialId", displayName: "Credential ID", type: "string", description: "The uploaded domain card credential identifier (CID)" },
-    { path: "entityType", displayName: "Entity Type", type: "string", description: "The type of domain entity created" }
+    { path: "entityDid", displayName: "Entity DID", type: "string", description: "The DID of the newly created domain entity" },
+    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The on-chain transaction hash for domain creation" }
   ],
   run: async (inputs, ctx) => {
     const handlers = ctx.handlers;
-    if (!handlers) throw new Error("Handlers not available");
+    if (!handlers) {
+      throw new Error("Handlers not available");
+    }
+    if (!handlers.requestPin) throw new Error("requestPin handler not available");
     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.requestPin) throw new Error("requestPin handler not available");
-    const configEntityType = String(inputs.entityType || "dao").trim();
-    let surveyData = {};
-    if (inputs.surveyData) {
-      if (typeof inputs.surveyData === "string") {
-        try {
-          surveyData = JSON.parse(inputs.surveyData);
-        } catch {
-          throw new Error("surveyData must be valid JSON");
-        }
-      } else if (typeof inputs.surveyData === "object" && !Array.isArray(inputs.surveyData)) {
-        surveyData = inputs.surveyData;
+    let domainCardData;
+    if (typeof inputs.domainCardData === "string") {
+      try {
+        domainCardData = JSON.parse(inputs.domainCardData);
+      } catch {
+        throw new Error("domainCardData must be valid JSON");
       }
+    } else if (inputs.domainCardData && typeof inputs.domainCardData === "object") {
+      domainCardData = inputs.domainCardData;
+    } else {
+      throw new Error("domainCardData is required");
+    }
+    if (!domainCardData?.credentialSubject?.name) {
+      throw new Error("domainCardData is missing or invalid (credentialSubject.name required)");
     }
+    const extractEntityType = (type) => type.replace(/^schema:/i, "").toLowerCase();
+    const entityType = String(inputs.entityType || "").trim() || (domainCardData.credentialSubject?.type?.[0] ? extractEntityType(domainCardData.credentialSubject.type[0]) : "dao");
     const issuerDid = handlers.getEntityDid?.() || handlers.getCurrentUser?.()?.address;
     if (!issuerDid) throw new Error("Unable to determine issuer DID");
-    const entityDid = "did:ixo:entity:pending";
-    const credentialSubject = transformSurveyToCredentialSubject(surveyData, entityDid);
+    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();
+    })();
+    const credentialSubject = {
+      ...domainCardData.credentialSubject,
+      id: entityDidPlaceholder
+    };
     const unsignedCredential = buildVerifiableCredential({
-      entityDid,
+      entityDid: entityDidPlaceholder,
       issuerDid,
       credentialSubject,
-      validFrom: surveyData["schema:validFrom"] || (/* @__PURE__ */ new Date()).toISOString(),
-      validUntil: surveyData["schema:validUntil"]
+      validFrom,
+      validUntil
     });
     const pin = await handlers.requestPin({
       title: "Sign Domain Card",
@@ -1526,24 +2267,160 @@ registerAction({
     });
     const uploadResult = await handlers.publicFileUpload(credentialFile);
     const domainCardLinkedResource = buildDomainCardLinkedResource({
-      entityDid,
+      entityDid: entityDidPlaceholder,
       cid: uploadResult.cid,
       serviceEndpoint: uploadResult.url,
-      description: `Domain Card for ${surveyData["schema:name"] || "Domain"}`
+      description: `Domain Card for ${domainCardData.credentialSubject?.name || "Domain"}`
     });
-    const finalEntityType = surveyData["type_2"] || surveyData["daoType"] || configEntityType;
+    let linkedEntitiesData = [];
+    if (inputs.linkedEntities) {
+      if (typeof inputs.linkedEntities === "string") {
+        try {
+          linkedEntitiesData = JSON.parse(inputs.linkedEntities);
+        } catch {
+        }
+      } else if (Array.isArray(inputs.linkedEntities)) {
+        linkedEntitiesData = inputs.linkedEntities;
+      }
+    }
+    const governanceGroupLinkedEntities = buildGovernanceGroupLinkedEntities(parseLinkedEntities(JSON.stringify(linkedEntitiesData)));
+    const endDate = domainCardData.endDate || validUntil;
     const { entityDid: newEntityDid, transactionHash } = await handlers.createDomain({
-      entityType: finalEntityType,
+      entityType,
       linkedResource: [domainCardLinkedResource],
-      startDate: surveyData["schema:validFrom"],
-      endDate: surveyData["schema:validUntil"]
+      linkedEntity: governanceGroupLinkedEntities.length > 0 ? governanceGroupLinkedEntities : void 0,
+      startDate: validFrom,
+      endDate
     });
     return {
       output: {
         entityDid: newEntityDid,
-        transactionHash,
-        credentialId: uploadResult.cid,
-        entityType: finalEntityType
+        transactionHash
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/domainCardBuild.ts
+registerAction({
+  type: "qi/domain.card-build",
+  can: "domain/card-build",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  outputSchema: [
+    {
+      path: "domainCardData",
+      displayName: "Domain Card Data",
+      type: "object",
+      description: "Unsigned domain card envelope { credentialSubject, validFrom, validUntil } ready for preview and signing"
+    },
+    { path: "unsignedCredential", displayName: "Unsigned Credential", type: "object", description: "The full unsigned W3C Verifiable Credential" },
+    { path: "credentialSubject", displayName: "Credential Subject", type: "object", description: "The ixo:DomainCard credentialSubject extracted from the survey" },
+    { path: "surveyData", displayName: "Survey Answers", type: "object", description: "Raw survey answers used to build the card" },
+    { path: "entityType", displayName: "Entity Type", type: "string", description: "Resolved entity type (from survey or configured default)" },
+    { path: "issuerDid", displayName: "Issuer DID", type: "string", description: "DID of the user or entity that built the card" }
+  ],
+  run: async (inputs, ctx) => {
+    const handlers = ctx.handlers;
+    if (!handlers) throw new Error("Handlers not available");
+    const configEntityType = String(inputs.entityType || "dao").trim();
+    let surveyData = {};
+    if (inputs.surveyData) {
+      if (typeof inputs.surveyData === "string") {
+        try {
+          surveyData = JSON.parse(inputs.surveyData);
+        } catch {
+          throw new Error("surveyData must be valid JSON");
+        }
+      } else if (typeof inputs.surveyData === "object" && !Array.isArray(inputs.surveyData)) {
+        surveyData = inputs.surveyData;
+      }
+    }
+    if (!surveyData || Object.keys(surveyData).length === 0) {
+      throw new Error("surveyData is required to build a domain card");
+    }
+    const issuerDid = handlers.getEntityDid?.() || handlers.getCurrentUser?.()?.address;
+    if (!issuerDid) throw new Error("Unable to determine issuer DID");
+    const entityDidPlaceholder = "did:ixo:entity:pending";
+    const credentialSubject = transformSurveyToCredentialSubject(surveyData, entityDidPlaceholder);
+    const validFrom = surveyData["schema:validFrom"] || (/* @__PURE__ */ new Date()).toISOString();
+    const validUntil = surveyData["schema:validUntil"] || (() => {
+      const d = new Date(validFrom);
+      d.setFullYear(d.getFullYear() + 5);
+      return d.toISOString();
+    })();
+    const unsignedCredential = buildVerifiableCredential({
+      entityDid: entityDidPlaceholder,
+      issuerDid,
+      credentialSubject,
+      validFrom,
+      validUntil
+    });
+    const resolvedEntityType = surveyData["type_2"] || surveyData["daoType"] || configEntityType;
+    const domainCardData = {
+      credentialSubject,
+      validFrom,
+      validUntil
+    };
+    return {
+      output: {
+        domainCardData,
+        unsignedCredential,
+        credentialSubject,
+        surveyData,
+        entityType: resolvedEntityType,
+        issuerDid
+      }
+    };
+  }
+});
+
+// src/core/lib/actionRegistry/actions/domainCardPreview.ts
+registerAction({
+  type: "qi/domain.card-preview",
+  can: "domain/card-preview",
+  sideEffect: false,
+  defaultRequiresConfirmation: false,
+  outputSchema: [
+    {
+      path: "domainCardData",
+      displayName: "Domain Card Data",
+      type: "object",
+      description: "Approved domain card envelope { credentialSubject, validFrom, validUntil } ready to sign"
+    },
+    { path: "domainPreviewData", displayName: "Preview Data", type: "object", description: "Oracle-enriched human-facing preview of the domain card" },
+    { path: "status", displayName: "Status", type: "string", description: "pending | loading | ready | approved | error" },
+    { path: "approvedAt", displayName: "Approved At", type: "number", description: "Timestamp when the user approved the preview" }
+  ],
+  run: async (inputs) => {
+    let domainCardData = inputs.domainCardData;
+    if (typeof domainCardData === "string") {
+      try {
+        domainCardData = JSON.parse(domainCardData);
+      } catch {
+        throw new Error("domainCardData must be valid JSON");
+      }
+    }
+    if (!domainCardData || typeof domainCardData !== "object") {
+      throw new Error("domainCardData is required to preview a domain card");
+    }
+    if (!domainCardData.credentialSubject?.name) {
+      throw new Error("domainCardData.credentialSubject.name is required");
+    }
+    let domainPreviewData = inputs.domainPreviewData;
+    if (typeof domainPreviewData === "string") {
+      try {
+        domainPreviewData = JSON.parse(domainPreviewData);
+      } catch {
+        domainPreviewData = void 0;
+      }
+    }
+    return {
+      output: {
+        domainCardData,
+        domainPreviewData,
+        status: "approved",
+        approvedAt: Date.now()
       }
     };
   }
@@ -2990,6 +3867,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 +3904,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 +4075,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 = {};
@@ -3301,7 +4239,8 @@ var ICON_DEFAULTS = {
   "matrix/dm": "message-circle",
   "proposal/create": "scroll",
   "proposal/vote": "vote",
-  "domain/create": "globe",
+  "domain/card-build": "file-text",
+  "domain/card-preview": "id",
   "domain/sign": "feather",
   "credential/store": "shield",
   "payment/execute": "credit-card",
@@ -4140,12 +5079,7 @@ export {
   buildServicesFromHandlers,
   getDiffResolver,
   hasDiffResolver,
-  buildVerifiableCredential,
-  buildDomainCardLinkedResource,
-  parseLinkedEntities,
-  buildGovernanceGroupLinkedEntities,
-  transformSurveyToCredentialSubject,
-  extractSurveyAnswersTemplate,
+  tempDomainCreatorSurvey,
   getHomeserver,
   didToMatrixUserId,
   findOrCreateDMRoom,
@@ -4163,9 +5097,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 +5122,4 @@ export {
   readFlow,
   setupFlowFromBaseUcan
 };
-//# sourceMappingURL=chunk-QIJA3CMG.mjs.map
+//# sourceMappingURL=chunk-4ETFMWQR.mjs.map