@documentation-robotics/cli 0.1.13 → 0.3.0

package/dist/core/changeset-base-index.js

@@ -0,0 +1,153 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileExists } from "../utils/file-io.js";
+import { getErrorMessage } from "../utils/errors.js";
+import { Changeset } from "./changeset.js";
+import { ChangesetGraph, relationshipKey } from "./changeset-graph.js";
+const BASE_INDEX_FILE = "base-index.json", DRIFT_LIST_LIMIT = 50;
+function indexPath(rootPath, changesetId) {
+  return path.join(rootPath, "documentation-robotics", "changesets", changesetId, BASE_INDEX_FILE);
+}
+function contentHash(element) {
+  const content = {
+    type: element.type,
+    name: element.name,
+    description: element.description ?? null,
+    attributes: element.attributes ?? {},
+    sourceReference: element.sourceReference ?? null
+  };
+  return createHash("sha256").update(stableStringify(content)).digest("hex").slice(0, 16);
+}
+async function baseGraph(model) {
+  const now = (/* @__PURE__ */ new Date()).toISOString(), empty = new Changeset({
+    id: "base",
+    name: "base model",
+    created: now,
+    modified: now,
+    status: "committed",
+    baseSnapshot: "",
+    changes: []
+  });
+  return ChangesetGraph.build(model, empty);
+}
+function indexFromGraph(graph) {
+  const elements = {};
+  for (const element of graph.elements.values())
+    element.status !== "deleted" && (elements[element.id] = contentHash(element));
+  return {
+    version: 1,
+    captured: (/* @__PURE__ */ new Date()).toISOString(),
+    elements,
+    relationships: graph.relationships().filter((r) => r.status !== "deleted").map((r) => relationshipKey(r)).sort()
+  };
+}
+async function captureBaseIndex(model) {
+  return indexFromGraph(await baseGraph(model));
+}
+async function writeBaseIndex(rootPath, changesetId, index) {
+  await writeFile(indexPath(rootPath, changesetId), JSON.stringify(index), "utf-8");
+}
+async function readBaseIndex(rootPath, changesetId) {
+  const file = indexPath(rootPath, changesetId);
+  if (!await fileExists(file))
+    return;
+  const parsed = JSON.parse(await readFile(file, "utf-8"));
+  if (parsed.version !== 1 || typeof parsed.elements != "object" || !Array.isArray(parsed.relationships))
+    throw new Error(`${file} is not a base index this version of dr can read`);
+  return parsed;
+}
+async function tryReadBaseIndex(rootPath, changesetId) {
+  try {
+    const index = await readBaseIndex(rootPath, changesetId);
+    return index ? { index, status: "recorded" } : { status: "not-recorded" };
+  } catch (error) {
+    return {
+      status: "unreadable",
+      warning: `The changeset's base index could not be read (${getErrorMessage(error)}); treating it as not recorded.`
+    };
+  }
+}
+function parseKey(key) {
+  const [source, predicate, target] = key.split("::");
+  return { source, predicate, target };
+}
+async function describeDrift(model, graph, hash) {
+  const changeset = graph.changeset, warnings = [...hash?.warnings ?? []], overlapping = { elements: [], relationships: [] }, inBase = graph.alreadyInBase();
+  for (const element of inBase.elements)
+    overlapping.elements.push({ id: element.id, reason: "already-in-base" });
+  for (const rel of inBase.relationships)
+    overlapping.relationships.push({ source: rel.source, predicate: rel.predicate, target: rel.target, reason: "already-in-base" });
+  const net = /* @__PURE__ */ new Map(), elementOps = /* @__PURE__ */ new Map(), addedHere = /* @__PURE__ */ new Set();
+  for (const change of changeset.changes)
+    if (change.type === "relationship-add" || change.type === "relationship-delete") {
+      const data = change.type === "relationship-delete" ? change.before ?? change.after : change.after, [source, predicate, target] = data?.source && data.predicate && data.target ? [data.source, data.predicate, data.target] : change.elementId.split("::");
+      if (!source || !predicate || !target)
+        continue;
+      const key = relationshipKey({ source: graph.resolve(source), predicate, target: graph.resolve(target) });
+      change.type === "relationship-add" && !net.has(key) && addedHere.add(key), net.set(key, change.type === "relationship-add" ? "add" : "delete");
+    } else {
+      const id = graph.resolve(change.elementId);
+      change.type === "add" && !elementOps.has(id) && addedHere.add(id), elementOps.set(id, change.type);
+    }
+  for (const [key, op] of net) {
+    if (op !== "delete" || addedHere.has(key))
+      continue;
+    const ref = parseKey(key);
+    graph.getRelationship(ref.source, ref.predicate, ref.target) || overlapping.relationships.push({ ...ref, reason: "already-removed" });
+  }
+  for (const [id, op] of elementOps)
+    op === "delete" && !addedHere.has(id) && !graph.getElement(id) && overlapping.elements.push({ id, reason: "already-removed" });
+  const read = await tryReadBaseIndex(model.rootPath, changeset.id);
+  read.warning && warnings.push(read.warning);
+  let baseChanges;
+  if (read.index) {
+    const then = read.index, now = indexFromGraph(await baseGraph(model)), elementsAdded = Object.keys(now.elements).filter((id) => !(id in then.elements)).sort(), elementsRemoved = Object.keys(then.elements).filter((id) => !(id in now.elements)).sort(), elementsChanged = Object.keys(now.elements).filter((id) => id in then.elements && then.elements[id] !== now.elements[id]).sort(), thenRels = new Set(then.relationships), nowRels = new Set(now.relationships), relationshipsAdded = now.relationships.filter((k) => !thenRels.has(k)), relationshipsRemoved = then.relationships.filter((k) => !nowRels.has(k));
+    for (const id of elementsChanged) {
+      const op = elementOps.get(id);
+      (op === "update" || op === "delete") && overlapping.elements.push({ id, reason: "changed-in-base" });
+    }
+    const cut = (list) => list.slice(0, DRIFT_LIST_LIMIT);
+    baseChanges = {
+      counts: {
+        elementsAdded: elementsAdded.length,
+        elementsRemoved: elementsRemoved.length,
+        elementsChanged: elementsChanged.length,
+        relationshipsAdded: relationshipsAdded.length,
+        relationshipsRemoved: relationshipsRemoved.length
+      },
+      elementsAdded: cut(elementsAdded),
+      elementsRemoved: cut(elementsRemoved),
+      elementsChanged: cut(elementsChanged),
+      relationshipsAdded: cut(relationshipsAdded).map(parseKey),
+      relationshipsRemoved: cut(relationshipsRemoved).map(parseKey),
+      truncated: [elementsAdded, elementsRemoved, elementsChanged, relationshipsAdded, relationshipsRemoved].some((l) => l.length > DRIFT_LIST_LIMIT)
+    };
+  } else read.status === "not-recorded" && (hash?.isDrifted || overlapping.elements.length + overlapping.relationships.length > 0) && warnings.push("No base index was recorded for this changeset (it predates them), so what changed in the base cannot be listed beyond the staged changes it overlaps.");
+  const baseChanged = !!baseChanges && Object.values(baseChanges.counts).some((n) => n > 0), overlapCount = overlapping.elements.length + overlapping.relationships.length, isDrifted = (hash?.isDrifted ?? !1) || baseChanged || overlapCount > 0;
+  return overlapCount > 0 && warnings.push(`The base now overlaps ${overlapCount} staged change(s): ` + [
+    ...overlapping.elements.map((e) => `${e.id} (${e.reason})`),
+    ...overlapping.relationships.map((r) => `${r.source} --${r.predicate}--> ${r.target} (${r.reason})`)
+  ].slice(0, 10).join(", ") + (overlapCount > 10 ? ", ..." : "")), {
+    isDrifted,
+    warnings,
+    ...hash?.baseSnapshotId ? { baseSnapshotId: hash.baseSnapshotId } : {},
+    ...hash?.currentSnapshotId ? { currentSnapshotId: hash.currentSnapshotId } : {},
+    baseIndex: read.status,
+    overlapping,
+    ...baseChanges ? { baseChanges } : {}
+  };
+}
+function stableStringify(value) {
+  return value === void 0 ? "null" : value === null || typeof value != "object" ? JSON.stringify(value) : Array.isArray(value) ? `[${value.map(stableStringify).join(",")}]` : `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+}
+export {
+  BASE_INDEX_FILE,
+  DRIFT_LIST_LIMIT,
+  captureBaseIndex,
+  describeDrift,
+  readBaseIndex,
+  tryReadBaseIndex,
+  writeBaseIndex
+};
+//# sourceMappingURL=changeset-base-index.js.map

package/dist/core/changeset-base-index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/changeset-base-index.ts"],
+  "sourcesContent": ["/**\n * Changeset base index \u2014 which elements and relationships the base model had when a changeset was\n * created, so later readers can tell what predates the plan and what changed in the base under it.\n *\n * The changeset's `baseSnapshot` is a single hash of the whole model: it says the base changed, not\n * what changed. The index records each base element's id with a short content hash, and each base\n * relationship's key, in `documentation-robotics/changesets/{id}/base-index.json`. It is written\n * when the changeset is created. Changesets created before it existed (or imported) have none, and\n * every reader falls back to what it can tell without one and says so.\n *\n * Readers:\n * - `changeset_verify` excludes elements that existed before the plan from the candidates for a\n *   planned add (they cannot be its built form).\n * - `changeset_brief` names what changed in the base since the plan was created (`describeDrift`).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { fileExists } from \"../utils/file-io.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\nimport { Changeset } from \"./changeset.js\";\nimport { ChangesetGraph, relationshipKey, type GraphElement } from \"./changeset-graph.js\";\nimport type { Model } from \"./model.js\";\n\nexport const BASE_INDEX_FILE = \"base-index.json\";\n\nexport interface BaseIndex {\n  version: 1;\n  captured: string;\n  /** Element id (dotted path) \u2192 short hash of its content. */\n  elements: Record<string, string>;\n  /** Relationship keys, `source::predicate::target`, endpoints as dotted paths. */\n  relationships: string[];\n}\n\nexport interface RelationshipRef {\n  source: string;\n  predicate: string;\n  target: string;\n}\n\n/** How many ids each drift list carries before it is cut short (the counts stay exact). */\nexport const DRIFT_LIST_LIMIT = 50;\n\nexport interface ChangesetDrift {\n  /** Kept for compatibility: true when the base changed since the changeset was created. */\n  isDrifted: boolean;\n  warnings: string[];\n  baseSnapshotId?: string;\n  currentSnapshotId?: string;\n  /** Whether a base index was recorded for the changeset; without one, `baseChanges` is absent. */\n  baseIndex: \"recorded\" | \"not-recorded\" | \"unreadable\";\n  /**\n   * Staged changes that the base now overlaps: adds whose element or relationship the base already\n   * has, deletes of what the base no longer has, and (with a base index) elements the plan updates\n   * or deletes whose base content changed since the plan was created.\n   */\n  overlapping: {\n    elements: Array<{ id: string; reason: \"already-in-base\" | \"already-removed\" | \"changed-in-base\" }>;\n    relationships: Array<RelationshipRef & { reason: \"already-in-base\" | \"already-removed\" }>;\n  };\n  /** What changed in the base since the changeset was created; needs a base index. */\n  baseChanges?: {\n    counts: {\n      elementsAdded: number;\n      elementsRemoved: number;\n      elementsChanged: number;\n      relationshipsAdded: number;\n      relationshipsRemoved: number;\n    };\n    elementsAdded: string[];\n    elementsRemoved: string[];\n    elementsChanged: string[];\n    relationshipsAdded: RelationshipRef[];\n    relationshipsRemoved: RelationshipRef[];\n    /** True when a list was cut at DRIFT_LIST_LIMIT entries. */\n    truncated: boolean;\n  };\n}\n\nfunction indexPath(rootPath: string, changesetId: string): string {\n  return path.join(rootPath, \"documentation-robotics\", \"changesets\", changesetId, BASE_INDEX_FILE);\n}\n\nfunction contentHash(element: GraphElement): string {\n  const content = {\n    type: element.type,\n    name: element.name,\n    description: element.description ?? null,\n    attributes: element.attributes ?? {},\n    sourceReference: element.sourceReference ?? null,\n  };\n  return createHash(\"sha256\").update(stableStringify(content)).digest(\"hex\").slice(0, 16);\n}\n\n/** The base model (never an active changeset's projection) as a graph with no changes. */\nasync function baseGraph(model: Model): Promise<ChangesetGraph> {\n  const now = new Date().toISOString();\n  const empty = new Changeset({\n    id: \"base\",\n    name: \"base model\",\n    created: now,\n    modified: now,\n    status: \"committed\",\n    baseSnapshot: \"\",\n    changes: [],\n  });\n  return ChangesetGraph.build(model, empty);\n}\n\nfunction indexFromGraph(graph: ChangesetGraph): BaseIndex {\n  const elements: Record<string, string> = {};\n  for (const element of graph.elements.values()) {\n    if (element.status !== \"deleted\") elements[element.id] = contentHash(element);\n  }\n  return {\n    version: 1,\n    captured: new Date().toISOString(),\n    elements,\n    relationships: graph\n      .relationships()\n      .filter((r) => r.status !== \"deleted\")\n      .map((r) => relationshipKey(r))\n      .sort(),\n  };\n}\n\n/** Indexes the base model as it is now. */\nexport async function captureBaseIndex(model: Model): Promise<BaseIndex> {\n  return indexFromGraph(await baseGraph(model));\n}\n\n/** Records the base index for a changeset that was just created. */\nexport async function writeBaseIndex(rootPath: string, changesetId: string, index: BaseIndex): Promise<void> {\n  await writeFile(indexPath(rootPath, changesetId), JSON.stringify(index), \"utf-8\");\n}\n\n/**\n * Reads a changeset's base index. `undefined` when none was recorded; throws when the file exists\n * but cannot be read, so callers can report it rather than mistake it for \"not recorded\".\n */\nexport async function readBaseIndex(rootPath: string, changesetId: string): Promise<BaseIndex | undefined> {\n  const file = indexPath(rootPath, changesetId);\n  if (!(await fileExists(file))) return undefined;\n  const parsed = JSON.parse(await readFile(file, \"utf-8\")) as Partial<BaseIndex>;\n  if (parsed.version !== 1 || typeof parsed.elements !== \"object\" || !Array.isArray(parsed.relationships)) {\n    throw new Error(`${file} is not a base index this version of dr can read`);\n  }\n  return parsed as BaseIndex;\n}\n\n/** Like `readBaseIndex`, but reports an unreadable index as a warning instead of throwing. */\nexport async function tryReadBaseIndex(\n  rootPath: string,\n  changesetId: string\n): Promise<{ index?: BaseIndex; status: ChangesetDrift[\"baseIndex\"]; warning?: string }> {\n  try {\n    const index = await readBaseIndex(rootPath, changesetId);\n    return index ? { index, status: \"recorded\" } : { status: \"not-recorded\" };\n  } catch (error) {\n    return {\n      status: \"unreadable\",\n      warning: `The changeset's base index could not be read (${getErrorMessage(error)}); treating it as not recorded.`,\n    };\n  }\n}\n\nfunction parseKey(key: string): RelationshipRef {\n  const [source, predicate, target] = key.split(\"::\");\n  return { source, predicate, target };\n}\n\n/**\n * Names how the base model changed under a changeset: staged changes the base now overlaps and,\n * with a base index, what was added, removed or changed in the base since the changeset was created.\n *\n * `graph` is the changeset's projected graph; `hash` is the hash-based drift check\n * (`StagingAreaManager.detectDrift`), when it ran.\n */\nexport async function describeDrift(\n  model: Model,\n  graph: ChangesetGraph,\n  hash?: { isDrifted: boolean; warnings: string[]; baseSnapshotId?: string; currentSnapshotId?: string }\n): Promise<ChangesetDrift> {\n  const changeset = graph.changeset;\n  const warnings = [...(hash?.warnings ?? [])];\n  const overlapping: ChangesetDrift[\"overlapping\"] = { elements: [], relationships: [] };\n\n  const inBase = graph.alreadyInBase();\n  for (const element of inBase.elements) overlapping.elements.push({ id: element.id, reason: \"already-in-base\" });\n  for (const rel of inBase.relationships) {\n    overlapping.relationships.push({ source: rel.source, predicate: rel.predicate, target: rel.target, reason: \"already-in-base\" });\n  }\n\n  // Staged deletes of what the base no longer has.\n  const net = new Map<string, \"add\" | \"delete\">();\n  const elementOps = new Map<string, string>();\n  const addedHere = new Set<string>();\n  for (const change of changeset.changes) {\n    if (change.type === \"relationship-add\" || change.type === \"relationship-delete\") {\n      const data = (change.type === \"relationship-delete\" ? (change.before ?? change.after) : change.after) as\n        | Partial<RelationshipRef>\n        | undefined;\n      const [source, predicate, target] =\n        data?.source && data.predicate && data.target\n          ? [data.source, data.predicate, data.target]\n          : change.elementId.split(\"::\");\n      if (!source || !predicate || !target) continue;\n      const key = relationshipKey({ source: graph.resolve(source), predicate, target: graph.resolve(target) });\n      if (change.type === \"relationship-add\" && !net.has(key)) addedHere.add(key);\n      net.set(key, change.type === \"relationship-add\" ? \"add\" : \"delete\");\n    } else {\n      const id = graph.resolve(change.elementId);\n      if (change.type === \"add\" && !elementOps.has(id)) addedHere.add(id);\n      elementOps.set(id, change.type);\n    }\n  }\n  for (const [key, op] of net) {\n    if (op !== \"delete\" || addedHere.has(key)) continue;\n    const ref = parseKey(key);\n    if (!graph.getRelationship(ref.source, ref.predicate, ref.target)) {\n      overlapping.relationships.push({ ...ref, reason: \"already-removed\" });\n    }\n  }\n  for (const [id, op] of elementOps) {\n    if (op === \"delete\" && !addedHere.has(id) && !graph.getElement(id)) overlapping.elements.push({ id, reason: \"already-removed\" });\n  }\n\n  const read = await tryReadBaseIndex(model.rootPath, changeset.id);\n  if (read.warning) warnings.push(read.warning);\n\n  let baseChanges: ChangesetDrift[\"baseChanges\"];\n  if (read.index) {\n    const then = read.index;\n    const now = indexFromGraph(await baseGraph(model));\n    const elementsAdded = Object.keys(now.elements).filter((id) => !(id in then.elements)).sort();\n    const elementsRemoved = Object.keys(then.elements).filter((id) => !(id in now.elements)).sort();\n    const elementsChanged = Object.keys(now.elements)\n      .filter((id) => id in then.elements && then.elements[id] !== now.elements[id])\n      .sort();\n    const thenRels = new Set(then.relationships);\n    const nowRels = new Set(now.relationships);\n    const relationshipsAdded = now.relationships.filter((k) => !thenRels.has(k));\n    const relationshipsRemoved = then.relationships.filter((k) => !nowRels.has(k));\n\n    for (const id of elementsChanged) {\n      const op = elementOps.get(id);\n      if (op === \"update\" || op === \"delete\") overlapping.elements.push({ id, reason: \"changed-in-base\" });\n    }\n\n    const cut = <T>(list: T[]): T[] => list.slice(0, DRIFT_LIST_LIMIT);\n    baseChanges = {\n      counts: {\n        elementsAdded: elementsAdded.length,\n        elementsRemoved: elementsRemoved.length,\n        elementsChanged: elementsChanged.length,\n        relationshipsAdded: relationshipsAdded.length,\n        relationshipsRemoved: relationshipsRemoved.length,\n      },\n      elementsAdded: cut(elementsAdded),\n      elementsRemoved: cut(elementsRemoved),\n      elementsChanged: cut(elementsChanged),\n      relationshipsAdded: cut(relationshipsAdded).map(parseKey),\n      relationshipsRemoved: cut(relationshipsRemoved).map(parseKey),\n      truncated: [elementsAdded, elementsRemoved, elementsChanged, relationshipsAdded, relationshipsRemoved].some(\n        (l) => l.length > DRIFT_LIST_LIMIT\n      ),\n    };\n  } else if (read.status === \"not-recorded\" && (hash?.isDrifted || overlapping.elements.length + overlapping.relationships.length > 0)) {\n    warnings.push(\n      \"No base index was recorded for this changeset (it predates them), so what changed in the base cannot be \" +\n        \"listed beyond the staged changes it overlaps.\"\n    );\n  }\n\n  const baseChanged =\n    !!baseChanges &&\n    Object.values(baseChanges.counts).some((n) => n > 0);\n  const overlapCount = overlapping.elements.length + overlapping.relationships.length;\n  const isDrifted = (hash?.isDrifted ?? false) || baseChanged || overlapCount > 0;\n  if (overlapCount > 0) {\n    warnings.push(\n      `The base now overlaps ${overlapCount} staged change(s): ` +\n        [\n          ...overlapping.elements.map((e) => `${e.id} (${e.reason})`),\n          ...overlapping.relationships.map((r) => `${r.source} --${r.predicate}--> ${r.target} (${r.reason})`),\n        ]\n          .slice(0, 10)\n          .join(\", \") +\n        (overlapCount > 10 ? \", ...\" : \"\")\n    );\n  }\n\n  return {\n    isDrifted,\n    warnings,\n    ...(hash?.baseSnapshotId ? { baseSnapshotId: hash.baseSnapshotId } : {}),\n    ...(hash?.currentSnapshotId ? { currentSnapshotId: hash.currentSnapshotId } : {}),\n    baseIndex: read.status,\n    overlapping,\n    ...(baseChanges ? { baseChanges } : {}),\n  };\n}\n\nfunction stableStringify(value: unknown): string {\n  if (value === undefined) return \"null\";\n  if (value === null || typeof value !== \"object\") return JSON.stringify(value);\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(\",\")}]`;\n  const entries = Object.keys(value as Record<string, unknown>)\n    .sort()\n    .map((k) => `${JSON.stringify(k)}:${stableStringify((value as Record<string, unknown>)[k])}`);\n  return `{${entries.join(\",\")}}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/changeset-brief-delta.js

@@ -0,0 +1,102 @@
+import { buildBrief, computeUnwired, unwiredKey } from "./changeset-analysis.js";
+import { ChangesetGraph, changesetRevisionToken, parseRevisionToken, relationshipKey, unstagedSince } from "./changeset-graph.js";
+import { summarizeChange } from "./changeset-summary.js";
+const NOTE = "The earlier state is rebuilt from the changes that made up the plan at `since` (unstaged ones from the changeset's unstage record), applied to today's base model; base drift since then is not separated out. It is approximate when a change staged by then was rewritten in place afterwards: pass the brief's revisionToken as `since` to be warned when that happened.";
+async function briefDelta(model, now, since) {
+  let revision;
+  const warnings = [], changeset = now.graph.changeset;
+  if (typeof since == "string") {
+    const parsed = parseRevisionToken(since);
+    if (!parsed)
+      throw new Error(`since "${since}" is neither a revision number nor a revision token (<revision>:<hash>) from a brief`);
+    revision = parsed.revision;
+    const today = changesetRevisionToken(changeset, revision);
+    revision <= now.brief.revision && today !== since && warnings.push(`The plan at revision ${revision} is not the one that revision token was taken from: a change up to it was rewritten in place since then (or the changeset was rewritten, e.g. by an upgrade). The earlier state below is rebuilt from what is recorded now, so this delta is approximate.`);
+  } else
+    revision = since;
+  const prunedThrough = changeset.unstagedPrunedThrough;
+  prunedThrough !== void 0 && revision < prunedThrough && warnings.push(`Unstage tombstones up to revision ${prunedThrough} were dropped to keep the record bounded, so changes unstaged between revision ${revision} and then may be missing from the rebuilt earlier state and from \`unstaged\`; this delta is approximate.`);
+  const earlier = await ChangesetGraph.build(model, changeset, { throughSequence: revision }), then = {
+    brief: buildBrief({ graph: earlier, unwired: "none" }),
+    unwired: computeUnwired(earlier),
+    graph: earlier
+  }, delta = diffBriefs(then, { brief: now.brief, unwired: computeUnwired(now.graph), graph: now.graph }, revision, warnings);
+  return delta.unstaged = unstagedSince(changeset, revision).map((t, index) => ({
+    ...summarizeChange({ ...t.change, sequenceNumber: t.sequence }, index),
+    removedAt: t.removedAt
+  })), delta;
+}
+function diffBriefs(then, now, since, extraWarnings = []) {
+  const revision = now.brief.revision, warnings = [...extraWarnings];
+  since > revision && warnings.push(`since (${since}) is past the current revision (${revision}), so it is not a revision of this plan; the delta compares the changeset with itself.`);
+  const changedIds = (brief) => brief.layers.flatMap((l) => l.changes.map((c) => c.id)), thenIds = new Set(changedIds(then.brief)), nowIds = new Set(changedIds(now.brief)), gapKey = (g) => `${g.kind}|${g.element}|${g.kind === "peer-pattern" ? g.detail.replace(/^\d+ of \d+ /, "") : g.detail}`, thenGaps = new Map(then.brief.gaps.map((g) => [gapKey(g), g])), nowGaps = new Map(now.brief.gaps.map((g) => [gapKey(g), g])), flatten = (list) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const { element, byLayer } of list)
+      for (const { layer, entries } of byLayer)
+        for (const entry of entries)
+          map.set(unwiredKey(element, entry), { element, layer, ...entry });
+    return map;
+  }, thenUnwired = flatten(then.unwired), nowUnwired = flatten(now.unwired), thenScoped = new Set(then.unwired.map((u) => u.element)), nowScoped = new Set(now.unwired.map((u) => u.element)), traced = (brief) => new Set(brief.intent.traced.map((t) => t.element)), untraced = (brief) => new Set(brief.intent.untraced), thenTraced = traced(then.brief), thenUntraced = untraced(then.brief), thenReach = new Set(then.brief.reach.touched), nowReach = new Set(now.brief.reach.touched);
+  return {
+    since,
+    revision,
+    elements: {
+      added: [...nowIds].filter((id) => !thenIds.has(id)),
+      removed: [...thenIds].filter((id) => !nowIds.has(id)),
+      updated: then.graph && now.graph ? elementUpdates(then.graph, now.graph) : []
+    },
+    relationships: then.graph && now.graph ? relationshipChanges(then.graph, now.graph) : { added: [], removed: [] },
+    unstaged: [],
+    gaps: {
+      opened: [...nowGaps].filter(([k]) => !thenGaps.has(k)).map(([, g]) => g),
+      closed: [...thenGaps].filter(([k]) => !nowGaps.has(k)).map(([, g]) => g)
+    },
+    unwired: {
+      wired: [...thenUnwired].filter(([k, e]) => !nowUnwired.has(k) && nowScoped.has(e.element)).map(([, e]) => e),
+      new: [...nowUnwired].filter(([k, e]) => !thenUnwired.has(k) && thenScoped.has(e.element)).map(([, e]) => e),
+      newElements: now.unwired.filter((u) => !thenScoped.has(u.element)).map((u) => ({ element: u.element, count: u.byLayer.reduce((sum, l) => sum + l.entries.length, 0) }))
+    },
+    reach: {
+      newlyReached: now.brief.reach.touched.filter((l) => !thenReach.has(l)),
+      noLongerReached: then.brief.reach.touched.filter((l) => !nowReach.has(l))
+    },
+    intent: {
+      newlyTraced: now.brief.intent.traced.map((t) => t.element).filter((id) => !thenTraced.has(id)),
+      newlyUntraced: now.brief.intent.untraced.filter((id) => !thenUntraced.has(id))
+    },
+    note: NOTE,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function elementUpdates(then, now) {
+  const updates = [];
+  for (const after of now.elements.values()) {
+    if (after.status === "deleted")
+      continue;
+    const before = then.getElement(after.id);
+    if (!before || before.status === "deleted" || before.status === "unchanged" && after.status === "unchanged")
+      continue;
+    const fields = changedFields(before, after);
+    fields.length > 0 && updates.push({ element: after.id, fields });
+  }
+  return updates;
+}
+function changedFields(before, after) {
+  const fields = [], same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+  same(before.name, after.name) || fields.push("name"), same(before.description, after.description) || fields.push("description");
+  for (const key of [.../* @__PURE__ */ new Set([...Object.keys(before.attributes), ...Object.keys(after.attributes)])].sort())
+    same(before.attributes[key], after.attributes[key]) || fields.push(`attributes.${key}`);
+  return same(before.sourceReference, after.sourceReference) || fields.push("sourceReference"), fields;
+}
+function relationshipChanges(then, now) {
+  const live = (graph) => new Map(graph.relationships().filter((r) => r.status !== "deleted").map((r) => [relationshipKey(r), { source: r.source, predicate: r.predicate, target: r.target }])), before = live(then), after = live(now);
+  return {
+    added: [...after].filter(([k]) => !before.has(k)).map(([, r]) => r),
+    removed: [...before].filter(([k]) => !after.has(k)).map(([, r]) => r)
+  };
+}
+export {
+  briefDelta,
+  diffBriefs
+};
+//# sourceMappingURL=changeset-brief-delta.js.map

package/dist/core/changeset-brief-delta.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/changeset-brief-delta.ts"],
+  "sourcesContent": ["/**\n * Brief deltas \u2014 what changed in a changeset's brief since an earlier revision.\n *\n * The earlier brief is rebuilt from the changes that made up the plan at that revision (a\n * `ChangesetGraph` over them, against today's base) and compared with the brief now. Sequence\n * numbers are never reused and every unstage leaves a tombstone, so the plan at a revision can be\n * rebuilt after later unstages too. See \"Iterating on a plan\" in docs/CHANGE_MODELING.md.\n */\n\nimport {\n  buildBrief,\n  computeUnwired,\n  unwiredKey,\n  type BriefGap,\n  type ChangesetBrief,\n  type ElementUnwired,\n  type UnwiredEntry,\n} from \"./changeset-analysis.js\";\nimport {\n  ChangesetGraph,\n  changesetRevisionToken,\n  parseRevisionToken,\n  relationshipKey,\n  unstagedSince,\n  type GraphElement,\n} from \"./changeset-graph.js\";\nimport { summarizeChange, type ChangeSummaryEntry } from \"./changeset-summary.js\";\nimport type { StagedChange } from \"./changeset.js\";\nimport type { Model } from \"./model.js\";\n\nexport type UnwiredDeltaEntry = { element: string; layer: string } & UnwiredEntry;\n\nexport type RelationshipTriple = { source: string; predicate: string; target: string };\n\nexport interface BriefDelta {\n  /** The revision compared against, as asked (the number, when a revision token was passed). */\n  since: number;\n  /** The revision now. */\n  revision: number;\n  /**\n   * Elements that entered or left the change, and elements whose content (name, description,\n   * attributes, source reference) changed since, with the fields that did.\n   */\n  elements: { added: string[]; removed: string[]; updated: Array<{ element: string; fields: string[] }> };\n  /** Relationships live now and not then (added), or then and not now (removed), new elements' included. */\n  relationships: { added: RelationshipTriple[]; removed: RelationshipTriple[] };\n  /** Changes staged at `since` and unstaged after it, with the revision each unstage made. */\n  unstaged: Array<ChangeSummaryEntry & { removedAt: number }>;\n  gaps: { opened: BriefGap[]; closed: BriefGap[] };\n  unwired: {\n    /** Unwired then, wired now (the element is still in the change). */\n    wired: UnwiredDeltaEntry[];\n    /** Unwired now, not then, on elements that were already in the change. */\n    new: UnwiredDeltaEntry[];\n    /** Elements new to the change, with how many unwired connections they bring (listed under `unwired`). */\n    newElements: Array<{ element: string; count: number }>;\n  };\n  reach: { newlyReached: string[]; noLongerReached: string[] };\n  intent: { newlyTraced: string[]; newlyUntraced: string[] };\n  /** How the earlier state was rebuilt, and when it is approximate. */\n  note: string;\n  warnings?: string[];\n}\n\nexport interface BriefSide {\n  brief: ChangesetBrief;\n  unwired: ElementUnwired[];\n  /** The projection the brief was built from; needed for element updates and relationship changes. */\n  graph?: ChangesetGraph;\n}\n\nconst NOTE =\n  \"The earlier state is rebuilt from the changes that made up the plan at `since` (unstaged ones from the \" +\n  \"changeset's unstage record), applied to today's base model; base drift since then is not separated out. \" +\n  \"It is approximate when a change staged by then was rewritten in place afterwards: pass the brief's \" +\n  \"revisionToken as `since` to be warned when that happened.\";\n\n/**\n * Rebuilds the brief side for `since` (a revision number, or a brief's `revisionToken`) and compares\n * it with `now`. A token whose hash no longer matches the plan at its revision adds a warning: a\n * change up to it was rewritten in place, so the rebuilt earlier state is not the one the token was\n * taken from.\n */\nexport async function briefDelta(\n  model: Model,\n  now: { graph: ChangesetGraph; brief: ChangesetBrief },\n  since: number | string\n): Promise<BriefDelta> {\n  let revision: number;\n  const warnings: string[] = [];\n  const changeset = now.graph.changeset;\n  if (typeof since === \"string\") {\n    const parsed = parseRevisionToken(since);\n    if (!parsed) {\n      throw new Error(`since \"${since}\" is neither a revision number nor a revision token (<revision>:<hash>) from a brief`);\n    }\n    revision = parsed.revision;\n    const today = changesetRevisionToken(changeset, revision);\n    if (revision <= now.brief.revision && today !== since) {\n      warnings.push(\n        `The plan at revision ${revision} is not the one that revision token was taken from: a change up to it ` +\n          \"was rewritten in place since then (or the changeset was rewritten, e.g. by an upgrade). The earlier \" +\n          \"state below is rebuilt from what is recorded now, so this delta is approximate.\"\n      );\n    }\n  } else {\n    revision = since;\n  }\n  const prunedThrough = changeset.unstagedPrunedThrough;\n  if (prunedThrough !== undefined && revision < prunedThrough) {\n    warnings.push(\n      `Unstage tombstones up to revision ${prunedThrough} were dropped to keep the record bounded, so changes ` +\n        `unstaged between revision ${revision} and then may be missing from the rebuilt earlier state and from ` +\n        \"`unstaged`; this delta is approximate.\"\n    );\n  }\n  const earlier = await ChangesetGraph.build(model, changeset, { throughSequence: revision });\n  const then: BriefSide = {\n    brief: buildBrief({ graph: earlier, unwired: \"none\" }),\n    unwired: computeUnwired(earlier),\n    graph: earlier,\n  };\n  const delta = diffBriefs(then, { brief: now.brief, unwired: computeUnwired(now.graph), graph: now.graph }, revision, warnings);\n  delta.unstaged = unstagedSince(changeset, revision).map((t, index) => ({\n    ...summarizeChange({ ...t.change, sequenceNumber: t.sequence } as StagedChange, index),\n    removedAt: t.removedAt,\n  }));\n  return delta;\n}\n\nexport function diffBriefs(then: BriefSide, now: BriefSide, since: number, extraWarnings: string[] = []): BriefDelta {\n  const revision = now.brief.revision;\n  const warnings: string[] = [...extraWarnings];\n  if (since > revision) {\n    warnings.push(\n      `since (${since}) is past the current revision (${revision}), so it is not a revision of this plan; the ` +\n        \"delta compares the changeset with itself.\"\n    );\n  }\n\n  const changedIds = (brief: ChangesetBrief) => brief.layers.flatMap((l) => l.changes.map((c) => c.id));\n  const thenIds = new Set(changedIds(then.brief));\n  const nowIds = new Set(changedIds(now.brief));\n\n  const gapKey = (g: BriefGap) => `${g.kind}|${g.element}|${g.kind === \"peer-pattern\" ? g.detail.replace(/^\\d+ of \\d+ /, \"\") : g.detail}`;\n  const thenGaps = new Map(then.brief.gaps.map((g) => [gapKey(g), g]));\n  const nowGaps = new Map(now.brief.gaps.map((g) => [gapKey(g), g]));\n\n  const flatten = (list: ElementUnwired[]) => {\n    const map = new Map<string, UnwiredDeltaEntry>();\n    for (const { element, byLayer } of list) {\n      for (const { layer, entries } of byLayer) {\n        for (const entry of entries) map.set(unwiredKey(element, entry), { element, layer, ...entry });\n      }\n    }\n    return map;\n  };\n  const thenUnwired = flatten(then.unwired);\n  const nowUnwired = flatten(now.unwired);\n  const thenScoped = new Set(then.unwired.map((u) => u.element));\n  const nowScoped = new Set(now.unwired.map((u) => u.element));\n\n  const traced = (brief: ChangesetBrief) => new Set(brief.intent.traced.map((t) => t.element));\n  const untraced = (brief: ChangesetBrief) => new Set(brief.intent.untraced);\n  const thenTraced = traced(then.brief);\n  const thenUntraced = untraced(then.brief);\n  const thenReach = new Set(then.brief.reach.touched);\n  const nowReach = new Set(now.brief.reach.touched);\n\n  return {\n    since,\n    revision,\n    elements: {\n      added: [...nowIds].filter((id) => !thenIds.has(id)),\n      removed: [...thenIds].filter((id) => !nowIds.has(id)),\n      updated: then.graph && now.graph ? elementUpdates(then.graph, now.graph) : [],\n    },\n    relationships: then.graph && now.graph ? relationshipChanges(then.graph, now.graph) : { added: [], removed: [] },\n    unstaged: [],\n    gaps: {\n      opened: [...nowGaps].filter(([k]) => !thenGaps.has(k)).map(([, g]) => g),\n      closed: [...thenGaps].filter(([k]) => !nowGaps.has(k)).map(([, g]) => g),\n    },\n    unwired: {\n      wired: [...thenUnwired]\n        .filter(([k, e]) => !nowUnwired.has(k) && nowScoped.has(e.element))\n        .map(([, e]) => e),\n      new: [...nowUnwired].filter(([k, e]) => !thenUnwired.has(k) && thenScoped.has(e.element)).map(([, e]) => e),\n      newElements: now.unwired\n        .filter((u) => !thenScoped.has(u.element))\n        .map((u) => ({ element: u.element, count: u.byLayer.reduce((sum, l) => sum + l.entries.length, 0) })),\n    },\n    reach: {\n      newlyReached: now.brief.reach.touched.filter((l) => !thenReach.has(l)),\n      noLongerReached: then.brief.reach.touched.filter((l) => !nowReach.has(l)),\n    },\n    intent: {\n      newlyTraced: now.brief.intent.traced.map((t) => t.element).filter((id) => !thenTraced.has(id)),\n      newlyUntraced: now.brief.intent.untraced.filter((id) => !thenUntraced.has(id)),\n    },\n    note: NOTE,\n    ...(warnings.length > 0 ? { warnings } : {}),\n  };\n}\n\n/** Elements present (not deleted) in both projections whose content differs, with the fields that do. */\nfunction elementUpdates(then: ChangesetGraph, now: ChangesetGraph): Array<{ element: string; fields: string[] }> {\n  const updates: Array<{ element: string; fields: string[] }> = [];\n  for (const after of now.elements.values()) {\n    if (after.status === \"deleted\") continue;\n    const before = then.getElement(after.id);\n    if (!before || before.status === \"deleted\") continue;\n    // Both from the base: same content. (One unchanged and one not still compares: an update\n    // staged or unstaged since.)\n    if (before.status === \"unchanged\" && after.status === \"unchanged\") continue;\n    const fields = changedFields(before, after);\n    if (fields.length > 0) updates.push({ element: after.id, fields });\n  }\n  return updates;\n}\n\nfunction changedFields(before: GraphElement, after: GraphElement): string[] {\n  const fields: string[] = [];\n  const same = (a: unknown, b: unknown) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);\n  if (!same(before.name, after.name)) fields.push(\"name\");\n  if (!same(before.description, after.description)) fields.push(\"description\");\n  for (const key of [...new Set([...Object.keys(before.attributes), ...Object.keys(after.attributes)])].sort()) {\n    if (!same(before.attributes[key], after.attributes[key])) fields.push(`attributes.${key}`);\n  }\n  if (!same(before.sourceReference, after.sourceReference)) fields.push(\"sourceReference\");\n  return fields;\n}\n\n/** Relationships live in one projection and not the other. */\nfunction relationshipChanges(\n  then: ChangesetGraph,\n  now: ChangesetGraph\n): { added: RelationshipTriple[]; removed: RelationshipTriple[] } {\n  const live = (graph: ChangesetGraph) =>\n    new Map(\n      graph\n        .relationships()\n        .filter((r) => r.status !== \"deleted\")\n        .map((r) => [relationshipKey(r), { source: r.source, predicate: r.predicate, target: r.target }])\n    );\n  const before = live(then);\n  const after = live(now);\n  return {\n    added: [...after].filter(([k]) => !before.has(k)).map(([, r]) => r),\n    removed: [...before].filter(([k]) => !after.has(k)).map(([, r]) => r),\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/changeset-graph.js

@@ -0,0 +1,281 @@
+import { createHash } from "node:crypto";
+import { compactChange, nextSequenceNumber, sequenceOf } from "./changeset.js";
+import { stagedSourceReference } from "./staged-source-reference.js";
+function sequencedChanges(changeset) {
+  return changeset.changes.map((change, index) => ({ change, sequence: sequenceOf(change, index) })).sort((a, b) => a.sequence - b.sequence);
+}
+function changesAtRevision(changeset, revision) {
+  const live = sequencedChanges(changeset);
+  if (revision === void 0)
+    return live;
+  const bySequence = /* @__PURE__ */ new Map();
+  for (const entry of live)
+    entry.sequence <= revision && bySequence.set(entry.sequence, entry);
+  for (const t of tombstonesLiveAt(changeset, revision))
+    bySequence.set(t.sequence, {
+      change: { ...t.change, sequenceNumber: t.sequence },
+      sequence: t.sequence,
+      ...t.rewritten ? {} : { unstagedAt: t.removedAt }
+    });
+  return [...bySequence.values()].sort((a, b) => a.sequence - b.sequence);
+}
+function tombstonesLiveAt(changeset, revision) {
+  const earliest = /* @__PURE__ */ new Map();
+  for (const t of changeset.unstaged ?? []) {
+    if (t.sequence > revision || t.removedAt <= revision)
+      continue;
+    const kept = earliest.get(t.sequence);
+    (!kept || t.removedAt < kept.removedAt) && earliest.set(t.sequence, t);
+  }
+  return [...earliest.values()].sort((a, b) => a.sequence - b.sequence);
+}
+function unstagedSince(changeset, revision) {
+  const live = new Set(sequencedChanges(changeset).map(({ sequence }) => sequence)), result = [];
+  for (const { sequence } of tombstonesLiveAt(changeset, revision)) {
+    if (live.has(sequence))
+      continue;
+    const unstage = (changeset.unstaged ?? []).filter((t) => t.sequence === sequence && !t.rewritten && t.removedAt > revision).sort((x, y) => y.removedAt - x.removedAt)[0];
+    unstage && result.push(unstage);
+  }
+  return result;
+}
+function changesetRevision(changeset) {
+  return nextSequenceNumber(changeset) - 1;
+}
+function changesetRevisionToken(changeset, throughSequence) {
+  const revision = throughSequence ?? changesetRevision(changeset), hash = createHash("sha256");
+  for (const { change, sequence } of changesAtRevision(changeset, revision)) {
+    const compact = compactChange(change);
+    hash.update(JSON.stringify([sequence, compact.type, compact.elementId, compact.timestamp ?? null, compact.before ?? null, compact.after ?? null])), hash.update(`
+`);
+  }
+  return `${revision}:${hash.digest("hex").slice(0, 12)}`;
+}
+function parseRevisionToken(token) {
+  const match = /^(-1|\d+):([0-9a-f]+)$/.exec(token);
+  return match ? { revision: Number(match[1]), hash: match[2] } : void 0;
+}
+function relationshipKey(rel) {
+  return `${rel.source}::${rel.predicate}::${rel.target}`;
+}
+class ChangesetGraph {
+  changeset;
+  elements = /* @__PURE__ */ new Map();
+  relationshipsByKey = /* @__PURE__ */ new Map();
+  /** UUID → dotted path, so relationship rows that name elements by UUID still resolve. */
+  uuidToPath = /* @__PURE__ */ new Map();
+  adjacency = null;
+  /** The staged changes this projection applied, in sequence order. */
+  appliedChanges = [];
+  _revision = -1;
+  constructor(changeset) {
+    this.changeset = changeset;
+  }
+  /** The revision this projection shows (see `changesetRevision`); -1 when nothing was staged by then. */
+  get revision() {
+    return this._revision;
+  }
+  /**
+   * Builds the projected graph of `changeset` over the base model. With `throughSequence`, the plan
+   * as it stood at that revision, over today's base: the changes numbered at most that, including
+   * ones unstaged since (rebuilt from their tombstones).
+   */
+  static async build(model, changeset, options = {}) {
+    const graph = new ChangesetGraph(changeset);
+    for (const layerName of model.getLayerNames()) {
+      const layer = await model.getBaseLayer(layerName);
+      if (layer)
+        for (const element of layer.listElements()) {
+          const record = element.toJSON();
+          graph.putElement(fromRecord(record, layerName, "unchanged"));
+        }
+    }
+    const baseRelationships = typeof model.getBaseRelationships == "function" ? model.getBaseRelationships() : model.relationships.getAll();
+    for (const rel of baseRelationships) {
+      const resolved = {
+        source: graph.resolve(rel.source),
+        predicate: rel.predicate,
+        target: graph.resolve(rel.target)
+      };
+      graph.relationshipsByKey.set(relationshipKey(resolved), {
+        ...resolved,
+        layer: rel.layer,
+        ...rel.targetLayer ? { targetLayer: rel.targetLayer } : {},
+        ...rel.properties ? { properties: rel.properties } : {},
+        status: "unchanged",
+        ...resolved.source !== rel.source || resolved.target !== rel.target ? { raw: { source: rel.source, target: rel.target } } : {}
+      });
+    }
+    const through = options.throughSequence, applied = changesAtRevision(changeset, through);
+    graph.appliedChanges = applied.map(({ change }) => change);
+    const current = changesetRevision(changeset);
+    graph._revision = through === void 0 ? current : Math.min(through, current);
+    for (const change of graph.appliedChanges)
+      graph.apply(change);
+    return graph;
+  }
+  /** Maps a UUID to its dotted path; returns any other identifier unchanged. */
+  resolve(id) {
+    return this.uuidToPath.get(id) ?? id;
+  }
+  getElement(id) {
+    return this.elements.get(this.resolve(id));
+  }
+  /** Every relationship in the projection, including the ones the changeset deletes. */
+  relationships() {
+    return [...this.relationshipsByKey.values()];
+  }
+  /** Whether the projection holds a relationship that is not deleted. */
+  hasLiveRelationship(source, predicate, target) {
+    const rel = this.relationshipsByKey.get(relationshipKey({ source: this.resolve(source), predicate, target: this.resolve(target) }));
+    return !!rel && rel.status !== "deleted";
+  }
+  getRelationship(source, predicate, target) {
+    return this.relationshipsByKey.get(relationshipKey({ source: this.resolve(source), predicate, target: this.resolve(target) }));
+  }
+  /** Elements the changeset adds, updates or deletes, in the order of their first change. */
+  changedElements() {
+    const seen = /* @__PURE__ */ new Set(), result = [];
+    for (const change of this.appliedChanges) {
+      if (change.type.startsWith("relationship-"))
+        continue;
+      const element = this.getElement(change.elementId);
+      !element || element.status === "unchanged" || seen.has(element.id) || (seen.add(element.id), result.push(element));
+    }
+    return result;
+  }
+  /** Relationships the changeset adds or deletes. */
+  changedRelationships() {
+    return this.relationships().filter((rel) => rel.status !== "unchanged");
+  }
+  /**
+   * Staged adds the base model already has: elements and relationships the changeset adds whose id
+   * (or source, predicate and target) now exists in the base. They are not counted as adds, since
+   * commit skips them; a later staged update or delete of the same element still applies.
+   */
+  alreadyInBase() {
+    return {
+      elements: [...this.elements.values()].filter((e) => e.alreadyInBase && e.status !== "deleted"),
+      relationships: this.relationships().filter((r) => r.alreadyInBase && r.status === "unchanged")
+    };
+  }
+  /** Relationships touching an element, with the element's side of each. */
+  neighbors(id, options = {}) {
+    const all = this.getAdjacency().get(this.resolve(id)) ?? [];
+    return options.includeDeleted ? all : all.filter((n) => n.relationship.status !== "deleted");
+  }
+  getAdjacency() {
+    if (this.adjacency)
+      return this.adjacency;
+    const adjacency = /* @__PURE__ */ new Map(), push = (id, neighbor) => {
+      const list = adjacency.get(id);
+      list ? list.push(neighbor) : adjacency.set(id, [neighbor]);
+    };
+    for (const rel of this.relationshipsByKey.values())
+      push(rel.source, { relationship: rel, direction: "out", other: rel.target }), rel.target !== rel.source && push(rel.target, { relationship: rel, direction: "in", other: rel.source });
+    return this.adjacency = adjacency, adjacency;
+  }
+  putElement(element) {
+    this.elements.set(element.id, element), element.uuid && element.uuid !== element.id && this.uuidToPath.set(element.uuid, element.id);
+  }
+  /**
+   * A committed changeset's changes are already in the base model, so a base element or
+   * relationship matching one of its adds is that add, not an earlier copy of it.
+   */
+  isCommitted() {
+    return this.changeset.status === "committed";
+  }
+  apply(change) {
+    switch (change.type) {
+      case "add": {
+        if (!change.after)
+          return;
+        const element = fromRecord(change.after, change.layerName, "added", change.elementId), existing = this.getElement(element.id);
+        if (existing && existing.status === "unchanged" && !this.isCommitted()) {
+          existing.alreadyInBase = !0;
+          return;
+        }
+        this.putElement(element);
+        return;
+      }
+      case "update": {
+        if (!change.after)
+          return;
+        const existing = this.getElement(change.elementId), status = existing?.status === "added" ? "added" : "updated", element = fromRecord(change.after, change.layerName, status, change.elementId);
+        element.before = existing?.before ?? change.before, this.putElement(element);
+        return;
+      }
+      case "delete": {
+        const existing = this.getElement(change.elementId);
+        if (!existing)
+          return;
+        existing.status === "added" ? this.elements.delete(existing.id) : (existing.before = existing.before ?? change.before, existing.status = "deleted");
+        return;
+      }
+      case "relationship-add": {
+        const data = change.after;
+        if (!data?.source || !data.target || !data.predicate)
+          return;
+        const rel = {
+          source: this.resolve(data.source),
+          predicate: data.predicate,
+          target: this.resolve(data.target)
+        }, key = relationshipKey(rel), existing = this.relationshipsByKey.get(key);
+        if (existing && existing.status === "unchanged" && !this.isCommitted()) {
+          existing.alreadyInBase = !0;
+          return;
+        }
+        this.relationshipsByKey.set(key, {
+          ...rel,
+          layer: data.layer ?? change.layerName,
+          ...data.targetLayer ? { targetLayer: data.targetLayer } : {},
+          ...data.properties ? { properties: data.properties } : {},
+          // Re-adding a relationship this changeset deleted restores it. A committed changeset's add
+          // is in the base because the changeset landed it, so it stays an add.
+          status: existing?.status === "deleted" ? "unchanged" : "added",
+          ...existing?.raw ? { raw: existing.raw } : {}
+        });
+        return;
+      }
+      case "relationship-delete": {
+        const data = change.before ?? change.after, [source, predicate, target] = data?.source ? [data.source, data.predicate, data.target] : change.elementId.split("::");
+        if (!source || !predicate || !target)
+          return;
+        const key = relationshipKey({
+          source: this.resolve(source),
+          predicate,
+          target: this.resolve(target)
+        }), existing = this.relationshipsByKey.get(key);
+        if (!existing)
+          return;
+        existing.status === "added" ? this.relationshipsByKey.delete(key) : existing.status = "deleted";
+        return;
+      }
+    }
+  }
+}
+function fromRecord(record, layerName, status, fallbackId) {
+  const str = (value) => typeof value == "string" && value.length > 0 ? value : void 0, id = str(record.path) ?? fallbackId ?? str(record.id) ?? "";
+  return {
+    id,
+    uuid: str(record.id),
+    layer: str(record.layer_id) ?? str(record.layer) ?? layerName,
+    type: str(record.type) ?? "",
+    name: str(record.name) ?? id,
+    description: str(record.description),
+    attributes: record.attributes ?? {},
+    sourceReference: stagedSourceReference(record),
+    status
+  };
+}
+export {
+  ChangesetGraph,
+  changesAtRevision,
+  changesetRevision,
+  changesetRevisionToken,
+  parseRevisionToken,
+  relationshipKey,
+  sequencedChanges,
+  unstagedSince
+};
+//# sourceMappingURL=changeset-graph.js.map