@ixo/editor 3.9.0 → 4.0.1

package/dist/{chunk-JHQO6FAQ.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",
@@ -347,10 +356,13 @@ registerAction({
   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(", ")}`);
@@ -359,8 +371,11 @@ registerAction({
     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");
+      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)");
@@ -371,7 +386,7 @@ registerAction({
         throw new Error("threshold + vetoThreshold cannot exceed 1.0");
       }
     }
-    return { output: { groupType, governance } };
+    return { output: { groupName, groupType, governance } };
   }
 });
 
@@ -1169,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 [];
@@ -1605,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
   }
-}
-function extractSurveyAnswersTemplate(surveyDef) {
-  const fields = {};
-  for (const page of surveyDef.pages) {
-    extractFieldsFromElements(page.elements, fields);
+];
+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 fields;
+  return fallback.toISOString();
 }
-
-// src/core/lib/actionRegistry/actions/domainCreate.ts
-registerAction({
-  type: "qi/domain.create",
-  can: "domain/create",
-  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" }
-  ],
-  run: async (inputs, ctx) => {
-    const handlers = ctx.handlers;
-    if (!handlers) throw new Error("Handlers 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");
+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/core/lib/domainCard/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/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"
+            }
+          ]
         }
-      } else if (typeof inputs.surveyData === "object" && !Array.isArray(inputs.surveyData)) {
-        surveyData = inputs.surveyData;
+      ]
+    },
+    {
+      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/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 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",
@@ -1710,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()
       }
     };
   }
@@ -3546,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",
@@ -4385,12 +5079,7 @@ export {
   buildServicesFromHandlers,
   getDiffResolver,
   hasDiffResolver,
-  buildVerifiableCredential,
-  buildDomainCardLinkedResource,
-  parseLinkedEntities,
-  buildGovernanceGroupLinkedEntities,
-  transformSurveyToCredentialSubject,
-  extractSurveyAnswersTemplate,
+  tempDomainCreatorSurvey,
   getHomeserver,
   didToMatrixUserId,
   findOrCreateDMRoom,
@@ -4433,4 +5122,4 @@ export {
   readFlow,
   setupFlowFromBaseUcan
 };
-//# sourceMappingURL=chunk-JHQO6FAQ.mjs.map
+//# sourceMappingURL=chunk-4ETFMWQR.mjs.map