@documentation-robotics/cli 0.2.0 → 0.4.0

package/dist/core/changeset-only-guard.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/changeset-only-guard.ts"],
+  "sourcesContent": ["/**\n * Changeset-only guard for chat agents.\n *\n * `dr visualize --with-changesets` lets its chat agent run `dr add`, `dr update` and\n * `dr relationship add`. Those commands stage their change when a changeset is active,\n * but write straight to the model when none is, and Claude Code's permission rules can't\n * tell the two apart. So the agent process runs with `CHANGESET_ONLY_ENV` set, and every\n * method that saves the base model calls `assertBaseModelWritable()` first: with the\n * variable set, the write fails and nothing on disk changes. Staging writes go to the\n * changeset store, not through the model, so they are unaffected.\n */\nimport { CLIError, ErrorCategory } from \"../utils/errors.js\";\n\nexport const CHANGESET_ONLY_ENV = \"DR_CHANGESET_ONLY\";\n\nconst ON_VALUES = new Set([\"true\", \"1\", \"yes\", \"on\"]);\nconst OFF_VALUES = new Set([\"false\", \"0\", \"no\", \"off\"]);\nconst warnedValues = new Set<string>();\n\n/**\n * Whether this process may only change the model through a changeset.\n *\n * Unset or empty means off. true/1/yes/on (any case) mean on, false/0/no/off mean off. Any\n * other value fails safe: the guard is on, and a warning naming the value goes to stderr once,\n * so a typo never silently lets an agent write the base model.\n */\nexport function isChangesetOnly(env: NodeJS.ProcessEnv = process.env): boolean {\n  const raw = env[CHANGESET_ONLY_ENV];\n  if (raw === undefined) return false;\n  const value = raw.trim().toLowerCase();\n  if (value === \"\" || OFF_VALUES.has(value)) return false;\n  if (ON_VALUES.has(value)) return true;\n  if (!warnedValues.has(raw)) {\n    warnedValues.add(raw);\n    console.error(\n      `[dr] ${CHANGESET_ONLY_ENV}=${JSON.stringify(raw)} is not a recognised value ` +\n        \"(use true/1/yes/on or false/0/no/off); treating it as on, so base-model writes are refused.\"\n    );\n  }\n  return true;\n}\n\n/** Test hook: forget which unrecognised values have already been warned about. */\nexport function resetChangesetOnlyWarnings(): void {\n  warnedValues.clear();\n}\n\n/** Thrown by `assertBaseModelWritable()`, so callers (e.g. the MCP server) can recognise the refusal. */\nexport class ChangesetOnlyError extends CLIError {\n  constructor(...args: ConstructorParameters<typeof CLIError>) {\n    super(...args);\n    this.name = \"ChangesetOnlyError\";\n  }\n}\n\n/** Throws when this process may only change the model through a changeset. */\nexport function assertBaseModelWritable(env: NodeJS.ProcessEnv = process.env): void {\n  if (!isChangesetOnly(env)) return;\n  throw new ChangesetOnlyError(\n    \"This session can only change the model through a changeset, and no changeset is active.\",\n    ErrorCategory.USER,\n    [\n      'Run \"dr changeset create <name>\" (it activates the new changeset), or \"dr changeset activate <name>\"',\n      \"Then re-run the command: it will be staged in the changeset for the user to review and commit\",\n    ],\n    { operation: \"save model\", context: `${CHANGESET_ONLY_ENV}=${env[CHANGESET_ONLY_ENV]}` }\n  );\n}\n"],
+  "mappings": "AAWA,SAAS,UAAU,qBAAqB;AAEjC,MAAM,qBAAqB,qBAE5B,YAAY,oBAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,GAC9C,aAAa,oBAAI,IAAI,CAAC,SAAS,KAAK,MAAM,KAAK,CAAC,GAChD,eAAe,oBAAI,IAAG;AAStB,SAAU,gBAAgB,MAAyB,QAAQ,KAAG;AAClE,QAAM,MAAM,IAAI,kBAAkB;AAClC,MAAI,QAAQ;AAAW,WAAO;AAC9B,QAAM,QAAQ,IAAI,KAAI,EAAG,YAAW;AACpC,SAAI,UAAU,MAAM,WAAW,IAAI,KAAK,IAAU,MAC9C,UAAU,IAAI,KAAK,KAClB,aAAa,IAAI,GAAG,MACvB,aAAa,IAAI,GAAG,GACpB,QAAQ,MACN,QAAQ,kBAAkB,IAAI,KAAK,UAAU,GAAG,CAAC,wHAC8C,IAG5F;AACT;AAGM,SAAU,6BAA0B;AACxC,eAAa,MAAK;AACpB;AAGM,MAAO,2BAA2B,SAAQ;EAC9C,eAAe,MAA4C;AACzD,UAAM,GAAG,IAAI,GACb,KAAK,OAAO;EACd;;AAII,SAAU,wBAAwB,MAAyB,QAAQ,KAAG;AAC1E,MAAK,gBAAgB,GAAG;AACxB,UAAM,IAAI,mBACR,2FACA,cAAc,MACd;MACE;MACA;OAEF,EAAE,WAAW,cAAc,SAAS,GAAG,kBAAkB,IAAI,IAAI,kBAAkB,CAAC,GAAE,CAAE;AAE5F;",
+  "names": []
+}

