@redush/sysconst-validator 1.0.0

package/dist/index.js

@@ -0,0 +1,1195 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  parseSpec: () => parseSpec,
+  validate: () => validate,
+  validatePhase: () => validatePhase,
+  validateYaml: () => validateYaml
+});
+module.exports = __toCommonJS(index_exports);
+var import_yaml = require("yaml");
+
+// src/phases/01-structural.ts
+var VALID_KINDS = [
+  "System",
+  "Module",
+  "Entity",
+  "Enum",
+  "Value",
+  "Interface",
+  "Command",
+  "Event",
+  "Query",
+  "Process",
+  "Step",
+  "Policy",
+  "Scenario",
+  "Contract"
+];
+var ID_PATTERN = /^[a-z][a-z0-9_.-]*$/;
+function validateStructural(spec) {
+  const errors = [];
+  if (!spec || typeof spec !== "object") {
+    errors.push({
+      code: "STRUCTURAL_ERROR",
+      phase: 1,
+      level: "hard",
+      message: "Spec must be an object",
+      location: ""
+    });
+    return errors;
+  }
+  const s = spec;
+  if (!("spec" in s)) {
+    errors.push({
+      code: "MISSING_SPEC_VERSION",
+      phase: 1,
+      level: "hard",
+      message: "Missing 'spec' field",
+      location: "",
+      suggestion: "Add 'spec: sysconst/v1' at the root"
+    });
+  } else if (s.spec !== "sysconst/v1") {
+    errors.push({
+      code: "INVALID_SPEC_VERSION",
+      phase: 1,
+      level: "hard",
+      message: `Invalid spec version: ${s.spec}`,
+      location: "spec",
+      suggestion: "Use 'spec: sysconst/v1'"
+    });
+  }
+  if (!("project" in s)) {
+    errors.push({
+      code: "MISSING_PROJECT",
+      phase: 1,
+      level: "hard",
+      message: "Missing 'project' field",
+      location: ""
+    });
+  } else {
+    const project = s.project;
+    if (!project.id) {
+      errors.push({
+        code: "MISSING_PROJECT_ID",
+        phase: 1,
+        level: "hard",
+        message: "Missing 'project.id'",
+        location: "project"
+      });
+    }
+    if (!project.versioning) {
+      errors.push({
+        code: "MISSING_VERSIONING",
+        phase: 1,
+        level: "hard",
+        message: "Missing 'project.versioning'",
+        location: "project"
+      });
+    } else {
+      const versioning = project.versioning;
+      if (!versioning.current) {
+        errors.push({
+          code: "MISSING_CURRENT_VERSION",
+          phase: 1,
+          level: "hard",
+          message: "Missing 'project.versioning.current'",
+          location: "project.versioning"
+        });
+      }
+    }
+  }
+  if (!("structure" in s)) {
+    errors.push({
+      code: "MISSING_STRUCTURE",
+      phase: 1,
+      level: "hard",
+      message: "Missing 'structure' field",
+      location: ""
+    });
+  } else {
+    const structure = s.structure;
+    if (!structure.root) {
+      errors.push({
+        code: "MISSING_STRUCTURE_ROOT",
+        phase: 1,
+        level: "hard",
+        message: "Missing 'structure.root'",
+        location: "structure"
+      });
+    }
+  }
+  if (!("domain" in s)) {
+    errors.push({
+      code: "MISSING_DOMAIN",
+      phase: 1,
+      level: "hard",
+      message: "Missing 'domain' field",
+      location: ""
+    });
+  } else {
+    const domain = s.domain;
+    if (!domain.nodes || !Array.isArray(domain.nodes)) {
+      errors.push({
+        code: "MISSING_DOMAIN_NODES",
+        phase: 1,
+        level: "hard",
+        message: "Missing or invalid 'domain.nodes'",
+        location: "domain"
+      });
+    } else {
+      const seenIds = /* @__PURE__ */ new Set();
+      domain.nodes.forEach((node, index) => {
+        const nodeErrors = validateNode(node, `domain.nodes[${index}]`, seenIds);
+        errors.push(...nodeErrors);
+      });
+    }
+  }
+  return errors;
+}
+function validateNode(node, location, seenIds) {
+  const errors = [];
+  if (!node || typeof node !== "object") {
+    errors.push({
+      code: "INVALID_NODE",
+      phase: 1,
+      level: "hard",
+      message: "Node must be an object",
+      location
+    });
+    return errors;
+  }
+  const n = node;
+  if (!("kind" in n)) {
+    errors.push({
+      code: "MISSING_NODE_KIND",
+      phase: 1,
+      level: "hard",
+      message: "Node missing 'kind'",
+      location
+    });
+  } else if (!VALID_KINDS.includes(n.kind)) {
+    errors.push({
+      code: "INVALID_NODE_KIND",
+      phase: 1,
+      level: "hard",
+      message: `Invalid node kind: ${n.kind}`,
+      location: `${location}.kind`,
+      suggestion: `Valid kinds: ${VALID_KINDS.join(", ")}`
+    });
+  }
+  if (!("id" in n)) {
+    errors.push({
+      code: "MISSING_NODE_ID",
+      phase: 1,
+      level: "hard",
+      message: "Node missing 'id'",
+      location
+    });
+  } else {
+    const id = n.id;
+    if (!ID_PATTERN.test(id)) {
+      errors.push({
+        code: "INVALID_NODE_ID",
+        phase: 1,
+        level: "hard",
+        message: `Invalid node ID format: ${id}`,
+        location: `${location}.id`,
+        suggestion: "ID must match pattern: ^[a-z][a-z0-9_.-]*$"
+      });
+    }
+    if (seenIds.has(id)) {
+      errors.push({
+        code: "DUPLICATE_NODE_ID",
+        phase: 1,
+        level: "hard",
+        message: `Duplicate node ID: ${id}`,
+        location: `${location}.id`
+      });
+    } else {
+      seenIds.add(id);
+    }
+  }
+  if (!("spec" in n)) {
+    errors.push({
+      code: "MISSING_NODE_SPEC",
+      phase: 1,
+      level: "hard",
+      message: "Node missing 'spec'",
+      location
+    });
+  } else if (typeof n.spec !== "object" || n.spec === null) {
+    errors.push({
+      code: "MISSING_NODE_SPEC",
+      phase: 1,
+      level: "hard",
+      message: "'spec' must be an object",
+      location: `${location}.spec`
+    });
+  }
+  if ("children" in n && n.children !== void 0) {
+    if (!Array.isArray(n.children)) {
+      errors.push({
+        code: "STRUCTURAL_ERROR",
+        phase: 1,
+        level: "hard",
+        message: "'children' must be an array",
+        location: `${location}.children`
+      });
+    }
+  }
+  return errors;
+}
+
+// src/phases/02-referential.ts
+var NODEREF_PATTERN = /^NodeRef\(([a-z][a-z0-9_.-]*)\)$/;
+function validateReferential(spec) {
+  const errors = [];
+  const nodeIndex = /* @__PURE__ */ new Map();
+  for (const node of spec.domain.nodes) {
+    nodeIndex.set(node.id, node);
+  }
+  const rootRef = spec.structure.root;
+  const rootMatch = NODEREF_PATTERN.exec(rootRef);
+  if (!rootMatch) {
+    errors.push({
+      code: "UNRESOLVED_ROOT",
+      phase: 2,
+      level: "hard",
+      message: `Invalid root reference format: ${rootRef}`,
+      location: "structure.root",
+      suggestion: "Use format: NodeRef(system.xxx)"
+    });
+  } else {
+    const rootId = rootMatch[1];
+    const rootNode = nodeIndex.get(rootId);
+    if (!rootNode) {
+      errors.push({
+        code: "UNRESOLVED_ROOT",
+        phase: 2,
+        level: "hard",
+        message: `Root node not found: ${rootId}`,
+        location: "structure.root"
+      });
+    } else if (rootNode.kind !== "System") {
+      errors.push({
+        code: "INVALID_ROOT_KIND",
+        phase: 2,
+        level: "hard",
+        message: `Root node must be System, got: ${rootNode.kind}`,
+        location: "structure.root"
+      });
+    }
+  }
+  spec.domain.nodes.forEach((node, index) => {
+    if (node.children) {
+      node.children.forEach((child, childIndex) => {
+        if (typeof child === "string") {
+          const match = NODEREF_PATTERN.exec(child);
+          if (match) {
+            const refId = match[1];
+            if (!nodeIndex.has(refId)) {
+              errors.push({
+                code: "UNRESOLVED_NODEREF",
+                phase: 2,
+                level: "hard",
+                message: `NodeRef does not resolve: ${child}`,
+                location: `domain.nodes[${index}].children[${childIndex}]`
+              });
+            }
+          } else {
+            errors.push({
+              code: "UNRESOLVED_NODEREF",
+              phase: 2,
+              level: "hard",
+              message: `Invalid NodeRef format: ${child}`,
+              location: `domain.nodes[${index}].children[${childIndex}]`,
+              suggestion: "Use format: NodeRef(node.id)"
+            });
+          }
+        }
+      });
+    }
+  });
+  const circularErrors = detectCircularChildren(spec.domain.nodes, nodeIndex);
+  errors.push(...circularErrors);
+  if (spec.tests?.scenarios) {
+    spec.tests.scenarios.forEach((ref, index) => {
+      const match = NODEREF_PATTERN.exec(ref);
+      if (match) {
+        const refId = match[1];
+        if (!nodeIndex.has(refId)) {
+          errors.push({
+            code: "UNRESOLVED_NODEREF",
+            phase: 2,
+            level: "hard",
+            message: `Scenario reference does not resolve: ${ref}`,
+            location: `tests.scenarios[${index}]`
+          });
+        }
+      }
+    });
+  }
+  return errors;
+}
+function detectCircularChildren(nodes, nodeIndex) {
+  const errors = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(nodeId, path) {
+    if (recursionStack.has(nodeId)) {
+      errors.push({
+        code: "CIRCULAR_CHILDREN",
+        phase: 2,
+        level: "hard",
+        message: `Circular reference detected: ${[...path, nodeId].join(" -> ")}`,
+        location: `domain.nodes`,
+        context: { cycle: [...path, nodeId] }
+      });
+      return true;
+    }
+    if (visited.has(nodeId)) {
+      return false;
+    }
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    const node = nodeIndex.get(nodeId);
+    if (node?.children) {
+      for (const child of node.children) {
+        if (typeof child === "string") {
+          const match = NODEREF_PATTERN.exec(child);
+          if (match) {
+            const childId = match[1];
+            if (dfs(childId, [...path, nodeId])) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+    recursionStack.delete(nodeId);
+    return false;
+  }
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      dfs(node.id, []);
+    }
+  }
+  return errors;
+}
+
+// src/phases/03-semantic.ts
+var NODEREF_PATTERN2 = /^NodeRef\(([a-z][a-z0-9_.-]*)\)$/;
+function validateSemantic(spec) {
+  const errors = [];
+  const nodeIndex = /* @__PURE__ */ new Map();
+  const entityIds = /* @__PURE__ */ new Set();
+  const enumIds = /* @__PURE__ */ new Set();
+  const commandIds = /* @__PURE__ */ new Set();
+  const eventIds = /* @__PURE__ */ new Set();
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const node of spec.domain.nodes) {
+    nodeIndex.set(node.id, node);
+    switch (node.kind) {
+      case "Entity":
+        entityIds.add(node.id);
+        break;
+      case "Enum":
+        enumIds.add(node.id);
+        break;
+      case "Command":
+        commandIds.add(node.id);
+        break;
+      case "Event":
+        eventIds.add(node.id);
+        break;
+      case "Step":
+        stepIds.add(node.id);
+        break;
+    }
+  }
+  spec.domain.nodes.forEach((node, index) => {
+    const location = `domain.nodes[${index}]`;
+    const nodeErrors = validateNodeSemantic(
+      node,
+      location,
+      { entityIds, enumIds, commandIds, eventIds, stepIds, nodeIndex }
+    );
+    errors.push(...nodeErrors);
+  });
+  return errors;
+}
+function validateNodeSemantic(node, location, ctx) {
+  const errors = [];
+  const spec = node.spec;
+  switch (node.kind) {
+    case "System":
+      if (!spec.goals || !Array.isArray(spec.goals)) {
+        errors.push({
+          code: "SEMANTIC_ERROR",
+          phase: 3,
+          level: "hard",
+          message: "System must have 'goals' array in spec",
+          location: `${location}.spec`
+        });
+      }
+      break;
+    case "Entity":
+      errors.push(...validateEntity(node, location, ctx));
+      break;
+    case "Enum":
+      if (!spec.values || !Array.isArray(spec.values)) {
+        errors.push({
+          code: "SEMANTIC_ERROR",
+          phase: 3,
+          level: "hard",
+          message: "Enum must have 'values' array in spec",
+          location: `${location}.spec`
+        });
+      }
+      break;
+    case "Command":
+      errors.push(...validateCommand(node, location, ctx));
+      break;
+    case "Event":
+      if (!spec.payload || typeof spec.payload !== "object") {
+        errors.push({
+          code: "EVENT_MISSING_PAYLOAD",
+          phase: 3,
+          level: "hard",
+          message: "Event must have 'payload' in spec",
+          location: `${location}.spec`
+        });
+      }
+      break;
+    case "Query":
+      if (!spec.input || typeof spec.input !== "object") {
+        errors.push({
+          code: "QUERY_MISSING_INPUT",
+          phase: 3,
+          level: "hard",
+          message: "Query must have 'input' in spec",
+          location: `${location}.spec`
+        });
+      }
+      if (!spec.output || typeof spec.output !== "object") {
+        errors.push({
+          code: "QUERY_MISSING_OUTPUT",
+          phase: 3,
+          level: "hard",
+          message: "Query must have 'output' in spec",
+          location: `${location}.spec`
+        });
+      }
+      break;
+    case "Process":
+      errors.push(...validateProcess(node, location, ctx));
+      break;
+    case "Step":
+      if (!spec.action || typeof spec.action !== "string") {
+        errors.push({
+          code: "SEMANTIC_ERROR",
+          phase: 3,
+          level: "hard",
+          message: "Step must have 'action' string in spec",
+          location: `${location}.spec`
+        });
+      }
+      break;
+    case "Scenario":
+      errors.push(...validateScenario(node, location, ctx));
+      break;
+  }
+  if (node.contracts) {
+    node.contracts.forEach((contract, cIndex) => {
+      if (!contract.level) {
+        contract.level = "hard";
+      }
+      if (!contract.type && !contract.invariant && !contract.temporal && !contract.rule) {
+        errors.push({
+          code: "INVALID_CONTRACT",
+          phase: 3,
+          level: "hard",
+          message: "Contract must have type, invariant, temporal, or rule",
+          location: `${location}.contracts[${cIndex}]`
+        });
+      }
+    });
+  }
+  return errors;
+}
+function validateEntity(node, location, ctx) {
+  const errors = [];
+  const spec = node.spec;
+  if (!spec.fields || typeof spec.fields !== "object") {
+    errors.push({
+      code: "ENTITY_MISSING_FIELDS",
+      phase: 3,
+      level: "hard",
+      message: "Entity must have 'fields' in spec",
+      location: `${location}.spec`
+    });
+    return errors;
+  }
+  const fields = spec.fields;
+  for (const [fieldName, fieldDef] of Object.entries(fields)) {
+    if (!fieldDef || typeof fieldDef !== "object") {
+      errors.push({
+        code: "FIELD_MISSING_TYPE",
+        phase: 3,
+        level: "hard",
+        message: `Field '${fieldName}' must be an object`,
+        location: `${location}.spec.fields.${fieldName}`
+      });
+      continue;
+    }
+    const field = fieldDef;
+    if (!field.type) {
+      errors.push({
+        code: "FIELD_MISSING_TYPE",
+        phase: 3,
+        level: "hard",
+        message: `Field '${fieldName}' missing 'type'`,
+        location: `${location}.spec.fields.${fieldName}`
+      });
+      continue;
+    }
+    const typeStr = field.type;
+    const refMatch = typeStr.match(/^ref\(([^)]+)\)$/);
+    const enumMatch = typeStr.match(/^enum\(([^)]+)\)$/);
+    if (refMatch) {
+      const refId = refMatch[1];
+      if (!ctx.entityIds.has(refId)) {
+        errors.push({
+          code: "UNRESOLVED_REF_TYPE",
+          phase: 3,
+          level: "hard",
+          message: `Referenced entity not found: ${refId}`,
+          location: `${location}.spec.fields.${fieldName}.type`
+        });
+      }
+    } else if (enumMatch) {
+    }
+  }
+  return errors;
+}
+function validateCommand(node, location, ctx) {
+  const errors = [];
+  const spec = node.spec;
+  if (!spec.input || typeof spec.input !== "object") {
+    errors.push({
+      code: "COMMAND_MISSING_INPUT",
+      phase: 3,
+      level: "hard",
+      message: "Command must have 'input' in spec",
+      location: `${location}.spec`
+    });
+  }
+  if (spec.effects && typeof spec.effects === "object") {
+    const effects = spec.effects;
+    if (effects.emits && Array.isArray(effects.emits)) {
+      effects.emits.forEach((eventId, eIndex) => {
+        if (!ctx.eventIds.has(eventId)) {
+          errors.push({
+            code: "UNRESOLVED_EFFECT_EVENT",
+            phase: 3,
+            level: "hard",
+            message: `Emitted event not found: ${eventId}`,
+            location: `${location}.spec.effects.emits[${eIndex}]`
+          });
+        }
+      });
+    }
+    if (effects.modifies && Array.isArray(effects.modifies)) {
+      effects.modifies.forEach((entityId, eIndex) => {
+        if (!ctx.entityIds.has(entityId)) {
+          errors.push({
+            code: "UNRESOLVED_EFFECT_ENTITY",
+            phase: 3,
+            level: "hard",
+            message: `Modified entity not found: ${entityId}`,
+            location: `${location}.spec.effects.modifies[${eIndex}]`
+          });
+        }
+      });
+    }
+  }
+  return errors;
+}
+function validateProcess(node, location, ctx) {
+  const errors = [];
+  const spec = node.spec;
+  if (!spec.trigger) {
+    errors.push({
+      code: "PROCESS_MISSING_TRIGGER",
+      phase: 3,
+      level: "hard",
+      message: "Process must have 'trigger' in spec",
+      location: `${location}.spec`
+    });
+  } else {
+    const trigger = spec.trigger;
+    if (!ctx.commandIds.has(trigger) && !ctx.eventIds.has(trigger)) {
+      errors.push({
+        code: "INVALID_PROCESS_TRIGGER",
+        phase: 3,
+        level: "hard",
+        message: `Process trigger not found: ${trigger}`,
+        location: `${location}.spec.trigger`
+      });
+    }
+  }
+  if (node.children) {
+    node.children.forEach((child, cIndex) => {
+      if (typeof child === "string") {
+        const match = NODEREF_PATTERN2.exec(child);
+        if (match) {
+          const childId = match[1];
+          const childNode = ctx.nodeIndex.get(childId);
+          if (childNode && childNode.kind !== "Step") {
+            errors.push({
+              code: "INVALID_PROCESS_CHILDREN",
+              phase: 3,
+              level: "hard",
+              message: `Process children must be Steps, got: ${childNode.kind}`,
+              location: `${location}.children[${cIndex}]`
+            });
+          }
+        }
+      }
+    });
+  }
+  return errors;
+}
+function validateScenario(node, location, ctx) {
+  const errors = [];
+  const spec = node.spec;
+  if (!spec.given || !Array.isArray(spec.given)) {
+    errors.push({
+      code: "SCENARIO_MISSING_GIVEN",
+      phase: 3,
+      level: "hard",
+      message: "Scenario must have 'given' array in spec",
+      location: `${location}.spec`
+    });
+  }
+  if (!spec.when || !Array.isArray(spec.when)) {
+    errors.push({
+      code: "SCENARIO_MISSING_WHEN",
+      phase: 3,
+      level: "hard",
+      message: "Scenario must have 'when' array in spec",
+      location: `${location}.spec`
+    });
+  }
+  if (!spec.then || !Array.isArray(spec.then)) {
+    errors.push({
+      code: "SCENARIO_MISSING_THEN",
+      phase: 3,
+      level: "hard",
+      message: "Scenario must have 'then' array in spec",
+      location: `${location}.spec`
+    });
+  }
+  return errors;
+}
+
+// src/phases/04-evolution.ts
+function validateEvolution(spec) {
+  const errors = [];
+  if (!spec.history || spec.history.length === 0) {
+    return errors;
+  }
+  const history = spec.history;
+  if (history[0].basedOn !== null) {
+    errors.push({
+      code: "INVALID_HISTORY_START",
+      phase: 4,
+      level: "hard",
+      message: "First history entry must have basedOn: null",
+      location: "history[0].basedOn"
+    });
+  }
+  for (let i = 1; i < history.length; i++) {
+    const current = history[i];
+    const previous = history[i - 1];
+    if (current.basedOn !== previous.version) {
+      errors.push({
+        code: "BROKEN_HISTORY_CHAIN",
+        phase: 4,
+        level: "hard",
+        message: `History chain broken: ${current.version} basedOn ${current.basedOn}, expected ${previous.version}`,
+        location: `history[${i}].basedOn`
+      });
+    }
+  }
+  const lastVersion = history[history.length - 1].version;
+  if (spec.project.versioning.current !== lastVersion) {
+    errors.push({
+      code: "VERSION_MISMATCH",
+      phase: 4,
+      level: "hard",
+      message: `Current version ${spec.project.versioning.current} doesn't match last history version ${lastVersion}`,
+      location: "project.versioning.current"
+    });
+  }
+  history.forEach((entry, index) => {
+    if (entry.migrations) {
+      entry.migrations.forEach((migration, mIndex) => {
+        const mLocation = `history[${index}].migrations[${mIndex}]`;
+        if (!migration.id) {
+          errors.push({
+            code: "MIGRATION_MISSING_ID",
+            phase: 4,
+            level: "hard",
+            message: "Migration missing 'id'",
+            location: mLocation
+          });
+        }
+        if (!migration.kind) {
+          errors.push({
+            code: "MIGRATION_MISSING_KIND",
+            phase: 4,
+            level: "hard",
+            message: "Migration missing 'kind'",
+            location: mLocation
+          });
+        } else if (!["data", "schema", "process"].includes(migration.kind)) {
+          errors.push({
+            code: "INVALID_MIGRATION_KIND",
+            phase: 4,
+            level: "hard",
+            message: `Invalid migration kind: ${migration.kind}`,
+            location: `${mLocation}.kind`,
+            suggestion: "Valid kinds: 'data', 'schema', 'process'"
+          });
+        }
+        if (!migration.steps || !Array.isArray(migration.steps)) {
+          errors.push({
+            code: "MIGRATION_MISSING_STEPS",
+            phase: 4,
+            level: "hard",
+            message: "Migration missing 'steps'",
+            location: mLocation
+          });
+        }
+      });
+    }
+    if (entry.changes) {
+      const breakingOps = ["remove-field", "rename-field", "type-change", "remove-node", "rename-node"];
+      entry.changes.forEach((change, cIndex) => {
+        if (breakingOps.includes(change.op)) {
+          const hasMigration = entry.migrations?.some(
+            (m) => m.id.includes(change.target) || m.id.includes(change.field || "")
+          );
+          if (!hasMigration && (!entry.migrations || entry.migrations.length === 0)) {
+            errors.push({
+              code: "MISSING_MIGRATION",
+              phase: 4,
+              level: "hard",
+              message: `Breaking change '${change.op}' on '${change.target}' requires migration`,
+              location: `history[${index}].changes[${cIndex}]`,
+              suggestion: "Add a migration with steps to handle this change"
+            });
+          }
+        }
+        if (change.op === "add-field" && change.required === true) {
+          const hasMigration = entry.migrations?.some(
+            (m) => m.id.includes(change.target) || m.id.includes(change.field || "")
+          );
+          if (!hasMigration && (!entry.migrations || entry.migrations.length === 0)) {
+            errors.push({
+              code: "MISSING_MIGRATION",
+              phase: 4,
+              level: "hard",
+              message: `Adding required field '${change.field}' to '${change.target}' requires migration`,
+              location: `history[${index}].changes[${cIndex}]`,
+              suggestion: "Add a migration to backfill existing data"
+            });
+          }
+        }
+      });
+    }
+  });
+  return errors;
+}
+
+// src/phases/05-generation.ts
+function validateGeneration(spec) {
+  const errors = [];
+  if (!spec.generation) {
+    return errors;
+  }
+  const gen = spec.generation;
+  if (gen.zones) {
+    errors.push(...validateZones(gen.zones));
+  }
+  if (gen.hooks) {
+    errors.push(...validateHooks(gen.hooks, gen.zones || []));
+  }
+  return errors;
+}
+function validateZones(zones) {
+  const errors = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  zones.forEach((zone, index) => {
+    const location = `generation.zones[${index}]`;
+    if (!zone.path) {
+      errors.push({
+        code: "GENERATION_ERROR",
+        phase: 5,
+        level: "hard",
+        message: "Zone missing 'path'",
+        location
+      });
+    }
+    if (!zone.mode) {
+      errors.push({
+        code: "GENERATION_ERROR",
+        phase: 5,
+        level: "hard",
+        message: "Zone missing 'mode'",
+        location
+      });
+    } else if (!["overwrite", "anchored", "preserve", "spec-controlled"].includes(zone.mode)) {
+      errors.push({
+        code: "GENERATION_ERROR",
+        phase: 5,
+        level: "hard",
+        message: `Invalid zone mode: ${zone.mode}`,
+        location: `${location}.mode`,
+        suggestion: "Valid modes: 'overwrite', 'anchored', 'preserve', 'spec-controlled'"
+      });
+    }
+    if (zone.path && seenPaths.has(zone.path)) {
+      errors.push({
+        code: "OVERLAPPING_ZONES",
+        phase: 5,
+        level: "hard",
+        message: `Duplicate zone path: ${zone.path}`,
+        location
+      });
+    }
+    if (zone.path) {
+      seenPaths.add(zone.path);
+    }
+  });
+  return errors;
+}
+function validateHooks(hooks, zones) {
+  const errors = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const overwriteZones = zones.filter((z) => z.mode === "overwrite").map((z) => z.path);
+  hooks.forEach((hook, index) => {
+    const location = `generation.hooks[${index}]`;
+    if (!hook.id) {
+      errors.push({
+        code: "GENERATION_ERROR",
+        phase: 5,
+        level: "hard",
+        message: "Hook missing 'id'",
+        location
+      });
+    } else {
+      if (seenIds.has(hook.id)) {
+        errors.push({
+          code: "DUPLICATE_HOOK_ID",
+          phase: 5,
+          level: "hard",
+          message: `Duplicate hook ID: ${hook.id}`,
+          location
+        });
+      }
+      seenIds.add(hook.id);
+    }
+    if (!hook.location) {
+      errors.push({
+        code: "GENERATION_ERROR",
+        phase: 5,
+        level: "hard",
+        message: "Hook missing 'location'",
+        location
+      });
+    } else {
+      if (!hook.location.file) {
+        errors.push({
+          code: "GENERATION_ERROR",
+          phase: 5,
+          level: "hard",
+          message: "Hook location missing 'file'",
+          location: `${location}.location`
+        });
+      }
+      if (!hook.location.anchorStart || !hook.location.anchorEnd) {
+        errors.push({
+          code: "INVALID_HOOK_ANCHORS",
+          phase: 5,
+          level: "hard",
+          message: "Hook location missing 'anchorStart' or 'anchorEnd'",
+          location: `${location}.location`
+        });
+      } else if (hook.location.anchorStart === hook.location.anchorEnd) {
+        errors.push({
+          code: "INVALID_HOOK_ANCHORS",
+          phase: 5,
+          level: "hard",
+          message: "Hook anchorStart and anchorEnd must be different",
+          location: `${location}.location`
+        });
+      }
+      if (hook.location.file) {
+        for (const zonePath of overwriteZones) {
+          if (matchesGlob(hook.location.file, zonePath)) {
+            errors.push({
+              code: "HOOK_IN_OVERWRITE",
+              phase: 5,
+              level: "hard",
+              message: `Hook '${hook.id}' is in overwrite zone: ${zonePath}`,
+              location: `${location}.location.file`,
+              suggestion: "Move hook to an anchored zone"
+            });
+            break;
+          }
+        }
+      }
+    }
+  });
+  return errors;
+}
+function matchesGlob(path, pattern) {
+  const normalizedPath = path.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regexPattern = normalizedPattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\//g, "\\/");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(normalizedPath);
+}
+
+// src/phases/06-verifiability.ts
+function validateVerifiability(spec) {
+  const errors = [];
+  if (spec.generation?.pipelines) {
+    const pipelines = spec.generation.pipelines;
+    if (!pipelines.build) {
+      errors.push({
+        code: "MISSING_BUILD_PIPELINE",
+        phase: 6,
+        level: "hard",
+        message: "Missing required 'build' pipeline",
+        location: "generation.pipelines"
+      });
+    } else if (!pipelines.build.cmd || pipelines.build.cmd.trim() === "") {
+      errors.push({
+        code: "EMPTY_PIPELINE_CMD",
+        phase: 6,
+        level: "hard",
+        message: "'build' pipeline has empty command",
+        location: "generation.pipelines.build.cmd"
+      });
+    }
+    if (!pipelines.test) {
+      errors.push({
+        code: "MISSING_TEST_PIPELINE",
+        phase: 6,
+        level: "hard",
+        message: "Missing required 'test' pipeline",
+        location: "generation.pipelines"
+      });
+    } else if (!pipelines.test.cmd || pipelines.test.cmd.trim() === "") {
+      errors.push({
+        code: "EMPTY_PIPELINE_CMD",
+        phase: 6,
+        level: "hard",
+        message: "'test' pipeline has empty command",
+        location: "generation.pipelines.test.cmd"
+      });
+    }
+    if (!pipelines.migrate) {
+      errors.push({
+        code: "MISSING_MIGRATE_PIPELINE",
+        phase: 6,
+        level: "hard",
+        message: "Missing required 'migrate' pipeline",
+        location: "generation.pipelines"
+      });
+    } else if (!pipelines.migrate.cmd || pipelines.migrate.cmd.trim() === "") {
+      errors.push({
+        code: "EMPTY_PIPELINE_CMD",
+        phase: 6,
+        level: "hard",
+        message: "'migrate' pipeline has empty command",
+        location: "generation.pipelines.migrate.cmd"
+      });
+    }
+  }
+  const commands = spec.domain.nodes.filter((n) => n.kind === "Command");
+  const scenarios = spec.domain.nodes.filter((n) => n.kind === "Scenario");
+  const coveredCommands = /* @__PURE__ */ new Set();
+  for (const scenario of scenarios) {
+    const scenarioSpec = scenario.spec;
+    if (scenarioSpec.when && Array.isArray(scenarioSpec.when)) {
+      for (const action of scenarioSpec.when) {
+        const actionObj = action;
+        if (actionObj.command && typeof actionObj.command === "object") {
+          const cmd = actionObj.command;
+          if (cmd.id) {
+            coveredCommands.add(cmd.id);
+          }
+        }
+      }
+    }
+  }
+  for (const command of commands) {
+    if (!coveredCommands.has(command.id)) {
+      errors.push({
+        code: "LOW_SCENARIO_COVERAGE",
+        phase: 6,
+        level: "soft",
+        message: `Command '${command.id}' has no test scenarios`,
+        location: `domain.nodes`,
+        suggestion: `Add a Scenario that tests ${command.id}`
+      });
+    }
+  }
+  return errors;
+}
+
+// src/index.ts
+function validate(spec, options = {}) {
+  const { phases = [1, 2, 3, 4, 5, 6], strict = false } = options;
+  const allErrors = [];
+  let currentPhase = 1;
+  if (phases.includes(1)) {
+    currentPhase = 1;
+    const errors = validateStructural(spec);
+    allErrors.push(...errors);
+    if (hasHardErrors(errors)) {
+      return buildResult(allErrors, currentPhase, strict);
+    }
+  }
+  const evoSpec = spec;
+  if (phases.includes(2)) {
+    currentPhase = 2;
+    const errors = validateReferential(evoSpec);
+    allErrors.push(...errors);
+    if (hasHardErrors(errors)) {
+      return buildResult(allErrors, currentPhase, strict);
+    }
+  }
+  if (phases.includes(3)) {
+    currentPhase = 3;
+    const errors = validateSemantic(evoSpec);
+    allErrors.push(...errors);
+    if (hasHardErrors(errors)) {
+      return buildResult(allErrors, currentPhase, strict);
+    }
+  }
+  if (phases.includes(4)) {
+    currentPhase = 4;
+    const errors = validateEvolution(evoSpec);
+    allErrors.push(...errors);
+    if (hasHardErrors(errors)) {
+      return buildResult(allErrors, currentPhase, strict);
+    }
+  }
+  if (phases.includes(5)) {
+    currentPhase = 5;
+    const errors = validateGeneration(evoSpec);
+    allErrors.push(...errors);
+    if (hasHardErrors(errors)) {
+      return buildResult(allErrors, currentPhase, strict);
+    }
+  }
+  if (phases.includes(6)) {
+    currentPhase = 6;
+    const errors = validateVerifiability(evoSpec);
+    allErrors.push(...errors);
+  }
+  return buildResult(allErrors, currentPhase, strict);
+}
+function validatePhase(spec, phase) {
+  switch (phase) {
+    case 1:
+      return validateStructural(spec);
+    case 2:
+      return validateReferential(spec);
+    case 3:
+      return validateSemantic(spec);
+    case 4:
+      return validateEvolution(spec);
+    case 5:
+      return validateGeneration(spec);
+    case 6:
+      return validateVerifiability(spec);
+    default:
+      throw new Error(`Invalid phase: ${phase}`);
+  }
+}
+function parseSpec(yaml) {
+  return (0, import_yaml.parse)(yaml);
+}
+function validateYaml(yaml, options = {}) {
+  try {
+    const spec = parseSpec(yaml);
+    return validate(spec, options);
+  } catch (error) {
+    return {
+      ok: false,
+      errors: [{
+        code: "STRUCTURAL_ERROR",
+        phase: 1,
+        level: "hard",
+        message: `Failed to parse YAML: ${error.message}`,
+        location: ""
+      }],
+      warnings: [],
+      phase: 1
+    };
+  }
+}
+function hasHardErrors(errors) {
+  return errors.some((e) => e.level === "hard");
+}
+function buildResult(errors, phase, strict) {
+  const hardErrors = errors.filter((e) => e.level === "hard");
+  const softErrors = errors.filter((e) => e.level === "soft");
+  if (strict) {
+    return {
+      ok: errors.length === 0,
+      errors,
+      warnings: [],
+      phase
+    };
+  }
+  return {
+    ok: hardErrors.length === 0,
+    errors: hardErrors,
+    warnings: softErrors,
+    phase
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseSpec,
+  validate,
+  validatePhase,
+  validateYaml
+});