@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-PYNDJDWZ.js

@@ -0,0 +1,1758 @@
+import {
+  doneWhenCompleted,
+  getAction,
+  registerAction
+} from "./chunk-IIIZZ4E4.js";
+import {
+  warnOnce
+} from "./chunk-HT6L7A5M.js";
+
+// src/core/lib/actionRegistry/inputRequirements.ts
+function isBlankInputValue(value) {
+  if (value == null) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function parseMaybeJsonObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function dedupe(values) {
+  return Array.from(new Set(values.filter((value) => typeof value === "string" && value.length > 0)));
+}
+function getMissingActionInputs(actionType, inputs) {
+  if (!actionType) return [];
+  const action = getAction(actionType);
+  if (!action) return [];
+  const merged = inputs ?? {};
+  if (action.getMissingInputs) {
+    try {
+      return dedupe(action.getMissingInputs(merged) || []);
+    } catch (error) {
+      warnOnce(
+        `missing-inputs:${action.type}`,
+        `[flow-config] action ${action.type}: getMissingInputs threw (${error instanceof Error ? error.message : String(error)}); reporting no missing inputs`
+      );
+      return [];
+    }
+  }
+  const schema = action.inputSchema;
+  const required = Array.isArray(schema?.required) ? schema.required.filter((name) => typeof name === "string") : [];
+  return dedupe(required.filter((name) => isBlankInputValue(merged[name])));
+}
+
+// src/core/lib/domainCard/transformSurveyToCredentialSubject.ts
+function extractPanelDynamicItems(surveyData, panelName, itemMapper) {
+  const items = surveyData[panelName];
+  if (!Array.isArray(items)) return [];
+  return items.map(itemMapper).filter((item) => item !== null);
+}
+function parseCommaSeparated(value) {
+  if (!value || typeof value !== "string") return [];
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseLanguageCodes(value) {
+  return parseCommaSeparated(value);
+}
+function buildImageObject(url) {
+  if (!url) return null;
+  return {
+    type: "schema:ImageObject",
+    id: url,
+    contentUrl: url
+  };
+}
+function transformSurveyToCredentialSubject(surveyData, entityDid) {
+  const types = [];
+  if (surveyData["type_1"]) types.push(`ixo:${surveyData["type_1"]}`);
+  if (surveyData["type_2"]) types.push(surveyData["type_2"]);
+  const additionalType = [];
+  if (surveyData["daoType"]) additionalType.push(surveyData["daoType"]);
+  const alternateNames = extractPanelDynamicItems(surveyData, "pannel_schema:alternateName", (item) => item["schema:alternateName"] || null);
+  const sameAsUrls = extractPanelDynamicItems(surveyData, "schema:sameAs", (item) => item["schema:sameAs.url"] || null);
+  const logoUrl = surveyData["ixo:imageLogo_url"] || surveyData["ixo:imageLogo"]?.[0]?.content;
+  const logo = buildImageObject(logoUrl);
+  const profileImageUrl = surveyData["ixo:imageProfile_url"] || surveyData["ixo:imageProfile"]?.[0]?.content;
+  const profileImage = buildImageObject(profileImageUrl);
+  const keywords = parseCommaSeparated(surveyData["schema:keywords"]);
+  const knowsAbout = extractPanelDynamicItems(surveyData, "pannel_ixo:knowsAbout", (item) => item["ixo:knowsAbout"] || null);
+  const hasAddressData = surveyData["schema:streetAddress"] || surveyData["schema:addressLocality"] || surveyData["schema:addressRegion"] || surveyData["schema:postalCode"] || surveyData["schema:addressCountry"];
+  const address = hasAddressData ? {
+    type: "schema:PostalAddress",
+    streetAddress: surveyData["schema:streetAddress"] || void 0,
+    addressLocality: surveyData["schema:addressLocality"] || void 0,
+    addressRegion: surveyData["schema:addressRegion"] || void 0,
+    postalCode: surveyData["schema:postalCode"] || void 0,
+    addressCountry: surveyData["schema:addressCountry"] || void 0
+  } : void 0;
+  const areaServed = surveyData["schema:AdministrativeArea"] ? {
+    type: "schema:AdministrativeArea",
+    name: surveyData["schema:AdministrativeArea"]
+  } : void 0;
+  const contactPoints = extractPanelDynamicItems(surveyData, "pannel:schema_contactPoint", (item) => {
+    if (!item["schema:contactType"] && !item["schema:email"] && !item["schema:telephone"]) return null;
+    return {
+      type: "schema:ContactPoint",
+      contactType: item["schema:contactType"] || "general",
+      email: item["schema:email"] || void 0,
+      telephone: item["schema:telephone"] || void 0,
+      availableLanguage: parseLanguageCodes(item["schema:availableLanguage"])
+    };
+  });
+  const hasParts = extractPanelDynamicItems(surveyData, "schema:hasPart", (item) => {
+    if (!item["schema:hasPart.name"] && !item["schema:hasPart.id"]) return null;
+    return {
+      type: "schema:CreativeWork",
+      id: item["schema:hasPart.id"] || void 0,
+      name: item["schema:hasPart.name"] || void 0,
+      description: item["schema:hasPart.description"] || void 0,
+      url: item["schema:hasPart.url"] || void 0,
+      creator: item["schema:hasPart.creator.name"] ? {
+        type: "schema:Organization",
+        name: item["schema:hasPart.creator.name"]
+      } : void 0
+    };
+  });
+  const subjectOf = extractPanelDynamicItems(surveyData, "schema:subjectOf", (item) => {
+    if (!item["schema:subjectOf.name"]) return null;
+    return {
+      type: "schema:CreativeWork",
+      name: item["schema:subjectOf.name"],
+      url: item["schema:subjectOf.url"] || void 0,
+      author: item["schema:subjectOf.author.name"] ? {
+        type: "schema:Organisation",
+        name: item["schema:subjectOf.author.name"]
+      } : void 0
+    };
+  });
+  const composition = hasParts.length > 0 || subjectOf.length > 0 ? {
+    type: "schema:Collection",
+    hasPart: hasParts.length > 0 ? hasParts : void 0,
+    subjectOf: subjectOf.length > 0 ? subjectOf : void 0
+  } : void 0;
+  const makesOffer = extractPanelDynamicItems(surveyData, "schema:makesOffer", (item) => {
+    if (!item["schema:itemOffered.name"]) return null;
+    return {
+      type: "schema:Offer",
+      itemOffered: {
+        type: item["schema:itemOffered.type"] === "service" ? "schema:Service" : "schema:Product",
+        name: item["schema:itemOffered.name"] || void 0,
+        description: item["schema:itemOffered.description"] || void 0,
+        url: item["schema:itemOffered.url"] || void 0
+      }
+    };
+  });
+  const memberOf = extractPanelDynamicItems(surveyData, "schema:memberOf", (item) => {
+    if (!item["schema:memberOf.name"]) return null;
+    return {
+      type: "schema:Organization",
+      name: item["schema:memberOf.name"]
+    };
+  });
+  const wasAssociatedWith = extractPanelDynamicItems(surveyData, "schema:wasAssociatedWith", (item) => {
+    if (!item["schema:wasAssociatedWith.name"]) return null;
+    return {
+      type: "schema:Organization",
+      name: item["schema:wasAssociatedWith.name"],
+      url: item["schema:wasAssociatedWith.url"] || void 0
+    };
+  });
+  const funding = extractPanelDynamicItems(surveyData, "schema:funding", (item) => {
+    if (!item["schema:funder.name"]) return null;
+    return {
+      type: "schema:MonetaryGrant",
+      funder: {
+        type: "schema:Organization",
+        name: item["schema:funder.name"]
+      },
+      amount: item["schema:amount.value"] || item["schema:amount.currency"] ? {
+        type: "schema:MonetaryAmount",
+        currency: item["schema:amount.currency"] || "USD",
+        value: item["schema:amount.value"] || "0"
+      } : void 0
+    };
+  });
+  const relationships = memberOf.length > 0 || wasAssociatedWith.length > 0 || funding.length > 0 ? {
+    memberOf: memberOf.length > 0 ? memberOf : void 0,
+    "prov:wasAssociatedWith": wasAssociatedWith.length > 0 ? wasAssociatedWith : void 0,
+    funding: funding.length > 0 ? funding : void 0
+  } : void 0;
+  const agents = extractPanelDynamicItems(surveyData, "ixo:agentCard", (item) => {
+    if (!item["ixo:agentCard.name"] && !item["ixo:agentCard.id"]) return null;
+    return {
+      type: "ixo:AgentCard",
+      id: item["ixo:agentCard.id"] || void 0,
+      name: item["ixo:agentCard.name"] || void 0,
+      description: item["ixo:agentCard.description"] || void 0
+    };
+  });
+  const credentials = extractPanelDynamicItems(surveyData, "ixo:verifiableCredential", (item) => {
+    if (!item["schema:Name"] && !item["schema:ID"]) return null;
+    return {
+      type: "VerifiableCredential",
+      id: item["schema:ID"] || void 0,
+      name: item["schema:Name"] || void 0,
+      description: item["schema:description"] || void 0
+    };
+  });
+  const attributes = extractPanelDynamicItems(surveyData, "ixo:attribute", (item) => {
+    if (!item["schema:name_2"]) return null;
+    return {
+      "@type": "ixo:Attribute",
+      "@id": item["schema:ID_2"] || `attribute:${item["schema:name_2"].replace(/\s+/g, "_").toLowerCase()}`,
+      name: item["schema:name_2"],
+      value: item["schema:description_2"] || ""
+    };
+  });
+  const projects = extractPanelDynamicItems(surveyData, "pannel_proj:project", (item) => {
+    if (!item["proj:project.name"]) return null;
+    const objectives = extractPanelDynamicItems(item, "proj:project.hadObjective", (objItem) => objItem["proj:hadObjective"] || null);
+    const projectFunding = extractPanelDynamicItems(item, "proj:wasFundedThrough", (fundItem) => ({
+      type: "proj:FundingAssociation",
+      moneyAmount: fundItem["proj:moneyAmount"] || void 0,
+      moneyCurrency: fundItem["proj:moneyCurrency"] || void 0,
+      agent: fundItem["prov.agent.name"] || fundItem["prov:agent.id"] ? {
+        type: "prov:Agent",
+        id: fundItem["prov:agent.id"] || void 0,
+        name: fundItem["prov.agent.name"] || void 0
+      } : void 0
+    }));
+    return {
+      type: "proj:Project",
+      name: item["proj:project.name"],
+      description: item["proj:project.description"] || void 0,
+      hadObjective: objectives.length > 0 ? objectives : void 0,
+      plannedStart: item["proj:plannedStart"] || void 0,
+      plannedEnd: item["proj:plannedEnd"] || void 0,
+      wasFundedThrough: projectFunding.length > 0 ? projectFunding : void 0
+    };
+  });
+  const project = projects.length > 0 ? projects[0] : void 0;
+  const seedQueries = extractPanelDynamicItems(surveyData, "ixo:ResearchProfile", (item) => item["ixo:seedQueries"] || null);
+  const citations = extractPanelDynamicItems(surveyData, "schema:creativeWork", (item) => {
+    if (!item["schema:creativeWork.name"]) return null;
+    return {
+      type: "schema:CreativeWork",
+      name: item["schema:creativeWork.name"],
+      url: item["schema:creativeWork.url"] || void 0,
+      publisher: item["schema:creativeWork.publisher"] || void 0,
+      datePublished: item["schema:creativeWork.datePublished"] || void 0
+    };
+  });
+  const researchProfile = seedQueries.length > 0 || citations.length > 0 ? {
+    type: "ixo:ResearchProfile",
+    "ixo:seedQueries": seedQueries.length > 0 ? seedQueries : void 0,
+    citation: citations.length > 0 ? citations : void 0,
+    dateModified: (/* @__PURE__ */ new Date()).toISOString()
+  } : void 0;
+  const credentialSubject = {
+    id: entityDid,
+    type: types.length > 0 ? types : ["ixo:dao"],
+    name: surveyData["schema:name"] || "",
+    description: surveyData["schema.description"] || ""
+  };
+  if (additionalType.length > 0) credentialSubject.additionalType = additionalType;
+  if (alternateNames.length > 0) credentialSubject.alternateName = alternateNames;
+  if (surveyData["schema:url"]) credentialSubject.url = surveyData["schema:url"];
+  if (sameAsUrls.length > 0) credentialSubject.sameAs = sameAsUrls;
+  if (logo) credentialSubject.logo = logo;
+  if (profileImage) credentialSubject.image = [profileImage];
+  if (keywords.length > 0) credentialSubject.keywords = keywords;
+  if (knowsAbout.length > 0) credentialSubject.knowsAbout = knowsAbout;
+  if (address) credentialSubject.address = address;
+  if (areaServed) credentialSubject.areaServed = areaServed;
+  if (contactPoints.length > 0) credentialSubject.contactPoint = contactPoints;
+  if (composition) credentialSubject.composition = composition;
+  if (makesOffer.length > 0) credentialSubject.makesOffer = makesOffer;
+  if (relationships) credentialSubject.relationships = relationships;
+  if (agents.length > 0) credentialSubject.agents = agents;
+  if (credentials.length > 0) credentialSubject.credentials = credentials;
+  if (attributes.length > 0) credentialSubject.attributes = attributes;
+  if (project) credentialSubject.project = project;
+  if (researchProfile) credentialSubject.researchProfile = researchProfile;
+  return credentialSubject;
+}
+
+// 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
+  };
+}
+
+// src/core/lib/domainCard/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);
+    }
+  }
+}
+function extractSurveyAnswersTemplate(surveyDef) {
+  const fields = {};
+  for (const page of surveyDef.pages) {
+    extractFieldsFromElements(page.elements, fields);
+  }
+  return fields;
+}
+
+// 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: `{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/domainSign.ts
+function resolveEntityTypeFromSchema(schemaType) {
+  const normalized = schemaType.replace(/^schema:/i, "").toLowerCase();
+  const schemaToEntity = {
+    organization: "dao/pod",
+    nonprofit: "dao/pod",
+    corporation: "dao/pod",
+    governmentorganization: "dao/pod"
+  };
+  if (schemaToEntity[normalized]) return schemaToEntity[normalized];
+  const allowed = /* @__PURE__ */ new Set(["dao/pod", "protocol", "oracle", "investment", "project", "asset"]);
+  return allowed.has(normalized) ? normalized : "dao/pod";
+}
+function parseJsonInput(value) {
+  if (!value) return null;
+  if (typeof value === "object" && !Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function parseContextInput(value) {
+  let raw = value;
+  if (typeof value === "string") {
+    try {
+      raw = JSON.parse(value);
+    } catch {
+      raw = [];
+    }
+  }
+  if (!Array.isArray(raw)) return [];
+  return raw.map((entry) => {
+    if (!entry || typeof entry !== "object") return null;
+    const key = String(entry.key || "").trim();
+    const val = String(entry.val || "").trim();
+    return key && val ? { key, val } : null;
+  }).filter((entry) => entry !== null);
+}
+function getSelectedProtocolTemplates(flowTemplateConfig) {
+  const raw = flowTemplateConfig?.selectedTemplates;
+  if (!Array.isArray(raw)) return [];
+  return raw.map((item) => {
+    if (!item || typeof item !== "object") return null;
+    const record = item;
+    const protocolDid = String(record.protocolDid || "").trim();
+    const sourceRoomId = String(record.sourceRoomId || "").trim();
+    if (!protocolDid || !sourceRoomId) return null;
+    const sourceLabel = String(record.sourceLabel || record.label || "").trim();
+    return {
+      protocolDid,
+      sourceRoomId,
+      ...sourceLabel ? { sourceLabel } : {}
+    };
+  }).filter((item) => item !== null);
+}
+function groupTemplatesByProtocol(templates) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const existing = grouped.get(template.protocolDid) || [];
+    existing.push({
+      sourceRoomId: template.sourceRoomId,
+      ...template.sourceLabel ? { sourceLabel: template.sourceLabel } : {}
+    });
+    grouped.set(template.protocolDid, existing);
+  }
+  return grouped;
+}
+var DOMAIN_SIGN_CACHE_KEY = "domainSign";
+function getDomainSignCheckpointKey(inputs, ctx) {
+  return String(ctx.pendingInvocation?.id || inputs.pendingInvocationId || inputs.invocationId || "manual");
+}
+function readDomainSignCheckpoint(ctx, key) {
+  const cache = ctx.runtime?.get?.(ctx.nodeId)?.cache;
+  const bucket = cache?.[DOMAIN_SIGN_CACHE_KEY];
+  if (!bucket || typeof bucket !== "object") return void 0;
+  const checkpoint = bucket[key];
+  return checkpoint && typeof checkpoint === "object" ? checkpoint : void 0;
+}
+function writeDomainSignCheckpoint(ctx, key, checkpoint) {
+  if (!ctx.runtime?.get || !ctx.runtime?.update || !ctx.nodeId) return;
+  const current = ctx.runtime.get(ctx.nodeId) || {};
+  const cache = current.cache && typeof current.cache === "object" ? current.cache : {};
+  const bucket = cache[DOMAIN_SIGN_CACHE_KEY] && typeof cache[DOMAIN_SIGN_CACHE_KEY] === "object" ? cache[DOMAIN_SIGN_CACHE_KEY] : {};
+  ctx.runtime.update(ctx.nodeId, {
+    cache: {
+      ...cache,
+      [DOMAIN_SIGN_CACHE_KEY]: {
+        ...bucket,
+        [key]: checkpoint
+      }
+    }
+  });
+}
+function buildCompletedDomainSignResult(output) {
+  const payload = {
+    entityDid: output.entityDid,
+    governanceGroupCoreAddress: output.governanceGroupCoreAddress || "",
+    transactionHash: output.transactionHash || "",
+    linkedResourceTransactionHash: output.linkedResourceTransactionHash || "",
+    ...output.parentLinkedEntityTransactionHash ? { parentLinkedEntityTransactionHash: output.parentLinkedEntityTransactionHash } : {}
+  };
+  return {
+    output,
+    events: [
+      {
+        name: "created",
+        payload
+      }
+    ]
+  };
+}
+function readDidInput(value) {
+  if (typeof value !== "string") return "";
+  const did = value.trim();
+  if (!did || did === "null" || did === "undefined") return "";
+  return did.startsWith("did:") ? did : "";
+}
+function getSelectedParentEntityDid(inputs) {
+  if (inputs.skipped === true || inputs.parentSkipped === true) return "";
+  return readDidInput(inputs.selectedEntityDid) || readDidInput(inputs.parentDid) || readDidInput(inputs.parentDID);
+}
+var MAX_PIN_ATTEMPTS = 3;
+function isInvalidPinError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /invalid pin|could not decrypt mnemonic/i.test(msg);
+}
+function parseDuration(raw) {
+  const seconds = parseInt(raw, 10) || 0;
+  if (seconds % (7 * 86400) === 0) return { amount: seconds / (7 * 86400), unit: "weeks" };
+  if (seconds % 86400 === 0) return { amount: seconds / 86400, unit: "days" };
+  if (seconds % 3600 === 0) return { amount: seconds / 3600, unit: "hours" };
+  if (seconds % 60 === 0) return { amount: seconds / 60, unit: "minutes" };
+  return { amount: seconds, unit: "seconds" };
+}
+function buildGroupConfig(groupType, governance, memberConfig) {
+  const duration = parseDuration(governance.votingPeriod || "604800s");
+  const thresholdNum = parseFloat(governance.threshold || "0.51");
+  const quorumNum = parseFloat(governance.quorum);
+  const unstakingDuration = governance.unstakingDuration ? parseDuration(governance.unstakingDuration) : null;
+  const baseConfig = {
+    proposalDurationAmount: duration.amount,
+    proposalDurationUnit: duration.unit,
+    proposalSubmissionPolicy: "members",
+    voteSwitching: false
+  };
+  const decisionPolicy = {
+    passingThreshold: "percentage",
+    passingThresholdPercentage: Math.round(thresholdNum * 100),
+    ...Number.isFinite(quorumNum) && quorumNum > 0 ? { quorum: "percentage", quorumPercentage: Math.round(quorumNum * 100) } : {}
+  };
+  if (groupType === "multisig") {
+    const members2 = memberConfig?.members || [];
+    return {
+      ...baseConfig,
+      threshold: memberConfig?.multisigThreshold || 1,
+      membershipCategory: [{ members: members2.map((m) => m.did) }]
+    };
+  }
+  if (groupType === "nftStaking") {
+    return {
+      ...baseConfig,
+      ...decisionPolicy,
+      nftContractAddress: memberConfig?.nftContractAddress || "",
+      ...unstakingDuration ? { unstakingDurationAmount: unstakingDuration.amount, unstakingDurationUnit: unstakingDuration.unit } : {}
+    };
+  }
+  if (groupType === "tokenStaking") {
+    const tokenConfig = memberConfig?.tokenConfig || {};
+    return {
+      ...baseConfig,
+      ...decisionPolicy,
+      isExistingToken: Boolean(tokenConfig.isExistingToken),
+      tokenAddress: tokenConfig.tokenAddress || "",
+      tokenName: tokenConfig.tokenName || "",
+      tokenSymbol: tokenConfig.tokenSymbol || "",
+      tokenSupply: tokenConfig.tokenSupply || 0,
+      distributionCategory: tokenConfig.distributionCategory || [],
+      ...unstakingDuration ? { unstakingDurationAmount: unstakingDuration.amount, unstakingDurationUnit: unstakingDuration.unit } : {}
+    };
+  }
+  const members = memberConfig?.members || [];
+  const byRole = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    const role = m.role || "member";
+    const existing = byRole.get(role);
+    if (existing) {
+      existing.dids.push(m.did);
+    } else {
+      byRole.set(role, { dids: [m.did], weight: m.votingPower || 1 });
+    }
+  }
+  return {
+    ...baseConfig,
+    ...decisionPolicy,
+    membershipCategory: Array.from(byRole.entries()).map(([role, { dids, weight }]) => ({
+      categoryName: role,
+      members: dids.map((did) => ({ memberAddress: did })),
+      weightPerMember: weight
+    }))
+  };
+}
+registerAction({
+  type: "qi/domain.sign",
+  can: "domain/sign",
+  sideEffect: true,
+  proof: { fields: ["entityDid"] },
+  done: doneWhenCompleted,
+  defaultRequiresConfirmation: true,
+  requiredCapability: "flow/block/execute",
+  eligibleForEventTrigger: true,
+  inputSchema: {
+    type: "object",
+    required: ["domainCardData"],
+    properties: {
+      domainCardData: {
+        type: "object",
+        description: "Domain card envelope (object or JSON string) with credentialSubject.name; signed and used to create the domain."
+      },
+      entityType: { type: "string", description: "Optional on-chain entity type; defaults from the credential type or dao/pod." },
+      governanceConfig: { type: "object", description: "Optional governance group config (object or JSON string) used to create a governance group." },
+      memberConfig: { type: "object", description: "Optional member config (object or JSON string) for the governance group." },
+      flowTemplateConfig: { type: "object", description: "Optional flow template config (object or JSON string) with selected protocol templates." },
+      context: { type: "array", description: "Optional context entries (array of { key, val } or JSON string) attached to the domain." },
+      selectedEntityDid: { type: "string", description: "Optional parent entity DID to link the new POD to." },
+      parentDid: { type: "string", description: "Optional parent entity DID (alternate field)." },
+      parentDID: { type: "string", description: "Optional parent entity DID (alternate field)." },
+      skipped: { type: "boolean", description: "Optional flag that skips parent entity linking." },
+      parentSkipped: { type: "boolean", description: "Optional flag that skips parent entity linking." },
+      pendingInvocationId: { type: "string", description: "Optional invocation ID used as the checkpoint key for resumable runs." },
+      invocationId: { type: "string", description: "Optional invocation ID used as the checkpoint key for resumable runs." }
+    }
+  },
+  outputSchema: [
+    { path: "entityDid", displayName: "Entity DID", type: "string", description: "The DID of the newly created domain entity" },
+    {
+      path: "governanceGroupCoreAddress",
+      displayName: "Governance Group Core Address",
+      type: "string",
+      description: "The core address of the created governance group, when one was created"
+    },
+    { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "The on-chain transaction hash for domain creation" },
+    {
+      path: "linkedResourceTransactionHash",
+      displayName: "Linked Resource Transaction Hash",
+      type: "string",
+      description: "The on-chain transaction hash for adding the domain card linked resource"
+    },
+    {
+      path: "parentEntityDid",
+      displayName: "Parent Entity DID",
+      type: "string",
+      description: "The selected parent entity DID that was updated with the new POD linked entity"
+    },
+    {
+      path: "parentLinkedEntityTransactionHash",
+      displayName: "Parent Linked Entity Transaction Hash",
+      type: "string",
+      description: "The on-chain transaction hash for linking the new POD to the selected parent entity"
+    },
+    {
+      path: "flowTemplateConfig",
+      displayName: "Flow Template Config",
+      type: "object",
+      description: "Selected protocol templates captured before POD creation"
+    },
+    {
+      path: "domainSpaces",
+      displayName: "Domain Spaces",
+      type: "object",
+      description: "Matrix space structure sourced for the new domain"
+    },
+    {
+      path: "protocolTemplateImports",
+      displayName: "Protocol Template Imports",
+      type: "array",
+      description: "Import results for selected protocol templates"
+    }
+  ],
+  events: [
+    {
+      name: "created",
+      displayName: "Domain Created",
+      description: "Fires after the domain entity is successfully created on-chain.",
+      payloadSchema: [
+        { path: "entityDid", displayName: "Entity DID", type: "string", description: "DID of the newly created domain" },
+        {
+          path: "governanceGroupCoreAddress",
+          displayName: "Governance Group Core Address",
+          type: "string",
+          description: "Core address of the created governance group, when present"
+        },
+        { path: "transactionHash", displayName: "Transaction Hash", type: "string", description: "On-chain transaction hash" },
+        {
+          path: "linkedResourceTransactionHash",
+          displayName: "Linked Resource Transaction Hash",
+          type: "string",
+          description: "On-chain transaction hash for adding the domain card linked resource"
+        },
+        {
+          path: "parentLinkedEntityTransactionHash",
+          displayName: "Parent Linked Entity Transaction Hash",
+          type: "string",
+          description: "On-chain transaction hash for linking the new POD to the selected parent entity"
+        }
+      ],
+      pendingDisplayFields: ["entityDid", "governanceGroupCoreAddress"]
+    }
+  ],
+  // Mirrors run(): the card envelope (object or JSON string) must carry
+  // credentialSubject.name before signing can start.
+  getMissingInputs: (inputs) => {
+    const card = parseMaybeJsonObject(inputs.domainCardData);
+    if (!card) return ["domainCardData"];
+    const subject = card.credentialSubject;
+    return subject && String(subject.name || "").trim() ? [] : ["domainCardData.credentialSubject.name"];
+  },
+  run: async (inputs, ctx) => {
+    const handlers = ctx.handlers || {};
+    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 entityType = String(inputs.entityType || "").trim() || (domainCardData.credentialSubject?.type?.[0] ? resolveEntityTypeFromSchema(domainCardData.credentialSubject.type[0]) : "dao/pod");
+    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 govConfig = parseJsonInput(inputs.governanceConfig);
+    const memberConfig = parseJsonInput(inputs.memberConfig);
+    const flowTemplateConfig = parseJsonInput(inputs.flowTemplateConfig);
+    const context = parseContextInput(inputs.context);
+    const selectedParentEntityDid = getSelectedParentEntityDid(inputs);
+    const selectedProtocolTemplates = getSelectedProtocolTemplates(flowTemplateConfig);
+    const checkpointKey = getDomainSignCheckpointKey(inputs, ctx);
+    let checkpoint = readDomainSignCheckpoint(ctx, checkpointKey) || {
+      invocationId: checkpointKey,
+      status: "running",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completedSteps: {}
+    };
+    if (checkpoint.status === "completed" && checkpoint.output) {
+      return buildCompletedDomainSignResult(checkpoint.output);
+    }
+    if (!ctx.handlers) {
+      throw new Error("Handlers not available");
+    }
+    if (typeof handlers.requestPin !== "function") throw new Error("requestPin handler not available");
+    if (typeof handlers.signCredential !== "function") throw new Error("signCredential handler not implemented");
+    if (!ctx.services.domainVfs) throw new Error("entity VFS domain persistence service not available");
+    if (typeof handlers.createDomain !== "function") throw new Error("createDomain handler not implemented");
+    if (typeof handlers.createAddLinkedResourceMessage !== "function") throw new Error("createAddLinkedResourceMessage handler not implemented");
+    if (typeof handlers.executeTransaction !== "function") throw new Error("executeTransaction handler not implemented");
+    const { requestPin, signCredential } = handlers;
+    const domainVfs = ctx.services.domainVfs;
+    const saveCheckpoint = (updates) => {
+      checkpoint = {
+        ...checkpoint,
+        ...updates,
+        invocationId: checkpointKey,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedSteps: {
+          ...checkpoint.completedSteps || {},
+          ...updates.completedSteps || {}
+        }
+      };
+      writeDomainSignCheckpoint(ctx, checkpointKey, checkpoint);
+      return checkpoint;
+    };
+    saveCheckpoint({
+      status: "running",
+      error: void 0,
+      flowTemplateConfig
+    });
+    try {
+      let governanceGroupLinkedEntities = checkpoint.governanceGroupLinkedEntities || [];
+      let governanceGroupCoreAddress = checkpoint.governanceGroupCoreAddress || "";
+      if (govConfig && handlers.createGovernanceGroup && !checkpoint.completedSteps?.createGovernanceGroup) {
+        const groupType = govConfig.groupType;
+        const governance = govConfig.governance || {};
+        const config = buildGroupConfig(groupType, governance, memberConfig);
+        const groupResult = await handlers.createGovernanceGroup({
+          groupType,
+          name: govConfig.groupName || domainCardData.credentialSubject?.name || "Governance Group",
+          config
+        });
+        governanceGroupCoreAddress = groupResult.coreAddress;
+        governanceGroupLinkedEntities = [
+          {
+            id: `{id}#${governanceGroupCoreAddress}`,
+            type: "group",
+            relationship: "governs",
+            service: ""
+          }
+        ];
+        saveCheckpoint({
+          governanceGroupCoreAddress,
+          governanceGroupLinkedEntities,
+          completedSteps: { createGovernanceGroup: true }
+        });
+      } else if (!govConfig) {
+        saveCheckpoint({ completedSteps: { createGovernanceGroup: true } });
+      }
+      const issuerDid = handlers.getEntityDid?.() || handlers.getCurrentUser?.()?.address;
+      if (!issuerDid) throw new Error("Unable to determine issuer DID");
+      const signAndUploadDomainCard = async (entityDid) => {
+        const credentialSubject = {
+          ...domainCardData.credentialSubject,
+          id: entityDid
+        };
+        const unsignedCredential = buildVerifiableCredential({
+          entityDid,
+          issuerDid,
+          credentialSubject,
+          validFrom,
+          validUntil
+        });
+        let signedCredential;
+        for (let attempt = 1; attempt <= MAX_PIN_ATTEMPTS; attempt++) {
+          const pin = await requestPin({
+            title: "Sign Domain Card",
+            description: attempt === 1 ? "Enter your PIN to sign the Domain Card credential" : "Incorrect PIN. Re-enter your PIN to sign the Domain Card credential.",
+            submitText: "Sign"
+          });
+          if (!pin) throw new Error("PIN entry cancelled");
+          try {
+            ({ signedCredential } = await signCredential({
+              issuerDid,
+              issuerType: "user",
+              credential: unsignedCredential,
+              pin
+            }));
+            break;
+          } catch (signError) {
+            if (isInvalidPinError(signError) && attempt < MAX_PIN_ATTEMPTS) continue;
+            throw signError;
+          }
+        }
+        if (!signedCredential) throw new Error("Failed to sign credential");
+        const domainMarkdown = [
+          "---",
+          `id: ${entityDid}`,
+          `name: ${JSON.stringify(domainCardData.credentialSubject?.name || "Domain")}`,
+          "private: true",
+          "access: UCAN",
+          "---",
+          "",
+          `# ${domainCardData.credentialSubject?.name || "Domain"}`,
+          "",
+          "This private domain package is stored in the entity VFS.",
+          ""
+        ].join("\n");
+        const persisted = await domainVfs.persistDomainPackage({
+          entityDid,
+          name: domainCardData.credentialSubject?.name || "Domain",
+          signedCredential,
+          domainMarkdown
+        });
+        return {
+          ...buildDomainCardLinkedResource({
+            entityDid,
+            cid: persisted.credentialCid,
+            serviceEndpoint: persisted.credentialServiceEndpoint,
+            description: `Domain Card for ${domainCardData.credentialSubject?.name || "Domain"}`
+          }),
+          id: "{id}#dmn"
+        };
+      };
+      const endDate = domainCardData.endDate || validUntil;
+      let newEntityDid = checkpoint.entityDid || "";
+      let transactionHash = checkpoint.transactionHash || "";
+      let linkedResourceTransactionHash = checkpoint.linkedResourceTransactionHash || "";
+      const parentEntityDid = checkpoint.parentEntityDid || selectedParentEntityDid;
+      let parentLinkedEntity = checkpoint.parentLinkedEntity;
+      let parentLinkedEntityTransactionHash = checkpoint.parentLinkedEntityTransactionHash || "";
+      let domainCardLinkedResource = checkpoint.domainCardLinkedResource;
+      if (!checkpoint.completedSteps?.createDomain || !newEntityDid || !transactionHash) {
+        const createResult = await handlers.createDomain({
+          entityType,
+          context: context.length > 0 ? context : void 0,
+          linkedResource: [],
+          linkedEntity: governanceGroupLinkedEntities.length > 0 ? governanceGroupLinkedEntities : void 0,
+          startDate: validFrom,
+          endDate
+        });
+        newEntityDid = createResult.entityDid;
+        transactionHash = createResult.transactionHash;
+        saveCheckpoint({
+          entityDid: newEntityDid,
+          transactionHash,
+          completedSteps: { createDomain: true }
+        });
+      }
+      if (!checkpoint.completedSteps?.signAndUploadDomainCard || !domainCardLinkedResource) {
+        domainCardLinkedResource = await signAndUploadDomainCard(newEntityDid);
+        saveCheckpoint({
+          domainCardLinkedResource,
+          completedSteps: { signAndUploadDomainCard: true }
+        });
+      }
+      if (!checkpoint.completedSteps?.addLinkedResource || !linkedResourceTransactionHash) {
+        const addLinkedResourceMessage = await handlers.createAddLinkedResourceMessage({
+          entityDid: newEntityDid,
+          linkedResource: domainCardLinkedResource
+        });
+        const addLinkedResourceResult = await handlers.executeTransaction({
+          messages: [addLinkedResourceMessage],
+          memo: ""
+        });
+        linkedResourceTransactionHash = String(addLinkedResourceResult?.transactionHash || "");
+        if (!linkedResourceTransactionHash) {
+          throw new Error("Linked resource transaction completed but no transaction hash received");
+        }
+        saveCheckpoint({
+          linkedResourceTransactionHash,
+          completedSteps: { addLinkedResource: true }
+        });
+      }
+      if (parentEntityDid && (!checkpoint.completedSteps?.addParentLinkedEntity || !parentLinkedEntityTransactionHash)) {
+        if (typeof handlers.createAddLinkedEntityMessage !== "function") {
+          throw new Error("createAddLinkedEntityMessage handler not implemented");
+        }
+        parentLinkedEntity = parentLinkedEntity || {
+          id: newEntityDid,
+          type: entityType,
+          relationship: "manages",
+          service: ""
+        };
+        const addParentLinkedEntityMessage = await handlers.createAddLinkedEntityMessage({
+          entityDid: parentEntityDid,
+          linkedEntity: parentLinkedEntity
+        });
+        const addParentLinkedEntityResult = await handlers.executeTransaction({
+          messages: [addParentLinkedEntityMessage],
+          memo: ""
+        });
+        parentLinkedEntityTransactionHash = String(addParentLinkedEntityResult?.transactionHash || "");
+        if (!parentLinkedEntityTransactionHash) {
+          throw new Error("Parent linked entity transaction completed but no transaction hash received");
+        }
+        saveCheckpoint({
+          parentEntityDid,
+          parentLinkedEntity,
+          parentLinkedEntityTransactionHash,
+          completedSteps: { addParentLinkedEntity: true }
+        });
+      } else if (!parentEntityDid) {
+        saveCheckpoint({ completedSteps: { addParentLinkedEntity: true } });
+      }
+      let domainSpaces = checkpoint.domainSpaces;
+      let protocolTemplateImports = checkpoint.protocolTemplateImports || [];
+      if (handlers.sourceDomainSpaces && (!checkpoint.completedSteps?.sourceDomainSpaces || !domainSpaces)) {
+        domainSpaces = await handlers.sourceDomainSpaces({ entityDid: newEntityDid });
+        if (!domainSpaces?.success) {
+          throw new Error("Domain spaces could not be sourced for the newly created domain");
+        }
+        saveCheckpoint({
+          domainSpaces,
+          completedSteps: { sourceDomainSpaces: true }
+        });
+      } else if (!handlers.sourceDomainSpaces) {
+        saveCheckpoint({ completedSteps: { sourceDomainSpaces: true } });
+      }
+      if (selectedProtocolTemplates.length > 0 && !checkpoint.completedSteps?.importTemplates) {
+        if (!handlers.sourceDomainSpaces) {
+          throw new Error("sourceDomainSpaces handler is required to import selected protocol templates");
+        }
+        if (!handlers.importProtocolTemplatesToSpace) {
+          throw new Error("importProtocolTemplatesToSpace handler is required to import selected protocol templates");
+        }
+        const targetFlowsSubspaceId = domainSpaces?.subspaces?.["domain flows"]?.space_id;
+        if (!targetFlowsSubspaceId) {
+          throw new Error("Domain flows subspace was not returned by sourceDomainSpaces");
+        }
+        const groupedTemplates = groupTemplatesByProtocol(selectedProtocolTemplates);
+        protocolTemplateImports = await Promise.all(
+          Array.from(groupedTemplates.entries()).map(async ([protocolDid, templates]) => {
+            const result = await handlers.importProtocolTemplatesToSpace({
+              protocolDid,
+              entityDid: newEntityDid,
+              targetFlowsSubspaceId,
+              templates
+            });
+            return { protocolDid, imported: result.imported };
+          })
+        );
+        saveCheckpoint({
+          protocolTemplateImports,
+          completedSteps: { importTemplates: true }
+        });
+      } else if (selectedProtocolTemplates.length === 0) {
+        saveCheckpoint({
+          protocolTemplateImports,
+          completedSteps: { importTemplates: true }
+        });
+      }
+      const output = {
+        entityDid: newEntityDid,
+        governanceGroupCoreAddress,
+        linkedEntities: governanceGroupLinkedEntities,
+        linkedResources: [domainCardLinkedResource],
+        parentEntityDid,
+        parentLinkedEntity,
+        flowTemplateConfig,
+        domainSpaces,
+        protocolTemplateImports,
+        transactionHash,
+        linkedResourceTransactionHash,
+        parentLinkedEntityTransactionHash
+      };
+      saveCheckpoint({
+        status: "completed",
+        output
+      });
+      return buildCompletedDomainSignResult(output);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Domain sign failed";
+      saveCheckpoint({
+        status: "failed",
+        error: message
+      });
+      throw error;
+    }
+  }
+});
+
+export {
+  isBlankInputValue,
+  parseMaybeJsonObject,
+  getMissingActionInputs,
+  transformSurveyToCredentialSubject,
+  buildVerifiableCredential,
+  buildDomainCardLinkedResource,
+  extractSurveyAnswersTemplate,
+  parseLinkedEntities,
+  buildGovernanceGroupLinkedEntities,
+  tempDomainCreatorSurvey,
+  resolveEntityTypeFromSchema
+};
+//# sourceMappingURL=chunk-PYNDJDWZ.js.map