package/dist/core/changeset-summary.js

@@ -0,0 +1,68 @@
+import { stagedRelationshipTriple } from "./relationship-staging.js";
+const FIELD_ALIASES = { sourceReference: "source_reference" }, NESTED_FIELDS = /* @__PURE__ */ new Set(["attributes", "metadata"]);
+function isRecord(value) {
+  return !!value && typeof value == "object" && !Array.isArray(value);
+}
+function canonical(value) {
+  return value === void 0 ? "undefined" : Array.isArray(value) ? `[${value.map(canonical).join(",")}]` : isRecord(value) ? `{${Object.keys(value).filter((k) => value[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(",")}}` : JSON.stringify(value);
+}
+function isUnset(value) {
+  return value == null;
+}
+function sameValue(a, b) {
+  return isUnset(a) && isUnset(b) ? !0 : canonical(a) === canonical(b);
+}
+function normalizeSnapshot(snapshot) {
+  const out = {};
+  if (!snapshot)
+    return out;
+  for (const [key, value] of Object.entries(snapshot)) {
+    const name = FIELD_ALIASES[key] ?? key;
+    (name !== key || !(name in out)) && (out[name] = value);
+  }
+  return out;
+}
+function changedFields(before, after) {
+  const a = normalizeSnapshot(before), b = normalizeSnapshot(after), fields = [];
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]))
+    if (!sameValue(a[key], b[key])) {
+      if (NESTED_FIELDS.has(key) && (isRecord(a[key]) || isUnset(a[key])) && (isRecord(b[key]) || isUnset(b[key]))) {
+        const inner = { before: a[key] ?? {}, after: b[key] ?? {} };
+        for (const sub of /* @__PURE__ */ new Set([...Object.keys(inner.before), ...Object.keys(inner.after)]))
+          sameValue(inner.before[sub], inner.after[sub]) || fields.push(`${key}.${sub}`);
+        continue;
+      }
+      fields.push(key);
+    }
+  return fields.sort();
+}
+function elementType(change) {
+  const type = (change.after ?? change.before)?.type;
+  return typeof type == "string" ? type : void 0;
+}
+function summarizeChange(change, index) {
+  const base = { sequence: change.sequenceNumber ?? index, operation: change.type, layer: change.layerName };
+  if (change.type === "relationship-add" || change.type === "relationship-delete") {
+    const triple = stagedRelationshipTriple(change);
+    return triple ? { ...base, ...triple } : { ...base, elementId: change.elementId };
+  }
+  const entry = { ...base, elementId: change.elementId }, type = elementType(change);
+  return type && (entry.elementType = type), change.type === "update" && (entry.changedFields = changedFields(change.before, change.after)), entry;
+}
+function summarizeChangeset(changes) {
+  const totals = {
+    add: 0,
+    update: 0,
+    delete: 0,
+    "relationship-add": 0,
+    "relationship-delete": 0,
+    total: changes.length
+  }, entries = changes.map((change, index) => (totals[change.type] = (totals[change.type] ?? 0) + 1, summarizeChange(change, index)));
+  return entries.sort((x, y) => x.sequence - y.sequence), { totals, changes: entries };
+}
+export {
+  changedFields,
+  summarizeChange,
+  summarizeChangeset
+};
+//# sourceMappingURL=changeset-summary.js.map

