@lucern/pack-host 1.0.28 → 1.0.30

package/dist/domain-pack/index.js

@@ -63,12 +63,13 @@ function defineDomainPack(input) {
 // src/domain-pack/authoring.core.ts
 var DOMAIN_PACK_MANIFEST_KIND = "lucern-domain-pack-manifest";
 var CURRENT_MANIFEST_VERSION = "1.0.0";
+var YAML_NUMERIC_SCALAR = /^-?\d+(?:\.\d+)?$/;
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
 function dedupeStrings2(values) {
   if (!values) {
-    return void 0;
+    return;
   }
   return Array.from(
     new Set(values.map((value) => value.trim()).filter((value) => value.length))
@@ -79,7 +80,7 @@ function normalizeRuntimeTargets2(values) {
 }
 function normalizeFrameworks(frameworks) {
   if (!frameworks) {
-    return void 0;
+    return;
   }
   return frameworks.map((framework) => ({
     ...framework,
@@ -91,7 +92,7 @@ function normalizeFrameworks(frameworks) {
 }
 function normalizeSchemaExtensions(extensions) {
   if (!extensions) {
-    return void 0;
+    return;
   }
   return extensions.map((extension) => ({
     ...extension,
@@ -104,7 +105,7 @@ function normalizeSchemaExtensions(extensions) {
 }
 function normalizeOntologyExtensions(extensions) {
   if (!extensions) {
-    return void 0;
+    return;
   }
   return extensions.map((extension) => ({
     ...extension,
@@ -143,7 +144,7 @@ function normalizeLineage(lineage) {
 }
 function normalizeMetadata(metadata) {
   if (!metadata) {
-    return void 0;
+    return;
   }
   return {
     description: metadata.description?.trim(),
@@ -271,7 +272,7 @@ function parseYamlScalar(raw) {
   if (value === "false") {
     return false;
   }
-  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+  if (YAML_NUMERIC_SCALAR.test(value)) {
     return Number(value);
   }
   if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
@@ -813,9 +814,14 @@ function checkDuplicateIds(items, idField, path) {
   }
   return issues;
 }
-function validateDomainPack(pack) {
-  const issues = [];
-  if (!pack.packId || !pack.packId.trim()) {
+function checkOptionalDuplicateIds(items, idField, path) {
+  if (!items) {
+    return [];
+  }
+  return checkDuplicateIds(items, idField, path);
+}
+function validatePackIdentity(pack, issues) {
+  if (typeof pack.packId !== "string" || pack.packId.trim().length === 0) {
     issues.push(issue("MISSING_PACK_ID", "packId is required", "packId"));
   } else if (!KEBAB_CASE.test(pack.packId)) {
     issues.push(
@@ -826,10 +832,10 @@ function validateDomainPack(pack) {
       )
     );
   }
-  if (!pack.name || !pack.name.trim()) {
+  if (typeof pack.name !== "string" || pack.name.trim().length === 0) {
     issues.push(issue("MISSING_NAME", "name is required", "name"));
   }
-  if (!pack.version || !pack.version.trim()) {
+  if (typeof pack.version !== "string" || pack.version.trim().length === 0) {
     issues.push(issue("MISSING_VERSION", "version is required", "version"));
   } else if (!SEMVER.test(pack.version)) {
     issues.push(
@@ -840,6 +846,8 @@ function validateDomainPack(pack) {
       )
     );
   }
+}
+function validateOntologyBindings(pack, issues) {
   if (!pack.ontologyBindings || pack.ontologyBindings.length === 0) {
     issues.push(
       issue(
@@ -900,6 +908,8 @@ function validateDomainPack(pack) {
       );
     }
   }
+}
+function validateTopicRoots(pack, issues) {
   if (!pack.topicRoots || pack.topicRoots.length === 0) {
     issues.push(
       issue(
@@ -908,270 +918,343 @@ function validateDomainPack(pack) {
         "topicRoots"
       )
     );
-  } else {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(pack.topicRoots, "slug", "topicRoots")
+  );
+}
+function validateOperatingSystemPrompts(operatingSystem, issues) {
+  if (!operatingSystem.prompts) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.prompts,
+      "promptId",
+      "operatingSystem.prompts"
+    )
+  );
+  for (const [index, prompt] of operatingSystem.prompts.entries()) {
+    issues.push(...validatePromptBinding(prompt, index));
+  }
+}
+function validateOperatingSystemTools(operatingSystem, issues) {
+  if (!operatingSystem.tools) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.tools,
+      "toolId",
+      "operatingSystem.tools"
+    )
+  );
+  for (const [index, tool] of operatingSystem.tools.entries()) {
+    issues.push(...validateToolBinding(tool, index));
+  }
+}
+function validateOperatingSystemSetupAssets(operatingSystem, issues) {
+  if (!operatingSystem.setupAssets) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.setupAssets,
+      "assetId",
+      "operatingSystem.setupAssets"
+    )
+  );
+  for (const [index, asset] of operatingSystem.setupAssets.entries()) {
+    issues.push(...validateSetupAsset(asset, index));
+  }
+}
+function validateOperatingSystemTopicTemplates(operatingSystem, knownRootSlugs, issues) {
+  const templateSlugs = /* @__PURE__ */ new Set();
+  if (!operatingSystem.topicTemplates) {
+    return templateSlugs;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.topicTemplates,
+      "slug",
+      "operatingSystem.topicTemplates"
+    )
+  );
+  for (const template of operatingSystem.topicTemplates) {
+    if (template.slug) {
+      templateSlugs.add(template.slug);
+    }
+  }
+  const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+  for (const [index, template] of operatingSystem.topicTemplates.entries()) {
+    issues.push(...validateTopicTemplate(template, index, knownTopicSlugs));
+  }
+  return templateSlugs;
+}
+function validateOperatingSystemInstallProfiles(operatingSystem, knownRootSlugs, templateSlugs, issues) {
+  if (!operatingSystem.installProfiles) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      operatingSystem.installProfiles,
+      "profileId",
+      "operatingSystem.installProfiles"
+    )
+  );
+  const knownPromptIds = new Set(
+    operatingSystem.prompts?.map((prompt) => prompt.promptId) ?? []
+  );
+  const knownToolIds = new Set(
+    operatingSystem.tools?.map((tool) => tool.toolId) ?? []
+  );
+  const knownAssetIds = new Set(
+    operatingSystem.setupAssets?.map((asset) => asset.assetId) ?? []
+  );
+  const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
+  for (const [index, profile] of operatingSystem.installProfiles.entries()) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.topicRoots,
-        "slug",
-        "topicRoots"
+      ...validateInstallProfile(
+        profile,
+        index,
+        knownPromptIds,
+        knownToolIds,
+        knownAssetIds,
+        knownTopicSlugs
       )
     );
   }
-  if (pack.operatingSystem) {
-    const knownRootSlugs = new Set(
-      pack.topicRoots?.map((topic) => topic.slug) ?? []
-    );
-    if (pack.operatingSystem.prompts) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.prompts,
-          "promptId",
-          "operatingSystem.prompts"
-        )
-      );
-      pack.operatingSystem.prompts.forEach((prompt, index) => {
-        issues.push(...validatePromptBinding(prompt, index));
-      });
-    }
-    if (pack.operatingSystem.tools) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.tools,
-          "toolId",
-          "operatingSystem.tools"
-        )
-      );
-      pack.operatingSystem.tools.forEach((tool, index) => {
-        issues.push(...validateToolBinding(tool, index));
-      });
-    }
-    if (pack.operatingSystem.setupAssets) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.setupAssets,
-          "assetId",
-          "operatingSystem.setupAssets"
-        )
-      );
-      pack.operatingSystem.setupAssets.forEach((asset, index) => {
-        issues.push(...validateSetupAsset(asset, index));
-      });
-    }
-    const templateSlugs = /* @__PURE__ */ new Set();
-    if (pack.operatingSystem.topicTemplates) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.topicTemplates,
-          "slug",
-          "operatingSystem.topicTemplates"
-        )
-      );
-      pack.operatingSystem.topicTemplates.forEach((template) => {
-        if (template.slug) {
-          templateSlugs.add(template.slug);
-        }
-      });
-      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
-      pack.operatingSystem.topicTemplates.forEach((template, index) => {
-        issues.push(...validateTopicTemplate(template, index, knownTopicSlugs));
-      });
-    }
-    if (pack.operatingSystem.installProfiles) {
-      issues.push(
-        ...checkDuplicateIds(
-          pack.operatingSystem.installProfiles,
-          "profileId",
-          "operatingSystem.installProfiles"
-        )
-      );
-      const knownPromptIds = new Set(
-        pack.operatingSystem.prompts?.map((prompt) => prompt.promptId) ?? []
-      );
-      const knownToolIds = new Set(
-        pack.operatingSystem.tools?.map((tool) => tool.toolId) ?? []
-      );
-      const knownAssetIds = new Set(
-        pack.operatingSystem.setupAssets?.map((asset) => asset.assetId) ?? []
-      );
-      const knownTopicSlugs = /* @__PURE__ */ new Set([...knownRootSlugs, ...templateSlugs]);
-      pack.operatingSystem.installProfiles.forEach((profile, index) => {
-        issues.push(
-          ...validateInstallProfile(
-            profile,
-            index,
-            knownPromptIds,
-            knownToolIds,
-            knownAssetIds,
-            knownTopicSlugs
-          )
-        );
-      });
-    }
+}
+function validateOperatingSystem(pack, issues) {
+  if (!pack.operatingSystem) {
+    return;
   }
+  const knownRootSlugs = new Set(
+    pack.topicRoots?.map((topic) => topic.slug) ?? []
+  );
+  validateOperatingSystemPrompts(pack.operatingSystem, issues);
+  validateOperatingSystemTools(pack.operatingSystem, issues);
+  validateOperatingSystemSetupAssets(pack.operatingSystem, issues);
+  const templateSlugs = validateOperatingSystemTopicTemplates(
+    pack.operatingSystem,
+    knownRootSlugs,
+    issues
+  );
+  validateOperatingSystemInstallProfiles(
+    pack.operatingSystem,
+    knownRootSlugs,
+    templateSlugs,
+    issues
+  );
+}
+function validateRoles(pack, issues) {
   if (!pack.roles || pack.roles.length === 0) {
     issues.push(
       issue("MISSING_ROLES", "At least one reasoning role is required", "roles")
     );
   } else {
-    issues.push(
-      ...checkDuplicateIds(
-        pack.roles,
-        "roleId",
-        "roles"
-      )
-    );
+    issues.push(...checkOptionalDuplicateIds(pack.roles, "roleId", "roles"));
   }
-  const knownGateIds = new Set(pack.gates?.map((g) => g.gateId) ?? []);
-  const knownArtifactIds = new Set(
-    pack.artifacts?.map((a) => a.artifactId) ?? []
-  );
-  const knownRoleIds = new Set(pack.roles?.map((r) => r.roleId) ?? []);
-  if (pack.gates) {
+}
+function validateGates(pack, issues) {
+  if (!pack.gates) {
+    return;
+  }
+  issues.push(...checkOptionalDuplicateIds(pack.gates, "gateId", "gates"));
+  for (const [index, gate] of pack.gates.entries()) {
+    if (!gate.criteria || gate.criteria.length === 0) {
+      issues.push(
+        issue(
+          "EMPTY_GATE_CRITERIA",
+          `Gate "${gate.gateId}" has no criteria`,
+          `gates[${index}].criteria`,
+          "warning"
+        )
+      );
+      continue;
+    }
     issues.push(
-      ...checkDuplicateIds(
-        pack.gates,
-        "gateId",
-        "gates"
+      ...checkOptionalDuplicateIds(
+        gate.criteria,
+        "criterionId",
+        `gates[${index}].criteria`
       )
     );
-    for (const [i, gate] of pack.gates.entries()) {
-      if (!gate.criteria || gate.criteria.length === 0) {
-        issues.push(
-          issue(
-            "EMPTY_GATE_CRITERIA",
-            `Gate "${gate.gateId}" has no criteria`,
-            `gates[${i}].criteria`,
-            "warning"
-          )
-        );
-      } else {
-        issues.push(
-          ...checkDuplicateIds(
-            gate.criteria,
-            "criterionId",
-            `gates[${i}].criteria`
-          )
-        );
-      }
-    }
   }
+}
+function validateArtifacts(pack, issues) {
   if (pack.artifacts) {
     issues.push(
-      ...checkDuplicateIds(
-        pack.artifacts,
-        "artifactId",
-        "artifacts"
-      )
+      ...checkOptionalDuplicateIds(pack.artifacts, "artifactId", "artifacts")
     );
   }
-  if (pack.workflows) {
-    issues.push(
-      ...checkDuplicateIds(
-        pack.workflows,
-        "workflowId",
-        "workflows"
-      )
-    );
-    for (const [wi, workflow] of pack.workflows.entries()) {
-      for (const gateId of workflow.gateCheckpoints) {
-        if (!knownGateIds.has(gateId)) {
-          issues.push(
-            issue(
-              "UNKNOWN_GATE_REF",
-              `Workflow "${workflow.workflowId}" references unknown gate "${gateId}"`,
-              `workflows[${wi}].gateCheckpoints`
-            )
-          );
-        }
-      }
-      for (const artifactId of workflow.requiredArtifacts) {
-        if (!knownArtifactIds.has(artifactId)) {
-          issues.push(
-            issue(
-              "UNKNOWN_ARTIFACT_REF",
-              `Workflow "${workflow.workflowId}" references unknown artifact "${artifactId}"`,
-              `workflows[${wi}].requiredArtifacts`
-            )
-          );
-        }
-      }
-      for (const [si, step] of workflow.steps.entries()) {
-        for (const roleId of step.requiredRoles) {
-          if (!knownRoleIds.has(roleId)) {
-            issues.push(
-              issue(
-                "UNKNOWN_ROLE_REF",
-                `Step "${step.stepId}" references unknown role "${roleId}"`,
-                `workflows[${wi}].steps[${si}].requiredRoles`
-              )
-            );
-          }
-        }
-        if (step.gateId && !knownGateIds.has(step.gateId)) {
-          issues.push(
-            issue(
-              "UNKNOWN_GATE_REF",
-              `Step "${step.stepId}" references unknown gate "${step.gateId}"`,
-              `workflows[${wi}].steps[${si}].gateId`
-            )
-          );
-        }
-        if (step.produces) {
-          for (const artifactId of step.produces) {
-            if (!knownArtifactIds.has(artifactId)) {
-              issues.push(
-                issue(
-                  "UNKNOWN_ARTIFACT_REF",
-                  `Step "${step.stepId}" references unknown artifact "${artifactId}"`,
-                  `workflows[${wi}].steps[${si}].produces`
-                )
-              );
-            }
-          }
-        }
-      }
+}
+function domainPackReferenceSets(pack) {
+  return {
+    knownGateIds: new Set(pack.gates?.map((gate) => gate.gateId) ?? []),
+    knownArtifactIds: new Set(
+      pack.artifacts?.map((artifact) => artifact.artifactId) ?? []
+    ),
+    knownRoleIds: new Set(pack.roles?.map((role) => role.roleId) ?? [])
+  };
+}
+function validateWorkflowGateReferences(workflow, workflowIndex, knownGateIds, issues) {
+  for (const gateId of workflow.gateCheckpoints) {
+    if (!knownGateIds.has(gateId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_GATE_REF",
+          `Workflow "${workflow.workflowId}" references unknown gate "${gateId}"`,
+          `workflows[${workflowIndex}].gateCheckpoints`
+        )
+      );
     }
   }
-  if (pack.inquiryShaping) {
-    if (pack.inquiryShaping.questionTemplates) {
+}
+function validateWorkflowArtifactReferences(workflow, workflowIndex, knownArtifactIds, issues) {
+  for (const artifactId of workflow.requiredArtifacts) {
+    if (!knownArtifactIds.has(artifactId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.questionTemplates,
-          "templateId",
-          "inquiryShaping.questionTemplates"
+        issue(
+          "UNKNOWN_ARTIFACT_REF",
+          `Workflow "${workflow.workflowId}" references unknown artifact "${artifactId}"`,
+          `workflows[${workflowIndex}].requiredArtifacts`
         )
       );
-      pack.inquiryShaping.questionTemplates.forEach((template, index) => {
-        issues.push(...validateQuestionTemplate(template, index));
-      });
     }
-    if (pack.inquiryShaping.taskTemplates) {
+  }
+}
+function validateWorkflowStepReferences(step, workflowIndex, stepIndex, refs, issues) {
+  for (const roleId of step.requiredRoles) {
+    if (!refs.knownRoleIds.has(roleId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.taskTemplates,
-          "templateId",
-          "inquiryShaping.taskTemplates"
+        issue(
+          "UNKNOWN_ROLE_REF",
+          `Step "${step.stepId}" references unknown role "${roleId}"`,
+          `workflows[${workflowIndex}].steps[${stepIndex}].requiredRoles`
         )
       );
-      pack.inquiryShaping.taskTemplates.forEach((template, index) => {
-        issues.push(...validateTaskTemplate(template, index));
-      });
     }
-    if (pack.inquiryShaping.frameworkHints) {
+  }
+  if (step.gateId && !refs.knownGateIds.has(step.gateId)) {
+    issues.push(
+      issue(
+        "UNKNOWN_GATE_REF",
+        `Step "${step.stepId}" references unknown gate "${step.gateId}"`,
+        `workflows[${workflowIndex}].steps[${stepIndex}].gateId`
+      )
+    );
+  }
+  for (const artifactId of step.produces ?? []) {
+    if (!refs.knownArtifactIds.has(artifactId)) {
       issues.push(
-        ...checkDuplicateIds(
-          pack.inquiryShaping.frameworkHints.map((hint) => ({
-            frameworkName: hint.frameworkName
-          })),
-          "frameworkName",
-          "inquiryShaping.frameworkHints"
+        issue(
+          "UNKNOWN_ARTIFACT_REF",
+          `Step "${step.stepId}" references unknown artifact "${artifactId}"`,
+          `workflows[${workflowIndex}].steps[${stepIndex}].produces`
         )
       );
-      pack.inquiryShaping.frameworkHints.forEach((hint, index) => {
-        issues.push(...validateFrameworkHint(hint, index));
-      });
     }
   }
+}
+function validateWorkflows(pack, refs, issues) {
+  if (!pack.workflows) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(pack.workflows, "workflowId", "workflows")
+  );
+  for (const [workflowIndex, workflow] of pack.workflows.entries()) {
+    validateWorkflowGateReferences(
+      workflow,
+      workflowIndex,
+      refs.knownGateIds,
+      issues
+    );
+    validateWorkflowArtifactReferences(
+      workflow,
+      workflowIndex,
+      refs.knownArtifactIds,
+      issues
+    );
+    for (const [stepIndex, step] of workflow.steps.entries()) {
+      validateWorkflowStepReferences(
+        step,
+        workflowIndex,
+        stepIndex,
+        refs,
+        issues
+      );
+    }
+  }
+}
+function validateInquiryQuestionTemplates(pack, issues) {
+  if (!pack.inquiryShaping?.questionTemplates) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      pack.inquiryShaping.questionTemplates,
+      "templateId",
+      "inquiryShaping.questionTemplates"
+    )
+  );
+  for (const [
+    index,
+    template
+  ] of pack.inquiryShaping.questionTemplates.entries()) {
+    issues.push(...validateQuestionTemplate(template, index));
+  }
+}
+function validateInquiryTaskTemplates(pack, issues) {
+  if (!pack.inquiryShaping?.taskTemplates) {
+    return;
+  }
+  issues.push(
+    ...checkOptionalDuplicateIds(
+      pack.inquiryShaping.taskTemplates,
+      "templateId",
+      "inquiryShaping.taskTemplates"
+    )
+  );
+  for (const [index, template] of pack.inquiryShaping.taskTemplates.entries()) {
+    issues.push(...validateTaskTemplate(template, index));
+  }
+}
+function validateInquiryFrameworkHints(pack, issues) {
+  if (!pack.inquiryShaping?.frameworkHints) {
+    return;
+  }
+  issues.push(
+    ...checkDuplicateIds(
+      pack.inquiryShaping.frameworkHints.map((hint) => ({
+        frameworkName: hint.frameworkName
+      })),
+      "frameworkName",
+      "inquiryShaping.frameworkHints"
+    )
+  );
+  for (const [index, hint] of pack.inquiryShaping.frameworkHints.entries()) {
+    issues.push(...validateFrameworkHint(hint, index));
+  }
+}
+function validateInquiryShaping(pack, issues) {
+  validateInquiryQuestionTemplates(pack, issues);
+  validateInquiryTaskTemplates(pack, issues);
+  validateInquiryFrameworkHints(pack, issues);
+}
+function validateDomainPack(pack) {
+  const issues = [];
+  validatePackIdentity(pack, issues);
+  validateOntologyBindings(pack, issues);
+  validateTopicRoots(pack, issues);
+  validateOperatingSystem(pack, issues);
+  validateRoles(pack, issues);
+  validateGates(pack, issues);
+  validateArtifacts(pack, issues);
+  validateWorkflows(pack, domainPackReferenceSets(pack), issues);
+  validateInquiryShaping(pack, issues);
   return {
     valid: issues.filter((i) => i.severity === "error").length === 0,
     issues
@@ -1462,7 +1545,7 @@ function validateOntologyExtensions(extensions) {
     extension.entityTypes?.forEach(
       (entityType, entityTypeIndex) => {
         const entityPath = `${path}.entityTypes[${entityTypeIndex}]`;
-        if (!entityType.value || !KEBAB_CASE2.test(entityType.value)) {
+        if (!(entityType.value && KEBAB_CASE2.test(entityType.value))) {
           issues.push(
             issue2(
               "INVALID_ONTOLOGY_ENTITY_VALUE",
@@ -1499,7 +1582,7 @@ function validateOntologyExtensions(extensions) {
     extension.edgeTypes?.forEach(
       (edgeType, edgeTypeIndex) => {
         const edgePath = `${path}.edgeTypes[${edgeTypeIndex}]`;
-        if (!edgeType.value || !KEBAB_CASE2.test(edgeType.value)) {
+        if (!(edgeType.value && KEBAB_CASE2.test(edgeType.value))) {
           issues.push(
             issue2(
               "INVALID_ONTOLOGY_EDGE_VALUE",
@@ -1655,15 +1738,15 @@ function validateLineage(lineage, packId) {
 function scanLegacyPublicKeys(value, path = "") {
   const issues = [];
   if (Array.isArray(value)) {
-    value.forEach((entry, index) => {
+    for (const [index, entry] of value.entries()) {
       issues.push(...scanLegacyPublicKeys(entry, `${path}[${index}]`));
-    });
+    }
     return issues;
   }
   if (!isPlainObject2(value)) {
     return issues;
   }
-  Object.entries(value).forEach(([key, entryValue]) => {
+  for (const [key, entryValue] of Object.entries(value)) {
     const nextPath = path ? `${path}.${key}` : key;
     if (LEGACY_PUBLIC_KEYS.has(key)) {
       issues.push(
@@ -1676,7 +1759,7 @@ function scanLegacyPublicKeys(value, path = "") {
       );
     }
     issues.push(...scanLegacyPublicKeys(entryValue, nextPath));
-  });
+  }
   return issues;
 }
 function createManifestDigest(manifest) {
@@ -1741,12 +1824,7 @@ function parseFailureResult(error, format) {
     manifest: null,
     manifestDigest: null,
     issues: [
-      issue2(
-        "PARSE_ERROR",
-        describeParseFailure(error),
-        "manifest",
-        "parse"
-      )
+      issue2("PARSE_ERROR", describeParseFailure(error), "manifest", "parse")
     ],
     counts: emptyCounts()
   };
@@ -1772,23 +1850,28 @@ function collectRuntimeTargets(manifest) {
     return [];
   }
   const targets = /* @__PURE__ */ new Set();
-  manifest.frameworks?.forEach(
-    (framework) => framework.runtimeTargets?.forEach((target) => targets.add(target))
-  );
-  manifest.pack.operatingSystem?.prompts?.forEach(
-    (prompt) => prompt.runtimeTargets?.forEach((target) => targets.add(target))
-  );
-  manifest.pack.operatingSystem?.tools?.forEach(
-    (tool) => tool.runtimeTargets?.forEach((target) => targets.add(target))
-  );
-  manifest.pack.operatingSystem?.setupAssets?.forEach(
-    (asset) => asset.runtimeTargets?.forEach((target) => targets.add(target))
-  );
-  manifest.pack.operatingSystem?.installProfiles?.forEach(
-    (profile) => targets.add(profile.runtimeTarget)
-  );
+  for (const framework of manifest.frameworks ?? []) {
+    addRuntimeTargets(targets, framework.runtimeTargets);
+  }
+  for (const prompt of manifest.pack.operatingSystem?.prompts ?? []) {
+    addRuntimeTargets(targets, prompt.runtimeTargets);
+  }
+  for (const tool of manifest.pack.operatingSystem?.tools ?? []) {
+    addRuntimeTargets(targets, tool.runtimeTargets);
+  }
+  for (const asset of manifest.pack.operatingSystem?.setupAssets ?? []) {
+    addRuntimeTargets(targets, asset.runtimeTargets);
+  }
+  for (const profile of manifest.pack.operatingSystem?.installProfiles ?? []) {
+    targets.add(profile.runtimeTarget);
+  }
   return Array.from(targets).sort();
 }
+function addRuntimeTargets(targets, values) {
+  for (const target of values ?? []) {
+    targets.add(target);
+  }
+}
 function describeLineage(lineage) {
   if (!lineage) {
     return null;
@@ -1832,20 +1915,35 @@ function buildLineageEdge(manifest) {
     return {
       edgeType: "remixed_from",
       childPackId: pack.packId,
-      parentPackId: lineage.parentPackId,
-      parentVersion: lineage.parentVersion
+      parentPackId: readLineageField(lineage.parentPackId, "parentPackId"),
+      parentVersion: readLineageField(lineage.parentVersion, "parentVersion")
     };
   }
   return {
     edgeType: "supersedes",
     childPackId: pack.packId,
-    parentPackId: lineage.supersedesPackId,
-    parentVersion: lineage.parentVersion
+    parentPackId: readLineageField(
+      lineage.supersedesPackId,
+      "supersedesPackId"
+    ),
+    parentVersion: readLineageField(lineage.parentVersion, "parentVersion")
   };
 }
+function readLineageField(value, field) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  throw new Error(`Cannot publish domain pack with missing lineage.${field}.`);
+}
+function readPublicationArtifact(value, field) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  throw new Error(`Cannot publish domain pack with missing ${field}.`);
+}
 function publishDomainPackAuthoringManifest(manifest) {
   const preview = previewDomainPackAuthoringManifest(manifest);
-  if (!preview.readyToPublish || !preview.manifest || !preview.manifestDigest) {
+  if (!(preview.readyToPublish && preview.manifest && preview.manifestDigest)) {
     return {
       published: false,
       preview,
@@ -1862,14 +1960,20 @@ function publishDomainPackAuthoringManifest(manifest) {
       manifestDigest: preview.manifestDigest,
       manifest: preview.manifest,
       lineageEdge: buildLineageEdge(preview.manifest),
-      canonicalJson: preview.canonicalJson,
-      canonicalYaml: preview.canonicalYaml
+      canonicalJson: readPublicationArtifact(
+        preview.canonicalJson,
+        "canonicalJson"
+      ),
+      canonicalYaml: readPublicationArtifact(
+        preview.canonicalYaml,
+        "canonicalYaml"
+      )
     }
   };
 }
 function publishDomainPackAuthoringManifestSource(source, format) {
   const preview = previewDomainPackAuthoringManifestSource(source, format);
-  if (!preview.readyToPublish || !preview.manifest || !preview.manifestDigest) {
+  if (!(preview.readyToPublish && preview.manifest && preview.manifestDigest)) {
     return {
       published: false,
       preview,
@@ -1886,8 +1990,14 @@ function publishDomainPackAuthoringManifestSource(source, format) {
       manifestDigest: preview.manifestDigest,
       manifest: preview.manifest,
       lineageEdge: buildLineageEdge(preview.manifest),
-      canonicalJson: preview.canonicalJson,
-      canonicalYaml: preview.canonicalYaml
+      canonicalJson: readPublicationArtifact(
+        preview.canonicalJson,
+        "canonicalJson"
+      ),
+      canonicalYaml: readPublicationArtifact(
+        preview.canonicalYaml,
+        "canonicalYaml"
+      )
     }
   };
 }
@@ -1913,19 +2023,28 @@ function createDomainPackAuthoringTools() {
       name: AUTHORING_TOOL_NAMES.validate,
       description: "Validate a domain pack authoring manifest and return structural, lineage, terminology, and extension issues.",
       inputSchema,
-      execute: (args) => validateDomainPackAuthoringManifestSource(args.manifestText, args.format)
+      execute: (args) => validateDomainPackAuthoringManifestSource(
+        args.manifestText,
+        args.format
+      )
     }),
     preview: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.preview,
       description: "Preview a domain pack manifest with canonical JSON/YAML renderings, runtime targets, and publication readiness.",
       inputSchema,
-      execute: (args) => previewDomainPackAuthoringManifestSource(args.manifestText, args.format)
+      execute: (args) => previewDomainPackAuthoringManifestSource(
+        args.manifestText,
+        args.format
+      )
     }),
     publish: asToolDefinition({
       name: AUTHORING_TOOL_NAMES.publish,
       description: "Build a publication-ready domain pack artifact when validation passes, including remix/fork lineage metadata.",
       inputSchema,
-      execute: (args) => publishDomainPackAuthoringManifestSource(args.manifestText, args.format)
+      execute: (args) => publishDomainPackAuthoringManifestSource(
+        args.manifestText,
+        args.format
+      )
     })
   };
 }
@@ -2064,7 +2183,7 @@ var TASK_PRIORITY_WEIGHT = {
 };
 function dedupeStrings3(values) {
   if (!values || values.length === 0) {
-    return void 0;
+    return;
   }
   const normalized = values.map((value) => value.trim()).filter(Boolean);
   return normalized.length > 0 ? Array.from(new Set(normalized)) : void 0;
@@ -2137,7 +2256,11 @@ function checkDuplicateIds2(items, idField, path) {
     }
     if (seen.has(id)) {
       issues.push(
-        issue3("DUPLICATE_ID", `Duplicate ${idField} "${id}"`, `${path}.${idField}`)
+        issue3(
+          "DUPLICATE_ID",
+          `Duplicate ${idField} "${id}"`,
+          `${path}.${idField}`
+        )
       );
     }
     seen.add(id);
@@ -2263,7 +2386,9 @@ function createShapingContributionRegistry(packs = []) {
     }
     const packValidation = validateDomainPack(pack);
     if (!packValidation.valid) {
-      throw new Error(formatRegistrationIssues(pack.packId, packValidation.issues));
+      throw new Error(
+        formatRegistrationIssues(pack.packId, packValidation.issues)
+      );
     }
     const contribution = buildShapingContribution(pack);
     const contributionValidation = validateShapingContribution(contribution);
@@ -2521,7 +2646,13 @@ var DEVELOPER_REASONING_PACK = defineDomainPack({
         questionType: "counterfactual",
         priority: "high",
         template: "What existing behavior or verification path would regress if {{hypothesis}} is false?",
-        whenObjectiveIncludes: ["build", "implement", "add", "extend", "support"]
+        whenObjectiveIncludes: [
+          "build",
+          "implement",
+          "add",
+          "extend",
+          "support"
+        ]
       }
     ],
     taskTemplates: [