@lucern/pack-host 0.3.0-alpha.9 → 1.0.1

package/dist/domain-pack/authoring.validation.js

@@ -0,0 +1,1944 @@
+// src/domain-pack/contracts.ts
+function dedupeStrings(values) {
+  return Array.from(
+    new Set(values.map((v) => v.trim()).filter((v) => v.length > 0))
+  );
+}
+function normalizeRuntimeTargets(values) {
+  return values ? dedupeStrings(values) : void 0;
+}
+function normalizeOntologyBinding(binding) {
+  return {
+    ...binding,
+    requiredEntityTypes: binding.requiredEntityTypes ? dedupeStrings(binding.requiredEntityTypes) : void 0,
+    requiredEdgeTypes: binding.requiredEdgeTypes ? dedupeStrings(binding.requiredEdgeTypes) : void 0
+  };
+}
+function normalizeOperatingSystem(layer) {
+  if (!layer) {
+    return;
+  }
+  return {
+    prompts: layer.prompts?.map((prompt) => ({
+      ...prompt,
+      runtimeTargets: normalizeRuntimeTargets(prompt.runtimeTargets)
+    })),
+    tools: layer.tools?.map((tool) => ({
+      ...tool,
+      runtimeTargets: normalizeRuntimeTargets(tool.runtimeTargets)
+    })),
+    setupAssets: layer.setupAssets?.map((asset) => ({
+      ...asset,
+      runtimeTargets: normalizeRuntimeTargets(asset.runtimeTargets)
+    })),
+    topicTemplates: layer.topicTemplates,
+    installProfiles: layer.installProfiles?.map((profile) => ({
+      ...profile,
+      promptIds: dedupeStrings(profile.promptIds),
+      toolIds: dedupeStrings(profile.toolIds),
+      assetIds: dedupeStrings(profile.assetIds),
+      defaultTopicSlugs: dedupeStrings(profile.defaultTopicSlugs)
+    }))
+  };
+}
+function defineDomainPack(input) {
+  return {
+    ...input,
+    ontologyBindings: input.ontologyBindings.map(normalizeOntologyBinding),
+    appPackKeys: input.appPackKeys ? dedupeStrings(input.appPackKeys) : void 0,
+    operatingSystem: normalizeOperatingSystem(input.operatingSystem),
+    workflows: input.workflows.map((w) => ({
+      ...w,
+      requiredArtifacts: dedupeStrings(w.requiredArtifacts),
+      gateCheckpoints: dedupeStrings(w.gateCheckpoints),
+      steps: w.steps.map((s) => ({
+        ...s,
+        requiredRoles: dedupeStrings(s.requiredRoles),
+        produces: s.produces ? dedupeStrings(s.produces) : void 0
+      }))
+    }))
+  };
+}
+
+// src/domain-pack/authoring.core.ts
+var DOMAIN_PACK_MANIFEST_KIND = "lucern-domain-pack-manifest";
+var CURRENT_MANIFEST_VERSION = "1.0.0";
+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 Array.from(
+    new Set(values.map((value) => value.trim()).filter((value) => value.length))
+  );
+}
+function normalizeRuntimeTargets2(values) {
+  return values ? dedupeStrings2(values) : void 0;
+}
+function normalizeFrameworks(frameworks) {
+  if (!frameworks) {
+    return void 0;
+  }
+  return frameworks.map((framework) => ({
+    ...framework,
+    frameworkId: framework.frameworkId.trim(),
+    version: framework.version.trim(),
+    versionConstraint: framework.versionConstraint?.trim(),
+    runtimeTargets: normalizeRuntimeTargets2(framework.runtimeTargets)
+  }));
+}
+function normalizeSchemaExtensions(extensions) {
+  if (!extensions) {
+    return void 0;
+  }
+  return extensions.map((extension) => ({
+    ...extension,
+    extensionId: extension.extensionId.trim(),
+    target: extension.target,
+    description: extension.description.trim(),
+    version: extension.version.trim(),
+    extends: extension.extends?.trim()
+  }));
+}
+function normalizeOntologyExtensions(extensions) {
+  if (!extensions) {
+    return void 0;
+  }
+  return extensions.map((extension) => ({
+    ...extension,
+    extensionId: extension.extensionId.trim(),
+    ontologyId: extension.ontologyId.trim(),
+    baseVersionConstraint: extension.baseVersionConstraint.trim(),
+    entityTypes: extension.entityTypes?.map((entityType) => ({
+      ...entityType,
+      value: entityType.value.trim(),
+      label: entityType.label.trim(),
+      description: entityType.description?.trim(),
+      subtypes: dedupeStrings2(entityType.subtypes)
+    })),
+    edgeTypes: extension.edgeTypes?.map((edgeType) => ({
+      ...edgeType,
+      value: edgeType.value.trim(),
+      label: edgeType.label.trim(),
+      description: edgeType.description?.trim(),
+      sourceTypes: dedupeStrings2(edgeType.sourceTypes),
+      targetTypes: dedupeStrings2(edgeType.targetTypes)
+    }))
+  }));
+}
+function normalizeLineage(lineage) {
+  if (!lineage) {
+    return { mode: "root" };
+  }
+  return {
+    mode: lineage.mode,
+    parentPackId: lineage.parentPackId?.trim(),
+    parentVersion: lineage.parentVersion?.trim(),
+    parentManifestDigest: lineage.parentManifestDigest?.trim(),
+    supersedesPackId: lineage.supersedesPackId?.trim(),
+    notes: lineage.notes?.trim()
+  };
+}
+function normalizeMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  return {
+    description: metadata.description?.trim(),
+    owner: metadata.owner?.trim(),
+    tags: dedupeStrings2(metadata.tags)
+  };
+}
+function toDomainPack(pack) {
+  return defineDomainPack(pack);
+}
+function defineDomainPackAuthoringManifest(input) {
+  return {
+    kind: input.kind ?? DOMAIN_PACK_MANIFEST_KIND,
+    manifestVersion: input.manifestVersion?.trim() || CURRENT_MANIFEST_VERSION,
+    pack: toDomainPack(input.pack),
+    frameworks: normalizeFrameworks(input.frameworks),
+    schemaExtensions: normalizeSchemaExtensions(input.schemaExtensions),
+    ontologyExtensions: normalizeOntologyExtensions(input.ontologyExtensions),
+    lineage: normalizeLineage(input.lineage),
+    metadata: normalizeMetadata(input.metadata)
+  };
+}
+function countManifestArtifacts(manifest) {
+  if (!manifest) {
+    return {
+      topicRoots: 0,
+      workflows: 0,
+      gates: 0,
+      artifacts: 0,
+      roles: 0,
+      prompts: 0,
+      tools: 0,
+      setupAssets: 0,
+      installProfiles: 0,
+      frameworks: 0,
+      schemaExtensions: 0,
+      ontologyExtensions: 0
+    };
+  }
+  return {
+    topicRoots: manifest.pack.topicRoots.length,
+    workflows: manifest.pack.workflows.length,
+    gates: manifest.pack.gates.length,
+    artifacts: manifest.pack.artifacts.length,
+    roles: manifest.pack.roles.length,
+    prompts: manifest.pack.operatingSystem?.prompts?.length ?? 0,
+    tools: manifest.pack.operatingSystem?.tools?.length ?? 0,
+    setupAssets: manifest.pack.operatingSystem?.setupAssets?.length ?? 0,
+    installProfiles: manifest.pack.operatingSystem?.installProfiles?.length ?? 0,
+    frameworks: manifest.frameworks?.length ?? 0,
+    schemaExtensions: manifest.schemaExtensions?.length ?? 0,
+    ontologyExtensions: manifest.ontologyExtensions?.length ?? 0
+  };
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, sortJsonValue(entryValue)])
+    );
+  }
+  return value;
+}
+function toYamlScalar(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return String(value);
+  }
+  return JSON.stringify(String(value));
+}
+function renderYaml(value, indent = 0) {
+  const prefix = " ".repeat(indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${prefix}[]`];
+    }
+    return value.flatMap((entry) => {
+      if (Array.isArray(entry) || isPlainObject(entry)) {
+        return [`${prefix}-`, ...renderYaml(entry, indent + 2)];
+      }
+      return [`${prefix}- ${toYamlScalar(entry)}`];
+    });
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return [`${prefix}{}`];
+    }
+    return entries.flatMap(([key, entryValue]) => {
+      if (entryValue === void 0) {
+        return [];
+      }
+      if (Array.isArray(entryValue)) {
+        if (entryValue.length === 0) {
+          return [`${prefix}${key}: []`];
+        }
+        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      }
+      if (isPlainObject(entryValue)) {
+        if (Object.keys(entryValue).length === 0) {
+          return [`${prefix}${key}: {}`];
+        }
+        return [`${prefix}${key}:`, ...renderYaml(entryValue, indent + 2)];
+      }
+      return [`${prefix}${key}: ${toYamlScalar(entryValue)}`];
+    });
+  }
+  return [`${prefix}${toYamlScalar(value)}`];
+}
+function countIndent(line) {
+  return line.length - line.trimStart().length;
+}
+function parseYamlScalar(raw) {
+  const value = raw.trim();
+  if (value === "null") {
+    return null;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    if (value.startsWith("'")) {
+      return value.slice(1, -1).replace(/''/g, "'");
+    }
+    return JSON.parse(value);
+  }
+  if (value === "[]") {
+    return [];
+  }
+  if (value === "{}") {
+    return {};
+  }
+  return value;
+}
+function splitYamlKeyValue(trimmed) {
+  const separatorIndex = trimmed.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error(`Invalid YAML mapping entry: ${trimmed}`);
+  }
+  const key = trimmed.slice(0, separatorIndex).trim();
+  const value = trimmed.slice(separatorIndex + 1).trim();
+  return { key, value: value.length ? value : null };
+}
+function parseYamlDocument(text) {
+  const rawLines = text.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/\t/g, "  "));
+  const lines = rawLines.filter((line) => {
+    const trimmed = line.trim();
+    return trimmed.length > 0 && trimmed !== "---" && trimmed !== "...";
+  });
+  let index = 0;
+  function parseBlock(indent) {
+    if (index >= lines.length) {
+      return {};
+    }
+    const currentLine = lines[index];
+    const currentIndent = countIndent(currentLine);
+    if (currentIndent < indent) {
+      return {};
+    }
+    if (currentLine.trimStart().startsWith("-")) {
+      return parseArray(indent);
+    }
+    return parseObject(indent);
+  }
+  function parseArray(indent) {
+    const items = [];
+    while (index < lines.length) {
+      const line = lines[index];
+      const currentIndent = countIndent(line);
+      if (currentIndent < indent) {
+        break;
+      }
+      if (currentIndent !== indent) {
+        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+      }
+      const trimmed = line.trimStart();
+      if (!trimmed.startsWith("-")) {
+        break;
+      }
+      const rest = trimmed.slice(1).trimStart();
+      index += 1;
+      if (!rest.length) {
+        items.push(parseBlock(indent + 2));
+        continue;
+      }
+      items.push(parseYamlScalar(rest));
+    }
+    return items;
+  }
+  function parseObject(indent) {
+    const objectValue = {};
+    while (index < lines.length) {
+      const line = lines[index];
+      const currentIndent = countIndent(line);
+      if (currentIndent < indent) {
+        break;
+      }
+      if (currentIndent !== indent) {
+        throw new Error(`Invalid YAML indentation near: ${line.trim()}`);
+      }
+      const trimmed = line.trim();
+      if (trimmed.startsWith("-")) {
+        break;
+      }
+      const { key, value } = splitYamlKeyValue(trimmed);
+      index += 1;
+      objectValue[key] = value === null ? parseBlock(indent + 2) : parseYamlScalar(value);
+    }
+    return objectValue;
+  }
+  return parseBlock(0);
+}
+function detectDomainPackManifestFormat(source, explicitFormat) {
+  if (explicitFormat) {
+    return explicitFormat;
+  }
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{")) {
+    return "json";
+  }
+  return "yaml";
+}
+function serializeDomainPackAuthoringManifest(manifest, format = "json") {
+  const canonicalValue = sortJsonValue(manifest);
+  if (format === "json") {
+    return `${JSON.stringify(canonicalValue, null, 2)}
+`;
+  }
+  return `${renderYaml(canonicalValue).join("\n")}
+`;
+}
+function parseDomainPackAuthoringManifest(source, format) {
+  const detectedFormat = detectDomainPackManifestFormat(source, format);
+  const parsed = detectedFormat === "json" ? JSON.parse(source) : parseYamlDocument(source);
+  if (!isPlainObject(parsed)) {
+    throw new Error("Domain pack manifest must parse to an object.");
+  }
+  if (!("pack" in parsed)) {
+    throw new Error("Domain pack manifest requires a top-level pack object.");
+  }
+  return defineDomainPackAuthoringManifest({
+    kind: parsed.kind,
+    manifestVersion: parsed.manifestVersion,
+    pack: parsed.pack,
+    frameworks: parsed.frameworks,
+    schemaExtensions: parsed.schemaExtensions,
+    ontologyExtensions: parsed.ontologyExtensions,
+    lineage: parsed.lineage,
+    metadata: parsed.metadata
+  });
+}
+
+// src/domain-pack/validation.ts
+function issue(code, message, path, severity = "error") {
+  return { code, severity, message, path };
+}
+var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var SHAPING_QUESTION_TYPES = /* @__PURE__ */ new Set([
+  "validation",
+  "falsification",
+  "assumption_probe",
+  "counterfactual",
+  "scope",
+  "comparison",
+  "mechanism",
+  "general"
+]);
+var RUNTIME_TARGETS = /* @__PURE__ */ new Set(["claude-code", "codex", "hybrid", "portable"]);
+var ONTOLOGY_PROVISION_MODES = /* @__PURE__ */ new Set(["bind", "seed", "extend"]);
+function validateStringArray(values, path, label) {
+  if (!values) {
+    return [];
+  }
+  return values.flatMap((value, index) => {
+    if (!value?.trim()) {
+      return [
+        issue(
+          "INVALID_SHAPING_CONDITION",
+          `${label} must not contain empty strings`,
+          `${path}[${index}]`
+        )
+      ];
+    }
+    return [];
+  });
+}
+function validateRuntimeTargets(values, path) {
+  const issues = validateStringArray(values, path, "runtimeTargets");
+  for (const [index, value] of (values || []).entries()) {
+    if (!RUNTIME_TARGETS.has(value)) {
+      issues.push(
+        issue(
+          "INVALID_RUNTIME_TARGET",
+          `Unsupported runtime target "${value}"`,
+          `${path}[${index}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validatePromptBinding(prompt, index) {
+  const path = `operatingSystem.prompts[${index}]`;
+  const issues = [];
+  if (!prompt.promptId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_PROMPT_ID",
+        "prompt binding requires promptId",
+        `${path}.promptId`
+      )
+    );
+  }
+  if (!prompt.ref?.trim()) {
+    issues.push(
+      issue("MISSING_PROMPT_REF", "prompt binding requires ref", `${path}.ref`)
+    );
+  }
+  issues.push(
+    ...validateRuntimeTargets(prompt.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateToolBinding(tool, index) {
+  const path = `operatingSystem.tools[${index}]`;
+  const issues = [];
+  if (!tool.toolId?.trim()) {
+    issues.push(
+      issue("MISSING_TOOL_ID", "tool binding requires toolId", `${path}.toolId`)
+    );
+  }
+  if (!tool.entrypoint?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOOL_ENTRYPOINT",
+        "tool binding requires entrypoint",
+        `${path}.entrypoint`
+      )
+    );
+  }
+  issues.push(
+    ...validateRuntimeTargets(tool.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateSetupAsset(asset, index) {
+  const path = `operatingSystem.setupAssets[${index}]`;
+  const issues = [];
+  if (!asset.assetId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SETUP_ASSET_ID",
+        "setup asset requires assetId",
+        `${path}.assetId`
+      )
+    );
+  }
+  if (!asset.path?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SETUP_ASSET_PATH",
+        "setup asset requires path",
+        `${path}.path`
+      )
+    );
+  }
+  issues.push(
+    ...validateRuntimeTargets(asset.runtimeTargets, `${path}.runtimeTargets`)
+  );
+  return issues;
+}
+function validateQuestionTemplate(template, index) {
+  const path = `inquiryShaping.questionTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SHAPING_TEMPLATE_ID",
+        "question template requires templateId",
+        `${path}.templateId`
+      )
+    );
+  }
+  if (!template.template?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_SHAPING_TEMPLATE",
+        "question template requires template text",
+        `${path}.template`
+      )
+    );
+  }
+  if (!SHAPING_QUESTION_TYPES.has(template.questionType)) {
+    issues.push(
+      issue(
+        "INVALID_SHAPING_QUESTION_TYPE",
+        `Unsupported questionType "${template.questionType}"`,
+        `${path}.questionType`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  return issues;
+}
+function validateTaskTemplate(template, index) {
+  const path = `inquiryShaping.taskTemplates[${index}]`;
+  const issues = [];
+  if (!template.templateId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_ID",
+        "task template requires templateId",
+        `${path}.templateId`
+      )
+    );
+  }
+  if (!template.title?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TASK_GENERATOR_TITLE",
+        "task template requires title",
+        `${path}.title`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      template.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      template.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (template.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_TASK_GENERATOR_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validateFrameworkHint(hint, index) {
+  const path = `inquiryShaping.frameworkHints[${index}]`;
+  const issues = [];
+  if (!hint.frameworkName?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_FRAMEWORK_HOOK_NAME",
+        "framework hint requires frameworkName",
+        `${path}.frameworkName`
+      )
+    );
+  }
+  if (hint.boost != null && (!Number.isFinite(hint.boost) || hint.boost < 0)) {
+    issues.push(
+      issue(
+        "INVALID_FRAMEWORK_HOOK_BOOST",
+        "framework hint boost must be a non-negative number",
+        `${path}.boost`
+      )
+    );
+  }
+  issues.push(
+    ...validateStringArray(
+      hint.whenObjectiveIncludes,
+      `${path}.whenObjectiveIncludes`,
+      "whenObjectiveIncludes"
+    )
+  );
+  issues.push(
+    ...validateStringArray(
+      hint.whenQuestionTypes,
+      `${path}.whenQuestionTypes`,
+      "whenQuestionTypes"
+    )
+  );
+  for (const [questionTypeIndex, questionType] of (hint.whenQuestionTypes || []).entries()) {
+    if (!SHAPING_QUESTION_TYPES.has(questionType)) {
+      issues.push(
+        issue(
+          "INVALID_FRAMEWORK_HOOK_QUESTION_TYPE",
+          `Unsupported whenQuestionTypes value "${questionType}"`,
+          `${path}.whenQuestionTypes[${questionTypeIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function validateTopicTemplate(template, index, knownTopicSlugs) {
+  const path = `operatingSystem.topicTemplates[${index}]`;
+  const issues = [];
+  if (!template.slug?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_SLUG",
+        "topic template requires slug",
+        `${path}.slug`
+      )
+    );
+  } else if (!KEBAB_CASE.test(template.slug)) {
+    issues.push(
+      issue(
+        "INVALID_TOPIC_TEMPLATE_SLUG",
+        `topic template slug "${template.slug}" must be kebab-case`,
+        `${path}.slug`
+      )
+    );
+  }
+  if (!template.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_NAME",
+        "topic template requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!template.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_TEMPLATE_DESCRIPTION",
+        "topic template requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (template.parentSlug && !knownTopicSlugs.has(template.parentSlug)) {
+    issues.push(
+      issue(
+        "UNKNOWN_TOPIC_PARENT",
+        `topic template references unknown parent "${template.parentSlug}"`,
+        `${path}.parentSlug`
+      )
+    );
+  }
+  return issues;
+}
+function validateInstallProfile(profile, index, knownPromptIds, knownToolIds, knownAssetIds, knownTopicSlugs) {
+  const path = `operatingSystem.installProfiles[${index}]`;
+  const issues = [];
+  if (!profile.profileId?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_ID",
+        "install profile requires profileId",
+        `${path}.profileId`
+      )
+    );
+  }
+  if (!profile.name?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_NAME",
+        "install profile requires name",
+        `${path}.name`
+      )
+    );
+  }
+  if (!profile.description?.trim()) {
+    issues.push(
+      issue(
+        "MISSING_INSTALL_PROFILE_DESCRIPTION",
+        "install profile requires description",
+        `${path}.description`
+      )
+    );
+  }
+  if (!RUNTIME_TARGETS.has(profile.runtimeTarget)) {
+    issues.push(
+      issue(
+        "INVALID_RUNTIME_TARGET",
+        `Unsupported runtime target "${profile.runtimeTarget}"`,
+        `${path}.runtimeTarget`
+      )
+    );
+  }
+  for (const [promptIndex, promptId] of profile.promptIds.entries()) {
+    if (!knownPromptIds.has(promptId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_PROMPT_REF",
+          `install profile references unknown prompt "${promptId}"`,
+          `${path}.promptIds[${promptIndex}]`
+        )
+      );
+    }
+  }
+  for (const [toolIndex, toolId] of profile.toolIds.entries()) {
+    if (!knownToolIds.has(toolId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_TOOL_REF",
+          `install profile references unknown tool "${toolId}"`,
+          `${path}.toolIds[${toolIndex}]`
+        )
+      );
+    }
+  }
+  for (const [assetIndex, assetId] of profile.assetIds.entries()) {
+    if (!knownAssetIds.has(assetId)) {
+      issues.push(
+        issue(
+          "UNKNOWN_SETUP_ASSET_REF",
+          `install profile references unknown setup asset "${assetId}"`,
+          `${path}.assetIds[${assetIndex}]`
+        )
+      );
+    }
+  }
+  for (const [topicIndex, topicSlug] of profile.defaultTopicSlugs.entries()) {
+    if (!knownTopicSlugs.has(topicSlug)) {
+      issues.push(
+        issue(
+          "UNKNOWN_TOPIC_REF",
+          `install profile references unknown topic "${topicSlug}"`,
+          `${path}.defaultTopicSlugs[${topicIndex}]`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function checkDuplicateIds(items, idField, path) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const id = item[idField];
+    if (seen.has(id)) {
+      issues.push(
+        issue(
+          "DUPLICATE_ID",
+          `Duplicate ${idField} "${id}"`,
+          `${path}.${idField}`
+        )
+      );
+    }
+    seen.add(id);
+  }
+  return issues;
+}
+function validateDomainPack(pack) {
+  const issues = [];
+  if (!pack.packId || !pack.packId.trim()) {
+    issues.push(issue("MISSING_PACK_ID", "packId is required", "packId"));
+  } else if (!KEBAB_CASE.test(pack.packId)) {
+    issues.push(
+      issue(
+        "INVALID_PACK_ID",
+        `packId "${pack.packId}" must be kebab-case`,
+        "packId"
+      )
+    );
+  }
+  if (!pack.name || !pack.name.trim()) {
+    issues.push(issue("MISSING_NAME", "name is required", "name"));
+  }
+  if (!pack.version || !pack.version.trim()) {
+    issues.push(issue("MISSING_VERSION", "version is required", "version"));
+  } else if (!SEMVER.test(pack.version)) {
+    issues.push(
+      issue(
+        "INVALID_VERSION",
+        `version "${pack.version}" must be valid semver`,
+        "version"
+      )
+    );
+  }
+  if (!pack.ontologyBindings || pack.ontologyBindings.length === 0) {
+    issues.push(
+      issue(
+        "MISSING_ONTOLOGY_BINDINGS",
+        "At least one ontologyBinding is required",
+        "ontologyBindings"
+      )
+    );
+  } else {
+    for (const [i, binding] of pack.ontologyBindings.entries()) {
+      if (!binding.ontologyId?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_ONTOLOGY_ID",
+            `ontologyBinding[${i}].ontologyId is required`,
+            `ontologyBindings[${i}].ontologyId`
+          )
+        );
+      }
+      if (!binding.versionConstraint?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_VERSION_CONSTRAINT",
+            `ontologyBinding[${i}].versionConstraint is required`,
+            `ontologyBindings[${i}].versionConstraint`
+          )
+        );
+      }
+      if (binding.provisionMode && !ONTOLOGY_PROVISION_MODES.has(binding.provisionMode)) {
+        issues.push(
+          issue(
+            "INVALID_ONTOLOGY_PROVISION_MODE",
+            `Unsupported provisionMode "${binding.provisionMode}"`,
+            `ontologyBindings[${i}].provisionMode`
+          )
+        );
+      }
+      if (binding.provisionMode && binding.provisionMode !== "bind" && !binding.seedRef?.trim()) {
+        issues.push(
+          issue(
+            "MISSING_ONTOLOGY_SEED_REF",
+            `ontologyBinding[${i}] requires seedRef when provisionMode is "${binding.provisionMode}"`,
+            `ontologyBindings[${i}].seedRef`
+          )
+        );
+      }
+      issues.push(
+        ...validateStringArray(
+          binding.requiredEntityTypes,
+          `ontologyBindings[${i}].requiredEntityTypes`,
+          "requiredEntityTypes"
+        ),
+        ...validateStringArray(
+          binding.requiredEdgeTypes,
+          `ontologyBindings[${i}].requiredEdgeTypes`,
+          "requiredEdgeTypes"
+        )
+      );
+    }
+  }
+  if (!pack.topicRoots || pack.topicRoots.length === 0) {
+    issues.push(
+      issue(
+        "MISSING_TOPIC_ROOTS",
+        "At least one topicRoot is required",
+        "topicRoots"
+      )
+    );
+  } else {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.topicRoots,
+        "slug",
+        "topicRoots"
+      )
+    );
+  }
+  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
+          )
+        );
+      });
+    }
+  }
+  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"
+      )
+    );
+  }
+  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) {
+    issues.push(
+      ...checkDuplicateIds(
+        pack.gates,
+        "gateId",
+        "gates"
+      )
+    );
+    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`
+          )
+        );
+      }
+    }
+  }
+  if (pack.artifacts) {
+    issues.push(
+      ...checkDuplicateIds(
+        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`
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  if (pack.inquiryShaping) {
+    if (pack.inquiryShaping.questionTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.questionTemplates,
+          "templateId",
+          "inquiryShaping.questionTemplates"
+        )
+      );
+      pack.inquiryShaping.questionTemplates.forEach((template, index) => {
+        issues.push(...validateQuestionTemplate(template, index));
+      });
+    }
+    if (pack.inquiryShaping.taskTemplates) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.taskTemplates,
+          "templateId",
+          "inquiryShaping.taskTemplates"
+        )
+      );
+      pack.inquiryShaping.taskTemplates.forEach((template, index) => {
+        issues.push(...validateTaskTemplate(template, index));
+      });
+    }
+    if (pack.inquiryShaping.frameworkHints) {
+      issues.push(
+        ...checkDuplicateIds(
+          pack.inquiryShaping.frameworkHints.map((hint) => ({
+            frameworkName: hint.frameworkName
+          })),
+          "frameworkName",
+          "inquiryShaping.frameworkHints"
+        )
+      );
+      pack.inquiryShaping.frameworkHints.forEach((hint, index) => {
+        issues.push(...validateFrameworkHint(hint, index));
+      });
+    }
+  }
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
+}
+
+// src/domain-pack/authoring.validation.ts
+var KEBAB_CASE2 = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var LEGACY_PUBLIC_KEYS = /* @__PURE__ */ new Set([
+  "project",
+  "projects",
+  "projectId",
+  "projectIds",
+  "sprint",
+  "sprints",
+  "sprintId",
+  "sprintIds"
+]);
+var SCHEMA_EXTENSION_TARGETS = /* @__PURE__ */ new Set([
+  "artifact",
+  "workflow",
+  "gate",
+  "prompt",
+  "tool",
+  "install-profile",
+  "topic-template"
+]);
+var ONTOLOGY_CONSTRAINT_SEVERITIES = /* @__PURE__ */ new Set([
+  "error",
+  "warning",
+  "informational"
+]);
+var LINEAGE_MODES = /* @__PURE__ */ new Set(["root", "remix", "fork"]);
+var AUTHORING_TOOL_NAMES = {
+  validate: "validate_domain_pack_manifest",
+  preview: "preview_domain_pack_manifest",
+  publish: "publish_domain_pack_manifest"
+};
+function issue2(code, message, path, source, severity = "error") {
+  return { code, message, path, severity, source };
+}
+function emptyCounts() {
+  return {
+    topicRoots: 0,
+    workflows: 0,
+    gates: 0,
+    artifacts: 0,
+    roles: 0,
+    prompts: 0,
+    tools: 0,
+    setupAssets: 0,
+    installProfiles: 0,
+    frameworks: 0,
+    schemaExtensions: 0,
+    ontologyExtensions: 0
+  };
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function describeParseFailure(error) {
+  return error instanceof Error ? error.message : "Manifest parse failed.";
+}
+function asToolDefinition(tool) {
+  return tool;
+}
+function detectDomainPackManifestFormat2(source, explicitFormat) {
+  if (explicitFormat) {
+    return explicitFormat;
+  }
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{")) {
+    return "json";
+  }
+  return "yaml";
+}
+function validateFrameworks(frameworks) {
+  if (!frameworks) {
+    return [];
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  frameworks.forEach((framework, index) => {
+    const path = `frameworks[${index}]`;
+    if (!framework.frameworkId) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_ID",
+          "frameworkId is required",
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(framework.frameworkId)) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_ID",
+          `frameworkId "${framework.frameworkId}" must be kebab-case`,
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else if (seen.has(framework.frameworkId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_FRAMEWORK_ID",
+          `Duplicate frameworkId "${framework.frameworkId}"`,
+          `${path}.frameworkId`,
+          "framework"
+        )
+      );
+    } else {
+      seen.add(framework.frameworkId);
+    }
+    if (!framework.version) {
+      issues.push(
+        issue2(
+          "MISSING_FRAMEWORK_VERSION",
+          "version is required",
+          `${path}.version`,
+          "framework"
+        )
+      );
+    } else if (!SEMVER2.test(framework.version)) {
+      issues.push(
+        issue2(
+          "INVALID_FRAMEWORK_VERSION",
+          `framework version "${framework.version}" must be valid semver`,
+          `${path}.version`,
+          "framework"
+        )
+      );
+    }
+  });
+  return issues;
+}
+function validateSchemaExtensions(extensions) {
+  if (!extensions) {
+    return [];
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  extensions.forEach((extension, index) => {
+    const path = `schemaExtensions[${index}]`;
+    if (!extension.extensionId) {
+      issues.push(
+        issue2(
+          "MISSING_SCHEMA_EXTENSION_ID",
+          "extensionId is required",
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_ID",
+          `extensionId "${extension.extensionId}" must be kebab-case`,
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else if (seen.has(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_SCHEMA_EXTENSION_ID",
+          `Duplicate schema extension "${extension.extensionId}"`,
+          `${path}.extensionId`,
+          "schema-extension"
+        )
+      );
+    } else {
+      seen.add(extension.extensionId);
+    }
+    if (!SCHEMA_EXTENSION_TARGETS.has(extension.target)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_TARGET",
+          `Unsupported schema extension target "${extension.target}"`,
+          `${path}.target`,
+          "schema-extension"
+        )
+      );
+    }
+    if (!extension.description) {
+      issues.push(
+        issue2(
+          "MISSING_SCHEMA_EXTENSION_DESCRIPTION",
+          "description is required",
+          `${path}.description`,
+          "schema-extension"
+        )
+      );
+    }
+    if (!SEMVER2.test(extension.version)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_VERSION",
+          `schema extension version "${extension.version}" must be valid semver`,
+          `${path}.version`,
+          "schema-extension"
+        )
+      );
+    }
+    if (!isPlainObject2(extension.schema)) {
+      issues.push(
+        issue2(
+          "INVALID_SCHEMA_EXTENSION_SCHEMA",
+          "schema extension schema must be a plain object",
+          `${path}.schema`,
+          "schema-extension"
+        )
+      );
+    }
+  });
+  return issues;
+}
+function validateOntologyExtensions(extensions) {
+  if (!extensions) {
+    return [];
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  extensions.forEach((extension, index) => {
+    const path = `ontologyExtensions[${index}]`;
+    if (!extension.extensionId) {
+      issues.push(
+        issue2(
+          "MISSING_ONTOLOGY_EXTENSION_ID",
+          "extensionId is required",
+          `${path}.extensionId`,
+          "ontology-extension"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "INVALID_ONTOLOGY_EXTENSION_ID",
+          `extensionId "${extension.extensionId}" must be kebab-case`,
+          `${path}.extensionId`,
+          "ontology-extension"
+        )
+      );
+    } else if (seen.has(extension.extensionId)) {
+      issues.push(
+        issue2(
+          "DUPLICATE_ONTOLOGY_EXTENSION_ID",
+          `Duplicate ontology extension "${extension.extensionId}"`,
+          `${path}.extensionId`,
+          "ontology-extension"
+        )
+      );
+    } else {
+      seen.add(extension.extensionId);
+    }
+    if (!extension.ontologyId) {
+      issues.push(
+        issue2(
+          "MISSING_ONTOLOGY_EXTENSION_TARGET",
+          "ontologyId is required",
+          `${path}.ontologyId`,
+          "ontology-extension"
+        )
+      );
+    }
+    if (!extension.baseVersionConstraint) {
+      issues.push(
+        issue2(
+          "MISSING_ONTOLOGY_BASE_VERSION",
+          "baseVersionConstraint is required",
+          `${path}.baseVersionConstraint`,
+          "ontology-extension"
+        )
+      );
+    }
+    if (extension.additiveOnly !== true) {
+      issues.push(
+        issue2(
+          "NON_MONOTONIC_ONTOLOGY_EXTENSION",
+          "ontology extensions must set additiveOnly=true",
+          `${path}.additiveOnly`,
+          "ontology-extension"
+        )
+      );
+    }
+    const entityTypeValues = /* @__PURE__ */ new Set();
+    extension.entityTypes?.forEach(
+      (entityType, entityTypeIndex) => {
+        const entityPath = `${path}.entityTypes[${entityTypeIndex}]`;
+        if (!entityType.value || !KEBAB_CASE2.test(entityType.value)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_ENTITY_VALUE",
+              "entity extension value must be kebab-case",
+              `${entityPath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else if (entityTypeValues.has(entityType.value)) {
+          issues.push(
+            issue2(
+              "DUPLICATE_ONTOLOGY_ENTITY_VALUE",
+              `Duplicate entity extension value "${entityType.value}"`,
+              `${entityPath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else {
+          entityTypeValues.add(entityType.value);
+        }
+        if (!entityType.label) {
+          issues.push(
+            issue2(
+              "MISSING_ONTOLOGY_ENTITY_LABEL",
+              "entity extension label is required",
+              `${entityPath}.label`,
+              "ontology-extension"
+            )
+          );
+        }
+      }
+    );
+    const edgeTypeValues = /* @__PURE__ */ new Set();
+    extension.edgeTypes?.forEach(
+      (edgeType, edgeTypeIndex) => {
+        const edgePath = `${path}.edgeTypes[${edgeTypeIndex}]`;
+        if (!edgeType.value || !KEBAB_CASE2.test(edgeType.value)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_EDGE_VALUE",
+              "edge extension value must be kebab-case",
+              `${edgePath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else if (edgeTypeValues.has(edgeType.value)) {
+          issues.push(
+            issue2(
+              "DUPLICATE_ONTOLOGY_EDGE_VALUE",
+              `Duplicate edge extension value "${edgeType.value}"`,
+              `${edgePath}.value`,
+              "ontology-extension"
+            )
+          );
+        } else {
+          edgeTypeValues.add(edgeType.value);
+        }
+        if (!edgeType.label) {
+          issues.push(
+            issue2(
+              "MISSING_ONTOLOGY_EDGE_LABEL",
+              "edge extension label is required",
+              `${edgePath}.label`,
+              "ontology-extension"
+            )
+          );
+        }
+        if (edgeType.constraintSeverity && !ONTOLOGY_CONSTRAINT_SEVERITIES.has(edgeType.constraintSeverity)) {
+          issues.push(
+            issue2(
+              "INVALID_ONTOLOGY_EDGE_SEVERITY",
+              `Unsupported constraint severity "${edgeType.constraintSeverity}"`,
+              `${edgePath}.constraintSeverity`,
+              "ontology-extension"
+            )
+          );
+        }
+      }
+    );
+  });
+  return issues;
+}
+function validateLineage(lineage, packId) {
+  const issues = [];
+  if (!LINEAGE_MODES.has(lineage.mode)) {
+    issues.push(
+      issue2(
+        "INVALID_LINEAGE_MODE",
+        `Unsupported lineage mode "${lineage.mode}"`,
+        "lineage.mode",
+        "lineage"
+      )
+    );
+    return issues;
+  }
+  if (lineage.mode === "root") {
+    if (lineage.parentPackId || lineage.parentVersion || lineage.supersedesPackId) {
+      issues.push(
+        issue2(
+          "ROOT_LINEAGE_HAS_PARENT",
+          "root lineage cannot declare parent or supersedes metadata",
+          "lineage",
+          "lineage"
+        )
+      );
+    }
+    return issues;
+  }
+  if (!lineage.parentPackId) {
+    issues.push(
+      issue2(
+        "MISSING_LINEAGE_PARENT_PACK",
+        "parentPackId is required for remix or fork lineage",
+        "lineage.parentPackId",
+        "lineage"
+      )
+    );
+  } else if (!KEBAB_CASE2.test(lineage.parentPackId)) {
+    issues.push(
+      issue2(
+        "INVALID_LINEAGE_PARENT_PACK",
+        `parentPackId "${lineage.parentPackId}" must be kebab-case`,
+        "lineage.parentPackId",
+        "lineage"
+      )
+    );
+  }
+  if (!lineage.parentVersion) {
+    issues.push(
+      issue2(
+        "MISSING_LINEAGE_PARENT_VERSION",
+        "parentVersion is required for remix or fork lineage",
+        "lineage.parentVersion",
+        "lineage"
+      )
+    );
+  } else if (!SEMVER2.test(lineage.parentVersion)) {
+    issues.push(
+      issue2(
+        "INVALID_LINEAGE_PARENT_VERSION",
+        `parentVersion "${lineage.parentVersion}" must be valid semver`,
+        "lineage.parentVersion",
+        "lineage"
+      )
+    );
+  }
+  if (lineage.parentPackId && lineage.parentPackId === packId && lineage.parentVersion === void 0) {
+    issues.push(
+      issue2(
+        "SELF_REFERENTIAL_LINEAGE",
+        "lineage parentPackId cannot equal the child packId without an explicit parentVersion",
+        "lineage.parentPackId",
+        "lineage"
+      )
+    );
+  }
+  if (lineage.mode === "remix" && lineage.supersedesPackId) {
+    issues.push(
+      issue2(
+        "REMIX_LINEAGE_SUPERSEDES",
+        "remix lineage cannot declare supersedesPackId",
+        "lineage.supersedesPackId",
+        "lineage"
+      )
+    );
+  }
+  if (lineage.mode === "fork") {
+    if (!lineage.supersedesPackId) {
+      issues.push(
+        issue2(
+          "MISSING_SUPERSEDES_PACK",
+          "fork lineage requires supersedesPackId to model the supersedes edge",
+          "lineage.supersedesPackId",
+          "lineage"
+        )
+      );
+    } else if (!KEBAB_CASE2.test(lineage.supersedesPackId)) {
+      issues.push(
+        issue2(
+          "INVALID_SUPERSEDES_PACK",
+          `supersedesPackId "${lineage.supersedesPackId}" must be kebab-case`,
+          "lineage.supersedesPackId",
+          "lineage"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function scanLegacyPublicKeys(value, path = "") {
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      issues.push(...scanLegacyPublicKeys(entry, `${path}[${index}]`));
+    });
+    return issues;
+  }
+  if (!isPlainObject2(value)) {
+    return issues;
+  }
+  Object.entries(value).forEach(([key, entryValue]) => {
+    const nextPath = path ? `${path}.${key}` : key;
+    if (LEGACY_PUBLIC_KEYS.has(key)) {
+      issues.push(
+        issue2(
+          "LEGACY_PUBLIC_TERM",
+          `Public manifest field "${key}" uses legacy terminology; expose canonical topic/worktree terms instead.`,
+          nextPath,
+          "terminology"
+        )
+      );
+    }
+    issues.push(...scanLegacyPublicKeys(entryValue, nextPath));
+  });
+  return issues;
+}
+function createManifestDigest(manifest) {
+  const data = serializeDomainPackAuthoringManifest(manifest, "json");
+  let h1 = 2166136261 | 0;
+  let h2 = 2166136261 | 0;
+  for (let i = 0; i < data.length; i++) {
+    const c = data.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 16777619);
+    h2 = Math.imul(h2 ^ (c >>> 4 | c << 4), 16777619);
+  }
+  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+}
+function evaluateDomainPackAuthoringManifest(manifest, format = null) {
+  const issues = [];
+  if (manifest.kind !== DOMAIN_PACK_MANIFEST_KIND) {
+    issues.push(
+      issue2(
+        "INVALID_MANIFEST_KIND",
+        `kind must be "${DOMAIN_PACK_MANIFEST_KIND}"`,
+        "kind",
+        "manifest"
+      )
+    );
+  }
+  if (!SEMVER2.test(manifest.manifestVersion)) {
+    issues.push(
+      issue2(
+        "INVALID_MANIFEST_VERSION",
+        `manifestVersion "${manifest.manifestVersion}" must be valid semver`,
+        "manifestVersion",
+        "manifest"
+      )
+    );
+  }
+  issues.push(...validateFrameworks(manifest.frameworks));
+  issues.push(...validateSchemaExtensions(manifest.schemaExtensions));
+  issues.push(...validateOntologyExtensions(manifest.ontologyExtensions));
+  issues.push(...validateLineage(manifest.lineage, manifest.pack.packId));
+  issues.push(...scanLegacyPublicKeys(manifest));
+  const packValidation = validateDomainPack(manifest.pack);
+  issues.push(
+    ...packValidation.issues.map((packIssue) => ({
+      ...packIssue,
+      path: `pack.${packIssue.path}`,
+      source: "pack"
+    }))
+  );
+  return {
+    valid: issues.every((currentIssue) => currentIssue.severity !== "error"),
+    format,
+    manifest,
+    manifestDigest: createManifestDigest(manifest),
+    issues,
+    counts: countManifestArtifacts(manifest)
+  };
+}
+function parseFailureResult(error, format) {
+  return {
+    valid: false,
+    format,
+    manifest: null,
+    manifestDigest: null,
+    issues: [
+      issue2(
+        "PARSE_ERROR",
+        describeParseFailure(error),
+        "manifest",
+        "parse"
+      )
+    ],
+    counts: emptyCounts()
+  };
+}
+function validateDomainPackAuthoringManifest(manifest) {
+  return evaluateDomainPackAuthoringManifest(
+    defineDomainPackAuthoringManifest(
+      manifest
+    )
+  );
+}
+function validateDomainPackAuthoringManifestSource(source, format) {
+  const detectedFormat = detectDomainPackManifestFormat2(source, format);
+  try {
+    const manifest = parseDomainPackAuthoringManifest(source, detectedFormat);
+    return evaluateDomainPackAuthoringManifest(manifest, detectedFormat);
+  } catch (error) {
+    return parseFailureResult(error, detectedFormat);
+  }
+}
+function collectRuntimeTargets(manifest) {
+  if (!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)
+  );
+  return Array.from(targets).sort();
+}
+function describeLineage(lineage) {
+  if (!lineage) {
+    return null;
+  }
+  if (lineage.mode === "root") {
+    return "Root pack with no parent lineage.";
+  }
+  if (lineage.mode === "remix") {
+    return `Remix of ${lineage.parentPackId}@${lineage.parentVersion}.`;
+  }
+  return `Fork of ${lineage.parentPackId}@${lineage.parentVersion} that supersedes ${lineage.supersedesPackId}.`;
+}
+function previewDomainPackAuthoringManifest(manifest) {
+  const validation = validateDomainPackAuthoringManifest(manifest);
+  return {
+    ...validation,
+    readyToPublish: validation.valid,
+    canonicalJson: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "json") : null,
+    canonicalYaml: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "yaml") : null,
+    lineageSummary: describeLineage(validation.manifest?.lineage ?? null),
+    requiredRuntimeTargets: collectRuntimeTargets(validation.manifest)
+  };
+}
+function previewDomainPackAuthoringManifestSource(source, format) {
+  const validation = validateDomainPackAuthoringManifestSource(source, format);
+  return {
+    ...validation,
+    readyToPublish: validation.valid,
+    canonicalJson: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "json") : null,
+    canonicalYaml: validation.manifest ? serializeDomainPackAuthoringManifest(validation.manifest, "yaml") : null,
+    lineageSummary: describeLineage(validation.manifest?.lineage ?? null),
+    requiredRuntimeTargets: collectRuntimeTargets(validation.manifest)
+  };
+}
+function buildLineageEdge(manifest) {
+  const { lineage, pack } = manifest;
+  if (lineage.mode === "root") {
+    return null;
+  }
+  if (lineage.mode === "remix") {
+    return {
+      edgeType: "remixed_from",
+      childPackId: pack.packId,
+      parentPackId: lineage.parentPackId,
+      parentVersion: lineage.parentVersion
+    };
+  }
+  return {
+    edgeType: "supersedes",
+    childPackId: pack.packId,
+    parentPackId: lineage.supersedesPackId,
+    parentVersion: lineage.parentVersion
+  };
+}
+function publishDomainPackAuthoringManifest(manifest) {
+  const preview = previewDomainPackAuthoringManifest(manifest);
+  if (!preview.readyToPublish || !preview.manifest || !preview.manifestDigest) {
+    return {
+      published: false,
+      preview,
+      publication: null
+    };
+  }
+  return {
+    published: true,
+    preview,
+    publication: {
+      publicationId: `${preview.manifest.pack.packId}@${preview.manifest.pack.version}`,
+      packId: preview.manifest.pack.packId,
+      version: preview.manifest.pack.version,
+      manifestDigest: preview.manifestDigest,
+      manifest: preview.manifest,
+      lineageEdge: buildLineageEdge(preview.manifest),
+      canonicalJson: preview.canonicalJson,
+      canonicalYaml: preview.canonicalYaml
+    }
+  };
+}
+function publishDomainPackAuthoringManifestSource(source, format) {
+  const preview = previewDomainPackAuthoringManifestSource(source, format);
+  if (!preview.readyToPublish || !preview.manifest || !preview.manifestDigest) {
+    return {
+      published: false,
+      preview,
+      publication: null
+    };
+  }
+  return {
+    published: true,
+    preview,
+    publication: {
+      publicationId: `${preview.manifest.pack.packId}@${preview.manifest.pack.version}`,
+      packId: preview.manifest.pack.packId,
+      version: preview.manifest.pack.version,
+      manifestDigest: preview.manifestDigest,
+      manifest: preview.manifest,
+      lineageEdge: buildLineageEdge(preview.manifest),
+      canonicalJson: preview.canonicalJson,
+      canonicalYaml: preview.canonicalYaml
+    }
+  };
+}
+function createDomainPackAuthoringTools() {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      manifestText: {
+        type: "string",
+        description: "Domain pack manifest text in JSON or YAML form."
+      },
+      format: {
+        type: "string",
+        enum: ["json", "yaml"],
+        description: "Optional manifest format override."
+      }
+    },
+    required: ["manifestText"],
+    additionalProperties: false
+  };
+  return {
+    validate: asToolDefinition({
+      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)
+    }),
+    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)
+    }),
+    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)
+    })
+  };
+}
+var domainPackAuthoringValidation = {
+  validateDomainPackAuthoringManifest,
+  validateDomainPackAuthoringManifestSource,
+  previewDomainPackAuthoringManifest,
+  previewDomainPackAuthoringManifestSource,
+  publishDomainPackAuthoringManifest,
+  publishDomainPackAuthoringManifestSource,
+  createDomainPackAuthoringTools
+};
+
+export { domainPackAuthoringValidation };
+//# sourceMappingURL=authoring.validation.js.map
+//# sourceMappingURL=authoring.validation.js.map