package/dist/core/changeset-summary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/changeset-summary.ts"],
+  "sourcesContent": ["/**\n * A compact view of a changeset's staged changes: one entry per change with its operation and what\n * it names, and for updates the fields it changed, without the before/after snapshots.\n *\n * Used by the MCP `changeset_show` tool's `detail: \"summary\"` mode, where an agent iterating on a\n * plan wants to see the plan's shape each pass without paying for every element snapshot.\n * See docs/CHANGE_MODELING.md (\"Iterating on a plan\").\n */\n\nimport type { Change, StagedChange } from \"./changeset.js\";\nimport { stagedRelationshipTriple } from \"./relationship-staging.js\";\n\nexport type ChangeOperation = Change[\"type\"];\n\nexport interface ChangeSummaryEntry {\n  sequence: number;\n  operation: ChangeOperation;\n  layer: string;\n  /** Element changes: the element's id. */\n  elementId?: string;\n  /** Element changes: the element's type (from its snapshot). */\n  elementType?: string;\n  /** Updates: the fields that differ between before and after (`name`, `attributes.summary`, ...). */\n  changedFields?: string[];\n  /** Relationship changes: the relationship's ends and predicate. */\n  source?: string;\n  predicate?: string;\n  target?: string;\n}\n\nexport interface ChangesetSummary {\n  totals: Record<ChangeOperation, number> & { total: number };\n  changes: ChangeSummaryEntry[];\n}\n\n/** Snapshot keys that name the same field. The legacy camelCase key is reported as `source_reference`. */\nconst FIELD_ALIASES: Record<string, string> = { sourceReference: \"source_reference\" };\n\n/** Keys whose nested keys are reported one level down (`attributes.summary`). */\nconst NESTED_FIELDS = new Set([\"attributes\", \"metadata\"]);\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return !!value && typeof value === \"object\" && !Array.isArray(value);\n}\n\n/** Stable JSON for comparing snapshot values regardless of key order. */\nfunction canonical(value: unknown): string {\n  if (value === undefined) return \"undefined\";\n  if (Array.isArray(value)) return `[${value.map(canonical).join(\",\")}]`;\n  if (isRecord(value)) {\n    const keys = Object.keys(value)\n      .filter((k) => value[k] !== undefined)\n      .sort();\n    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(\",\")}}`;\n  }\n  return JSON.stringify(value);\n}\n\n/** `null` and absent both mean \"not set\" in a snapshot (a cleared source reference is written as null). */\nfunction isUnset(value: unknown): boolean {\n  return value === undefined || value === null;\n}\n\nfunction sameValue(a: unknown, b: unknown): boolean {\n  if (isUnset(a) && isUnset(b)) return true;\n  return canonical(a) === canonical(b);\n}\n\nfunction normalizeSnapshot(snapshot: Record<string, unknown> | undefined): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (!snapshot) return out;\n  for (const [key, value] of Object.entries(snapshot)) {\n    const name = FIELD_ALIASES[key] ?? key;\n    // The legacy key carries the intended value; it wins over a stale snake_case copy.\n    if (name !== key || !(name in out)) out[name] = value;\n  }\n  return out;\n}\n\n/**\n * The fields an update changes: top-level snapshot keys whose values differ, with `attributes`\n * and `metadata` broken down by key. Sorted for a stable result.\n */\nexport function changedFields(\n  before: Record<string, unknown> | undefined,\n  after: Record<string, unknown> | undefined\n): string[] {\n  const a = normalizeSnapshot(before);\n  const b = normalizeSnapshot(after);\n  const fields: string[] = [];\n  for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {\n    if (sameValue(a[key], b[key])) continue;\n    if (NESTED_FIELDS.has(key) && (isRecord(a[key]) || isUnset(a[key])) && (isRecord(b[key]) || isUnset(b[key]))) {\n      const inner = { before: (a[key] ?? {}) as Record<string, unknown>, after: (b[key] ?? {}) as Record<string, unknown> };\n      for (const sub of new Set([...Object.keys(inner.before), ...Object.keys(inner.after)])) {\n        if (!sameValue(inner.before[sub], inner.after[sub])) fields.push(`${key}.${sub}`);\n      }\n      continue;\n    }\n    fields.push(key);\n  }\n  return fields.sort();\n}\n\nfunction elementType(change: Change): string | undefined {\n  const snapshot = (change.after ?? change.before) as Record<string, unknown> | undefined;\n  const type = snapshot?.type;\n  return typeof type === \"string\" ? type : undefined;\n}\n\nexport function summarizeChange(change: Change | StagedChange, index: number): ChangeSummaryEntry {\n  const sequence = (change as StagedChange).sequenceNumber ?? index;\n  const base = { sequence, operation: change.type, layer: change.layerName };\n  if (change.type === \"relationship-add\" || change.type === \"relationship-delete\") {\n    const triple = stagedRelationshipTriple(change as StagedChange);\n    // A malformed row still gets an entry, named by its key, rather than vanishing from the view.\n    return triple ? { ...base, ...triple } : { ...base, elementId: change.elementId };\n  }\n  const entry: ChangeSummaryEntry = { ...base, elementId: change.elementId };\n  const type = elementType(change);\n  if (type) entry.elementType = type;\n  if (change.type === \"update\") {\n    entry.changedFields = changedFields(\n      change.before as Record<string, unknown> | undefined,\n      change.after as Record<string, unknown> | undefined\n    );\n  }\n  return entry;\n}\n\nexport function summarizeChangeset(changes: ReadonlyArray<Change | StagedChange>): ChangesetSummary {\n  const totals = {\n    add: 0,\n    update: 0,\n    delete: 0,\n    \"relationship-add\": 0,\n    \"relationship-delete\": 0,\n    total: changes.length,\n  } as ChangesetSummary[\"totals\"];\n  const entries = changes.map((change, index) => {\n    totals[change.type] = (totals[change.type] ?? 0) + 1;\n    return summarizeChange(change, index);\n  });\n  entries.sort((x, y) => x.sequence - y.sequence);\n  return { totals, changes: entries };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/changeset-validator.js

@@ -2,6 +2,11 @@ import { VirtualProjectionEngine } from "./virtual-projection.js";
 import { StagedChangesetStorage } from "./staged-changeset-storage.js";
 import { Validator } from "../validators/validator.js";
 import { ValidationResult } from "../validators/types.js";
+import { Relationships, elementIdentifiers } from "./relationships.js";
+import { getErrorMessage } from "../utils/errors.js";
+function errorKey(issue) {
+  return `${issue.layer}\0${issue.elementId ?? ""}\0${issue.message}`;
+}
 class ChangesetValidator {
   projectionEngine;
   storage;
@@ -10,29 +15,70 @@ class ChangesetValidator {
     this.projectionEngine = new VirtualProjectionEngine(rootPath), this.storage = new StagedChangesetStorage(rootPath), this.validator = new Validator();
   }
   /**
-   * Validate a changeset by running the full 4-stage pipeline on its projected model.
-   *
-   * Only errors affecting elements touched by the changeset (add/update) block the
-   * commit. Pre-existing errors in unchanged elements are demoted to warnings so that
-   * incremental fixes can be committed without requiring the entire model to be valid
-   * first.
+   * Validate a changeset by running the full validation pipeline on its projected model.
    *
-   * @param baseModel - The base model to project
-   * @param changesetId - The changeset to validate
-   * @returns ValidationResult from all 4 stages
+   * See {@link validateChangesetReport}: only errors the changeset introduces are
+   * returned as errors; errors the base model already had are demoted to warnings.
    */
   async validateChangeset(baseModel, changesetId) {
-    const changeset = await this.storage.load(changesetId), changedElementIds = /* @__PURE__ */ new Set();
-    if (changeset)
-      for (const change of changeset.changes)
-        (change.type === "add" || change.type === "update") && changedElementIds.add(change.elementId);
-    const projectedModel = await this.projectionEngine.projectModel(baseModel, changesetId), fullResult = await this.validator.validateModel(projectedModel);
-    if (changedElementIds.size === 0)
-      return fullResult;
-    const filtered = new ValidationResult();
-    for (const error of fullResult.errors)
-      !error.elementId || changedElementIds.has(error.elementId) ? filtered.errors.push(error) : filtered.warnings.push({ ...error, severity: "warning" });
-    return filtered.warnings.push(...fullResult.warnings), filtered;
+    return (await this.validateChangesetReport(baseModel, changesetId)).result;
+  }
+  /**
+   * Judge the change, not the base: validate the committed base model and the
+   * projected model (base + staged changes), and block only on errors the
+   * projection has beyond the base's. An error is identified by its layer,
+   * element and message, and counted, so a changeset that adds another copy of
+   * an existing problem still blocks.
+   *
+   * A model with pre-existing errors (a relationship the catalog has since
+   * retired, say) can therefore take a change to the same element; those errors
+   * come back as warnings and in `preExistingErrors`.
+   */
+  async validateChangesetReport(baseModel, changesetId) {
+    const changeset = await this.storage.load(changesetId), projectedModel = await this.projectionEngine.projectModel(baseModel, changesetId), baseRelationships = baseModel.getBaseRelationships(), projectedRelationships = Relationships.fromArray([...baseRelationships]), deletedIdentifiers = /* @__PURE__ */ new Set();
+    for (const change of changeset?.changes ?? [])
+      if (change.type === "relationship-add" && change.after) {
+        const rel = change.after;
+        projectedRelationships.find(rel.source, rel.target, rel.predicate).length === 0 && projectedRelationships.add({ ...rel, category: rel.category ?? "structural" });
+      } else if (change.type === "relationship-delete" && change.before) {
+        const rel = change.before;
+        projectedRelationships.delete(rel.source, rel.target, rel.predicate);
+      } else if (change.type === "delete") {
+        const before = change.before ?? {};
+        for (const id of elementIdentifiers(before, change.elementId))
+          deletedIdentifiers.add(id);
+      }
+    projectedModel.relationships = deletedIdentifiers.size > 0 ? Relationships.fromArray(projectedRelationships.getAll().filter((rel) => !deletedIdentifiers.has(rel.source) && !deletedIdentifiers.has(rel.target))) : projectedRelationships;
+    const projectedResult = await this.validator.validateModel(projectedModel);
+    let baseErrors = [], baseValidationFailure;
+    try {
+      const baseLayers = /* @__PURE__ */ new Map();
+      for (const name of baseModel.getLayerNames()) {
+        const layer = await baseModel.getBaseLayer(name);
+        layer && baseLayers.set(name, layer);
+      }
+      const baseView = {
+        manifest: baseModel.manifest,
+        layers: baseLayers,
+        relationships: Relationships.fromArray([...baseRelationships]),
+        loadedLayerFilter: baseModel.loadedLayerFilter,
+        isProjection: !0
+      };
+      baseErrors = (await this.validator.validateModel(baseView)).errors;
+    } catch (error) {
+      baseValidationFailure = getErrorMessage(error);
+    }
+    const remaining = /* @__PURE__ */ new Map();
+    for (const issue of baseErrors) {
+      const key = errorKey(issue);
+      remaining.set(key, (remaining.get(key) ?? 0) + 1);
+    }
+    const result = new ValidationResult(), preExistingErrors = [];
+    for (const issue of projectedResult.errors) {
+      const key = errorKey(issue), count = remaining.get(key) ?? 0;
+      count > 0 ? (remaining.set(key, count - 1), preExistingErrors.push(issue), result.warnings.push({ ...issue, severity: "warning", message: `(pre-existing) ${issue.message}` })) : result.errors.push(issue);
+    }
+    return result.warnings.push(...projectedResult.warnings), { result, preExistingErrors, ...baseValidationFailure ? { baseValidationFailure } : {} };
   }
 }
 export {

package/dist/core/changeset-validator.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/core/changeset-validator.ts"],
-  "sourcesContent": ["/**\n * ChangesetValidator - Validates staged changes against projected model\n *\n * Runs the complete 4-stage validation pipeline against a merged view\n * of the base model with staged changes applied.\n */\n\nimport { VirtualProjectionEngine } from \"./virtual-projection.js\";\nimport { StagedChangesetStorage } from \"./staged-changeset-storage.js\";\nimport { Validator } from \"../validators/validator.js\";\nimport { ValidationResult } from \"../validators/types.js\";\nimport type { Model } from \"./model.js\";\n\n/**\n * Validates changesets by running validation pipeline on projected models\n */\nexport class ChangesetValidator {\n  private projectionEngine: VirtualProjectionEngine;\n  private storage: StagedChangesetStorage;\n  private validator: Validator;\n\n  constructor(rootPath: string) {\n    this.projectionEngine = new VirtualProjectionEngine(rootPath);\n    this.storage = new StagedChangesetStorage(rootPath);\n    this.validator = new Validator();\n  }\n\n  /**\n   * Validate a changeset by running the full 4-stage pipeline on its projected model.\n   *\n   * Only errors affecting elements touched by the changeset (add/update) block the\n   * commit. Pre-existing errors in unchanged elements are demoted to warnings so that\n   * incremental fixes can be committed without requiring the entire model to be valid\n   * first.\n   *\n   * @param baseModel - The base model to project\n   * @param changesetId - The changeset to validate\n   * @returns ValidationResult from all 4 stages\n   */\n  async validateChangeset(baseModel: Model, changesetId: string): Promise<ValidationResult> {\n    // Collect element IDs touched by this changeset (add/update only)\n    const changeset = await this.storage.load(changesetId);\n    const changedElementIds = new Set<string>();\n    if (changeset) {\n      for (const change of changeset.changes) {\n        if (change.type === \"add\" || change.type === \"update\") {\n          changedElementIds.add(change.elementId);\n        }\n      }\n    }\n\n    // Project the model with staged changes applied\n    const projectedModel = await this.projectionEngine.projectModel(baseModel, changesetId);\n\n    // Run unified validator on projected model\n    const fullResult = await this.validator.validateModel(projectedModel as unknown as Model);\n\n    if (changedElementIds.size === 0) {\n      return fullResult;\n    }\n\n    // Partition errors: block on errors for changed elements; demote pre-existing\n    // errors in unchanged elements to warnings so they don't block this commit.\n    const filtered = new ValidationResult();\n    for (const error of fullResult.errors) {\n      if (!error.elementId || changedElementIds.has(error.elementId)) {\n        filtered.errors.push(error);\n      } else {\n        filtered.warnings.push({ ...error, severity: \"warning\" });\n      }\n    }\n    filtered.warnings.push(...fullResult.warnings);\n\n    return filtered;\n  }\n}\n"],
-  "mappings": "AAOA,SAAS,+BAA+B;AACxC,SAAS,8BAA8B;AACvC,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB;AAM3B,MAAO,mBAAkB;EACrB;EACA;EACA;EAER,YAAY,UAAgB;AAC1B,SAAK,mBAAmB,IAAI,wBAAwB,QAAQ,GAC5D,KAAK,UAAU,IAAI,uBAAuB,QAAQ,GAClD,KAAK,YAAY,IAAI,UAAS;EAChC;;;;;;;;;;;;;EAcA,MAAM,kBAAkB,WAAkB,aAAmB;AAE3D,UAAM,YAAY,MAAM,KAAK,QAAQ,KAAK,WAAW,GAC/C,oBAAoB,oBAAI,IAAG;AACjC,QAAI;AACF,iBAAW,UAAU,UAAU;AAC7B,SAAI,OAAO,SAAS,SAAS,OAAO,SAAS,aAC3C,kBAAkB,IAAI,OAAO,SAAS;AAM5C,UAAM,iBAAiB,MAAM,KAAK,iBAAiB,aAAa,WAAW,WAAW,GAGhF,aAAa,MAAM,KAAK,UAAU,cAAc,cAAkC;AAExF,QAAI,kBAAkB,SAAS;AAC7B,aAAO;AAKT,UAAM,WAAW,IAAI,iBAAgB;AACrC,eAAW,SAAS,WAAW;AAC7B,MAAI,CAAC,MAAM,aAAa,kBAAkB,IAAI,MAAM,SAAS,IAC3D,SAAS,OAAO,KAAK,KAAK,IAE1B,SAAS,SAAS,KAAK,EAAE,GAAG,OAAO,UAAU,UAAS,CAAE;AAG5D,oBAAS,SAAS,KAAK,GAAG,WAAW,QAAQ,GAEtC;EACT;;",
+  "sourcesContent": ["/**\n * ChangesetValidator - Validates staged changes against projected model\n *\n * Runs the validation pipeline against a merged view of the base model with\n * staged changes applied, and against the base model itself, so a commit is\n * judged by the errors the changeset introduces rather than by the base's.\n */\n\nimport { VirtualProjectionEngine, type ProjectedModel } from \"./virtual-projection.js\";\nimport { StagedChangesetStorage } from \"./staged-changeset-storage.js\";\nimport { Validator } from \"../validators/validator.js\";\nimport { ValidationResult, type ValidationIssue } from \"../validators/types.js\";\nimport type { Model } from \"./model.js\";\nimport type { Layer } from \"./layer.js\";\nimport type { StagedChange } from \"./changeset.js\";\nimport { Relationships, elementIdentifiers, type Relationship } from \"./relationships.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\n\n/**\n * The outcome of judging a changeset: what it introduces, and what was already wrong.\n */\nexport interface ChangesetValidationReport {\n  /**\n   * Errors that block the commit: those the projected model has beyond the base\n   * model's. Pre-existing errors are carried as warnings.\n   */\n  result: ValidationResult;\n  /** Errors the base model already had that the projected model still has. */\n  preExistingErrors: ValidationIssue[];\n  /** Set when the base model could not be validated, so every projected error blocks. */\n  baseValidationFailure?: string;\n}\n\n/** Identity of an error, for comparing the base model's errors with the projection's. */\nfunction errorKey(issue: ValidationIssue): string {\n  return `${issue.layer}\\u0000${issue.elementId ?? \"\"}\\u0000${issue.message}`;\n}\n\n/**\n * Validates changesets by running validation pipeline on projected models\n */\nexport class ChangesetValidator {\n  private projectionEngine: VirtualProjectionEngine;\n  private storage: StagedChangesetStorage;\n  private validator: Validator;\n\n  constructor(rootPath: string) {\n    this.projectionEngine = new VirtualProjectionEngine(rootPath);\n    this.storage = new StagedChangesetStorage(rootPath);\n    this.validator = new Validator();\n  }\n\n  /**\n   * Validate a changeset by running the full validation pipeline on its projected model.\n   *\n   * See {@link validateChangesetReport}: only errors the changeset introduces are\n   * returned as errors; errors the base model already had are demoted to warnings.\n   */\n  async validateChangeset(baseModel: Model, changesetId: string): Promise<ValidationResult> {\n    return (await this.validateChangesetReport(baseModel, changesetId)).result;\n  }\n\n  /**\n   * Judge the change, not the base: validate the committed base model and the\n   * projected model (base + staged changes), and block only on errors the\n   * projection has beyond the base's. An error is identified by its layer,\n   * element and message, and counted, so a changeset that adds another copy of\n   * an existing problem still blocks.\n   *\n   * A model with pre-existing errors (a relationship the catalog has since\n   * retired, say) can therefore take a change to the same element; those errors\n   * come back as warnings and in `preExistingErrors`.\n   */\n  async validateChangesetReport(baseModel: Model, changesetId: string): Promise<ChangesetValidationReport> {\n    const changeset = await this.storage.load(changesetId);\n\n    // Project the model with staged changes applied\n    const projectedModel = await this.projectionEngine.projectModel(baseModel, changesetId);\n\n    // Relationships as committed, without the active changeset's staged changes that\n    // Model.load() merges in, so the result does not depend on which changeset is active.\n    const baseRelationships = baseModel.getBaseRelationships();\n\n    // Relationships as the changeset leaves them. Those naming an element this changeset\n    // deletes are removed at commit (by UUID or by path), so they are left out here too.\n    const projectedRelationships = Relationships.fromArray([...baseRelationships]);\n    const deletedIdentifiers = new Set<string>();\n    for (const change of (changeset?.changes ?? []) as StagedChange[]) {\n      if (change.type === \"relationship-add\" && change.after) {\n        const rel = change.after as unknown as Relationship;\n        if (projectedRelationships.find(rel.source, rel.target, rel.predicate).length === 0) {\n          projectedRelationships.add({ ...rel, category: rel.category ?? \"structural\" });\n        }\n      } else if (change.type === \"relationship-delete\" && change.before) {\n        const rel = change.before as { source: string; target: string; predicate?: string };\n        projectedRelationships.delete(rel.source, rel.target, rel.predicate);\n      } else if (change.type === \"delete\") {\n        const before = (change.before ?? {}) as { id?: unknown; path?: unknown };\n        for (const id of elementIdentifiers(before, change.elementId)) {\n          deletedIdentifiers.add(id);\n        }\n      }\n    }\n    projectedModel.relationships =\n      deletedIdentifiers.size > 0\n        ? Relationships.fromArray(\n            projectedRelationships\n              .getAll()\n              .filter((rel) => !deletedIdentifiers.has(rel.source) && !deletedIdentifiers.has(rel.target))\n          )\n        : projectedRelationships;\n\n    const projectedResult = await this.validator.validateModel(projectedModel as unknown as Model);\n\n    // The base model, validated the same way.\n    let baseErrors: ValidationIssue[] = [];\n    let baseValidationFailure: string | undefined;\n    try {\n      const baseLayers = new Map<string, Layer>();\n      for (const name of baseModel.getLayerNames()) {\n        const layer = await baseModel.getBaseLayer(name);\n        if (layer) baseLayers.set(name, layer);\n      }\n      const baseView: ProjectedModel = {\n        manifest: baseModel.manifest,\n        layers: baseLayers,\n        relationships: Relationships.fromArray([...baseRelationships]),\n        loadedLayerFilter: baseModel.loadedLayerFilter,\n        isProjection: true,\n      };\n      baseErrors = (await this.validator.validateModel(baseView as unknown as Model)).errors;\n    } catch (error) {\n      // Without a base to compare against, every projected error blocks (the strict\n      // behaviour), and the report says why.\n      baseValidationFailure = getErrorMessage(error);\n    }\n\n    const remaining = new Map<string, number>();\n    for (const issue of baseErrors) {\n      const key = errorKey(issue);\n      remaining.set(key, (remaining.get(key) ?? 0) + 1);\n    }\n\n    const result = new ValidationResult();\n    const preExistingErrors: ValidationIssue[] = [];\n    for (const issue of projectedResult.errors) {\n      const key = errorKey(issue);\n      const count = remaining.get(key) ?? 0;\n      if (count > 0) {\n        remaining.set(key, count - 1);\n        preExistingErrors.push(issue);\n        result.warnings.push({ ...issue, severity: \"warning\", message: `(pre-existing) ${issue.message}` });\n      } else {\n        result.errors.push(issue);\n      }\n    }\n    result.warnings.push(...projectedResult.warnings);\n\n    return { result, preExistingErrors, ...(baseValidationFailure ? { baseValidationFailure } : {}) };\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }