@aburi/diff 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kage1020
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -21,7 +21,7 @@ Symbols are paired across base / head via cascading stages:
 
 Unmatched base Symbols become `removed`, unmatched head Symbols become `added`.
 Matched pairs are classified into one of five statuses per
-[`design/details/diff-algorithm.md`](../../design/details/diff-algorithm.md):
+[`docs/design/diff-algorithm.md`](../../docs/design/diff-algorithm.md):
 `unchanged` / `moved` / `changed` / `moved+changed` / `dropped-toggled`
 (with `to-dropped` / `to-kept` direction).
 
@@ -59,4 +59,4 @@ await writeFile("out/diff.json", writeCanonicalDiff(diff, { format: "compact" })
 ## See also
 
 - [`schema/aburi.diff.v1.json`](../../schema/aburi.diff.v1.json)
-- [`design/details/diff-algorithm.md`](../../design/details/diff-algorithm.md)
+- [`docs/design/diff-algorithm.md`](../../docs/design/diff-algorithm.md)

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { SerializeOptions } from "@aburi/core";
-import { Component, ComponentDiff, Dependency, DependencyDiff, DiffResult, IR, IRRef, MatchRationale, Signature, Symbol, SymbolDelta } from "@aburi/types";
+import { CallEdge, SerializeOptions } from "@aburi/core";
+import { Component, ComponentDiff, Dependency, DependencyDiff, DiffResult, IR, IRRef, MatchRationale, Signature, SliceRecord, Symbol, SymbolChange, SymbolDelta, SymbolId } from "@aburi/types";
 
 //#region src/components.d.ts
 /**
@@ -172,7 +172,16 @@ type DiffErrorCode = /** `base.$schema` and `head.$schema` disagree; a diff acro
  * `dependencies`, or an absent `$schema` — anything that would otherwise crash with a
  * cryptic `TypeError: undefined is not iterable` deep in a matching stage.
  */
-| "ir-shape-invalid";
+| "ir-shape-invalid"
+/**
+ * A `SliceRecord` broke the derivation invariant of slice-view.md §7.1 / §8.2:
+ * `members[]` empty, `members[]` not in strictly ascending order, or `id` not
+ * equal to `"slice:" + members[0]`. The last two compare one property against
+ * another and so have no JSON Schema equivalent; the pass checks them itself
+ * (§7.4). Raised only by an Aburi bug, never by user input — see
+ * `SliceRecordViolation.kind` for which clause broke.
+ */
+| "slice-invariant-violated";
 interface DiffErrorDetail {
   code: DiffErrorCode;
   /** Offending value (schema id, fuzz value, etc.) when applicable. */
@@ -254,6 +263,79 @@ declare function ownerSimilarity(baseName: string, headName: string): number;
 /** §3.4.1 tail note — used by drop-4.5 weak matcher and threshold lookup. */
 declare function lastSegment(qname: string): string;
 //#endregion
+//#region src/slice.d.ts
+/** The three inputs of the Slice View pass — docs/design/slice-view.md §3. */
+interface SliceInput {
+  /** SymbolChange records produced by `buildDiff` (pre-sort is not required). */
+  changes: readonly SymbolChange[];
+  /**
+   * Resolved call edges from the base IR. Typically produced by
+   * `reconstructCallEdgesFromIR(baseIR)` inside `buildDiff` — Slice View
+   * consumes only resolved edges (§5.4), never `Symbol.calls[]` directly.
+   */
+  baseCallEdges: readonly CallEdge[];
+  /** Resolved call edges from the head IR (same source rule as base). */
+  headCallEdges: readonly CallEdge[];
+}
+/**
+ * Slice View clustering pass — docs/design/slice-view.md §2, §4–§8.
+ *
+ * Groups the changed-Symbol set of a diff into weakly-connected components
+ * over the union of base and head call edges. Emits a `SliceRecord[]` whose
+ * cluster ids are `"slice:" + <smallest-member Symbol id>`, both `slices[]`
+ * and each `members[]` sorted ascending.
+ *
+ * Pure function: `(changes, baseCallEdges, headCallEdges)` → `SliceRecord[]`.
+ * Determinism, idempotence, input-order insensitivity, and locality are all
+ * guaranteed — see `computeWeaklyConnectedComponents` in `@aburi/core`.
+ *
+ * Returns `[]` when no SymbolChange is Node-eligible per §4.1; callers should
+ * still serialise the empty array — the Markdown projection omits the section
+ * (§9.4 / §12.5) but the JSON always emits the key so consumers never
+ * distinguish "field absent" from "no slices" (§11.2).
+ *
+ * Every returned record has passed `assertSliceRecordInvariant` (§7.4).
+ */
+declare function computeSlices(input: SliceInput): SliceRecord[];
+/**
+ * §7.1 — the anchor of a Slice: its lexicographically smallest member.
+ *
+ * Answers from `members[0]`. `id` is derived from the anchor, so
+ * reconstructing the anchor by stripping the `"slice:"` prefix is circular at
+ * best and, for a record that broke the derivation, silently wrong: it would
+ * name a Symbol that is not in the Slice. `id` is read here only to name the
+ * offending record in the error message. Consumers that need the anchor call
+ * this; consumers that need a label keep using `id` directly.
+ */
+declare function sliceAnchor(record: SliceRecord): SymbolId;
+/** Which clause of the §7.1 / §8.2 invariant a `SliceRecord` broke. */
+type SliceViolationKind = /** Not a `SliceRecord` at all: not an object, or `id` / `members` of the wrong type. */"malformed-shape" /** `members[]` has no entries, so the Slice has no anchor (§11.1). */ | "members-empty" /** `members[]` is not in strictly ascending order, so `members[0]` need not be the smallest (§8.2, §11.1). */ | "members-unordered" /** `id` is not `"slice:" + members[0]` (§7.1). */ | "id-not-derived" /** The anchor is itself in a reserved id namespace, so `id` would read as a doubled prefix (§7.5). */ | "anchor-in-reserved-namespace";
+interface SliceRecordViolation {
+  kind: SliceViolationKind;
+  /** The offending record's `id` when it has a usable one, else a short stand-in. */
+  subject: string;
+  /** Human-facing explanation, suitable for an error message or a validator error. */
+  message: string;
+}
+/**
+ * Report which clause of the §7.1 / §8.2 invariant a value breaks, or `null`
+ * when it is a well-formed `SliceRecord`. Non-throwing counterpart of
+ * `assertSliceRecordInvariant`: the pass wants an exception, a schema
+ * validator wants a verdict it can turn into its own error.
+ *
+ * Takes `unknown` rather than `SliceRecord` deliberately. §7.4 layer 2 points
+ * this at documents written by third-party or older producers — data that has
+ * not been type-checked by definition — so anything that assumed a well-typed
+ * argument would crash on exactly the input it exists to reject.
+ */
+declare function sliceRecordViolation(value: unknown): SliceRecordViolation | null;
+/**
+ * Throwing form of `sliceRecordViolation`. Raised as a coded `DiffError` so
+ * callers branch on `code` rather than parsing the message; which clause broke
+ * is `SliceRecordViolation.kind`, for callers that need to tell them apart.
+ */
+declare function assertSliceRecordInvariant(record: SliceRecord): void;
+//#endregion
 //#region src/status.d.ts
 type SymbolStatus = "unchanged" | "moved" | "changed" | "moved+changed" | "dropped-toggled";
 /**
@@ -263,8 +345,8 @@ type SymbolStatus = "unchanged" | "moved" | "changed" | "moved+changed" | "dropp
  * drop-rule flip, not a genuine code edit (§4.1 rationale).
  *
  * "pathChanged" catches both physical file relocation AND in-file rename: any Symbol id
- * mismatch between base and head means the identifier moved, and DF9 ("method 名 rename
- * (同 file、同 logic) → moved") relies on this. Stage-1 pairs cannot trigger the id branch
+ * mismatch between base and head means the identifier moved, and DF9 ("method rename
+ * (same file, same logic) → moved") relies on this. Stage-1 pairs cannot trigger the id branch
  * (they match by exact id), so this only affects stage-2+ pairings where the pair was
  * discovered via fingerprint or name/signature similarity.
  */
@@ -273,5 +355,5 @@ declare function classifyStatus(base: Symbol, head: Symbol): SymbolStatus;
 type DropDirection = "to-dropped" | "to-kept";
 declare function dropDirection(head: Symbol): DropDirection;
 //#endregion
-export { DEFAULT_LINE_FUZZ, type DeltaOptions, DiffError, type DiffErrorCode, type DiffErrorDetail, type DiffInput, type DropDirection, type GitRenameMap, MAX_LINE_FUZZ, MIN_LINE_FUZZ, type SymbolPair, type SymbolStatus, buildDiff, classifyStatus, computeSymbolDelta, diffComponents, diffDependencies, dropDirection, jaccard, jaccardTokens, lastSegment, matchStageDroppedWeak, matchStageGitRename, matchStageId, matchStageLogicFingerprint, matchStageNameSignature, nameSimilarity, ownerSimilarity, signatureSimilarity, tokenizeName, writeCanonicalDiff };
+export { DEFAULT_LINE_FUZZ, type DeltaOptions, DiffError, type DiffErrorCode, type DiffErrorDetail, type DiffInput, type DropDirection, type GitRenameMap, MAX_LINE_FUZZ, MIN_LINE_FUZZ, type SliceInput, type SliceRecordViolation, type SliceViolationKind, type SymbolPair, type SymbolStatus, assertSliceRecordInvariant, buildDiff, classifyStatus, computeSlices, computeSymbolDelta, diffComponents, diffDependencies, dropDirection, jaccard, jaccardTokens, lastSegment, matchStageDroppedWeak, matchStageGitRename, matchStageId, matchStageLogicFingerprint, matchStageNameSignature, nameSimilarity, ownerSimilarity, signatureSimilarity, sliceAnchor, sliceRecordViolation, tokenizeName, writeCanonicalDiff };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/components.ts","../src/delta.ts","../src/match.ts","../src/diff.ts","../src/errors.ts","../src/signature.ts","../src/similarity.ts","../src/status.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/components.ts","../src/delta.ts","../src/match.ts","../src/diff.ts","../src/errors.ts","../src/signature.ts","../src/similarity.ts","../src/slice.ts","../src/status.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { serializeCanonical } from "@aburi/core";
+import { RESERVED_LANGUAGE_IDS, computeWeaklyConnectedComponents, reconstructCallEdgesFromIR, serializeCanonical, trySymbolId } from "@aburi/core";
 
 //#region src/components.ts
 /**
@@ -208,7 +208,7 @@ function diffEffects(base, head) {
 	const mapper = (e) => ({
 		item: e,
 		key: `${e.id}::${e.target}`,
-		line: e.line
+		line: e.line ?? 0
 	});
 	return differentiate(base.map(mapper), head.map(mapper), effectsEqual, Number.POSITIVE_INFINITY);
 }
@@ -582,7 +582,7 @@ function matchStageGitRename(remainingBase, remainingHead, renameMap) {
 			continue;
 		}
 		const expectedId = rewriteIdFile(b.id, b.source.file, newPath);
-		const h = headById.get(expectedId);
+		const h = expectedId === null ? void 0 : headById.get(expectedId);
 		if (h === void 0 || usedHead.has(h.id)) {
 			remaining.push(b);
 			continue;
@@ -600,13 +600,26 @@ function matchStageGitRename(remainingBase, remainingHead, renameMap) {
 		remainingHead: remainingHead.filter((h) => !usedHead.has(h.id))
 	};
 }
+/**
+* Predict the id a base Symbol would carry after git moved its file. The second Symbol-id
+* derivation in the codebase after `makeSymbolId` itself, so it goes back through the same
+* constructor rather than re-concatenating the parts: `trySymbolId` rejects a rename target
+* the id grammar cannot express (a backslash path, say) instead of minting an id no head
+* Symbol can ever equal.
+*
+* Returns `null` for that case, and the unchanged id when no rename applies — the caller
+* treats a null the same way it treats a lookup miss, leaving the pair for stage 3.
+*/
 function rewriteIdFile(id, oldPath, newPath) {
 	const colon = id.indexOf(":");
 	const hash = id.indexOf("#");
 	if (colon < 0 || hash < 0 || hash < colon) return id;
-	const language = id.slice(0, colon);
 	if (id.slice(colon + 1, hash) !== oldPath) return id;
-	return `${language}:${newPath}${id.slice(hash)}`;
+	return trySymbolId({
+		language: id.slice(0, colon),
+		file: newPath,
+		qualifiedName: id.slice(hash + 1)
+	});
 }
 /**
 * §3.3 — group base Symbols by `fingerprint.logic` and match head Symbols whose logic
@@ -821,6 +834,226 @@ function basename(path) {
 	return slash >= 0 ? path.slice(slash + 1) : path;
 }
 
+//#endregion
+//#region src/slice.ts
+/**
+* Slice View clustering pass — docs/design/slice-view.md §2, §4–§8.
+*
+* Groups the changed-Symbol set of a diff into weakly-connected components
+* over the union of base and head call edges. Emits a `SliceRecord[]` whose
+* cluster ids are `"slice:" + <smallest-member Symbol id>`, both `slices[]`
+* and each `members[]` sorted ascending.
+*
+* Pure function: `(changes, baseCallEdges, headCallEdges)` → `SliceRecord[]`.
+* Determinism, idempotence, input-order insensitivity, and locality are all
+* guaranteed — see `computeWeaklyConnectedComponents` in `@aburi/core`.
+*
+* Returns `[]` when no SymbolChange is Node-eligible per §4.1; callers should
+* still serialise the empty array — the Markdown projection omits the section
+* (§9.4 / §12.5) but the JSON always emits the key so consumers never
+* distinguish "field absent" from "no slices" (§11.2).
+*
+* Every returned record has passed `assertSliceRecordInvariant` (§7.4).
+*/
+function computeSlices(input) {
+	const nodeIds = collectNodeIds(input.changes);
+	if (nodeIds.length === 0) return [];
+	const nodeIdSet = new Set(nodeIds);
+	return computeWeaklyConnectedComponents(nodeIds, collectEdges(input.baseCallEdges, input.headCallEdges, nodeIdSet), (id) => id).map(makeSliceRecord);
+}
+const SLICE_ID_PREFIX = "slice:";
+/**
+* §7.1 — the single place production code derives a Slice id. Everything else
+* in `src/` either receives an id or renders one. (Tests spell the prefix out
+* literally on purpose: an expectation written in terms of the function under
+* test would agree with it no matter what it produced.)
+*
+* The cast is the one place a `SliceId` comes into existence. `SliceId` and
+* `SymbolId` are separate brands precisely so this concatenation cannot be
+* open-coded anywhere else: a bare `"slice:" + x` evaluates to `string`, which
+* `SliceRecord.id` no longer accepts.
+*/
+function sliceIdFor(anchor) {
+	return `${SLICE_ID_PREFIX}${anchor}`;
+}
+/**
+* Build one SliceRecord from an ascending-sorted component and check its own
+* post-condition before letting it out (§7.4 layer 1).
+*
+* The check is not defending against untrusted input — this function builds
+* the id itself, so the derivation clause is true by construction here and
+* only the two clauses about `members` can actually fire. Those are the point:
+* `members[0]` is the anchor only because `computeWeaklyConnectedComponents`
+* returns each component sorted ascending, a guarantee that lives one layer
+* down and is invisible from this file. If it ever stops holding, the diff
+* would otherwise keep emitting well-formed-looking SliceRecords naming the
+* wrong anchor. Here it fails instead.
+*/
+function makeSliceRecord(members) {
+	const anchor = members[0];
+	if (anchor === void 0) throw new DiffError("computeSlices: the clustering utility returned an empty component; every weakly-connected component contains at least the node that seeded it (slice-view.md §6).", { code: "slice-invariant-violated" });
+	const record = {
+		id: sliceIdFor(anchor),
+		members: [...members]
+	};
+	assertSliceRecordInvariant(record);
+	return record;
+}
+/**
+* §7.1 — the anchor of a Slice: its lexicographically smallest member.
+*
+* Answers from `members[0]`. `id` is derived from the anchor, so
+* reconstructing the anchor by stripping the `"slice:"` prefix is circular at
+* best and, for a record that broke the derivation, silently wrong: it would
+* name a Symbol that is not in the Slice. `id` is read here only to name the
+* offending record in the error message. Consumers that need the anchor call
+* this; consumers that need a label keep using `id` directly.
+*/
+function sliceAnchor(record) {
+	const anchor = record.members[0];
+	if (anchor === void 0) {
+		const violation = emptyMembersViolation(record.id);
+		throw new DiffError(violation.message, {
+			code: "slice-invariant-violated",
+			value: violation.subject
+		});
+	}
+	return anchor;
+}
+/**
+* Report which clause of the §7.1 / §8.2 invariant a value breaks, or `null`
+* when it is a well-formed `SliceRecord`. Non-throwing counterpart of
+* `assertSliceRecordInvariant`: the pass wants an exception, a schema
+* validator wants a verdict it can turn into its own error.
+*
+* Takes `unknown` rather than `SliceRecord` deliberately. §7.4 layer 2 points
+* this at documents written by third-party or older producers — data that has
+* not been type-checked by definition — so anything that assumed a well-typed
+* argument would crash on exactly the input it exists to reject.
+*/
+function sliceRecordViolation(value) {
+	if (typeof value !== "object" || value === null) return {
+		kind: "malformed-shape",
+		subject: "<not an object>",
+		message: `Expected a SliceRecord object; got ${value === null ? "null" : typeof value}.`
+	};
+	const { id, members } = value;
+	const subject = typeof id === "string" ? id : "<missing id>";
+	if (typeof id !== "string") return {
+		kind: "malformed-shape",
+		subject,
+		message: `SliceRecord ${subject}: id must be a string; got ${typeof id}.`
+	};
+	if (!Array.isArray(members) || members.some((member) => typeof member !== "string")) return {
+		kind: "malformed-shape",
+		subject,
+		message: `SliceRecord ${subject}: members must be an array of strings.`
+	};
+	const anchor = members[0];
+	if (anchor === void 0) return emptyMembersViolation(subject);
+	const reservedAnchor = reservedNamespaceOf(anchor);
+	if (reservedAnchor !== null) return {
+		kind: "anchor-in-reserved-namespace",
+		subject,
+		message: `SliceRecord anchor "${anchor}" uses the reserved language token "${reservedAnchor}", so its Slice id would repeat the prefix (ir-schema.md §3.5, slice-view.md §7.5).`
+	};
+	for (let i = 1; i < members.length; i++) {
+		const previous = members[i - 1];
+		const current = members[i];
+		if (previous < current) continue;
+		return {
+			kind: "members-unordered",
+			subject,
+			message: `SliceRecord ${subject}: members[] is not in strictly ascending order at index ${i} ("${current}" follows "${previous}"), so members[0] is not necessarily the anchor (slice-view.md §8.2 for the order, §11.1 for uniqueness).`
+		};
+	}
+	const expected = sliceIdFor(anchor);
+	if (id !== expected) return {
+		kind: "id-not-derived",
+		subject,
+		message: `SliceRecord id "${id}" is not derived from the anchor "${anchor}"; expected "${expected}" (slice-view.md §7.1).`
+	};
+	return null;
+}
+/** The reserved token an id opens with, or `null`. Shares the list `@aburi/core` enforces. */
+function reservedNamespaceOf(id) {
+	const colon = id.indexOf(":");
+	if (colon < 0) return null;
+	const token = id.slice(0, colon);
+	return RESERVED_LANGUAGE_IDS.has(token) ? token : null;
+}
+/** Single source of the empty-`members[]` wording, shared with `sliceAnchor`. */
+function emptyMembersViolation(subject) {
+	return {
+		kind: "members-empty",
+		subject,
+		message: `SliceRecord ${subject}: members[] is empty, so the Slice has no anchor (slice-view.md §11.1 requires at least one member).`
+	};
+}
+/**
+* Throwing form of `sliceRecordViolation`. Raised as a coded `DiffError` so
+* callers branch on `code` rather than parsing the message; which clause broke
+* is `SliceRecordViolation.kind`, for callers that need to tell them apart.
+*/
+function assertSliceRecordInvariant(record) {
+	const violation = sliceRecordViolation(record);
+	if (violation === null) return;
+	throw new DiffError(violation.message, {
+		code: "slice-invariant-violated",
+		value: violation.subject
+	});
+}
+/**
+* §4.1 Node selection: keep every SymbolChange whose status is
+* added / removed / changed / moved+changed / dropped-toggled. The identity
+* is the head-side Symbol id where present (added / changed / moved+changed /
+* dropped-toggled), the base-side id for removed. Pure moved and unchanged
+* (already stripped upstream) are excluded — §4.1 / §4.3.
+*
+* The returned array is deliberately not deduplicated: a well-formed
+* SymbolChange list from `buildDiff` never mentions the same Symbol id
+* twice, and Union-Find would coalesce any accidental duplicate anyway.
+*/
+function collectNodeIds(changes) {
+	const ids = [];
+	for (const change of changes) {
+		const id = nodeIdOf(change);
+		if (id === null) continue;
+		ids.push(id);
+	}
+	return ids;
+}
+function nodeIdOf(change) {
+	switch (change.status) {
+		case "added": return change.symbol.id;
+		case "removed": return change.symbol.id;
+		case "changed":
+		case "moved+changed":
+		case "dropped-toggled": return change.after.id;
+		case "moved": return null;
+	}
+}
+/**
+* §5.1 Edge selection: union of base and head, restricted to edges whose
+* BOTH endpoints are Nodes, canonicalised to `(u, v)` with `u < v` (self-
+* loops implicitly dropped). Multi-edges collapse naturally inside the WCC
+* primitive — no explicit dedup needed.
+*
+* The union is the load-bearing rule of §5.3: a controller that called an
+* old service in base and a new service in head needs both edges to land
+* all three Symbols in a single Slice.
+*/
+function collectEdges(baseEdges, headEdges, nodeIds) {
+	const pairs = [];
+	for (const edge of baseEdges) appendEdgeIfBothNodes(edge, nodeIds, pairs);
+	for (const edge of headEdges) appendEdgeIfBothNodes(edge, nodeIds, pairs);
+	return pairs;
+}
+function appendEdgeIfBothNodes(edge, nodeIds, out) {
+	if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) return;
+	out.push([edge.from, edge.to]);
+}
+
 //#endregion
 //#region src/status.ts
 /**
@@ -830,8 +1063,8 @@ function basename(path) {
 * drop-rule flip, not a genuine code edit (§4.1 rationale).
 *
 * "pathChanged" catches both physical file relocation AND in-file rename: any Symbol id
-* mismatch between base and head means the identifier moved, and DF9 ("method 名 rename
-* (同 file、同 logic) → moved") relies on this. Stage-1 pairs cannot trigger the id branch
+* mismatch between base and head means the identifier moved, and DF9 ("method rename
+* (same file, same logic) → moved") relies on this. Stage-1 pairs cannot trigger the id branch
 * (they match by exact id), so this only affects stage-2+ pairings where the pair was
 * discovered via fingerprint or name/signature similarity.
 */
@@ -966,6 +1199,11 @@ function buildDiff(input) {
 	summary.depsAdded = dependencies.added.length;
 	summary.depsRemoved = dependencies.removed.length;
 	symbols.sort(compareSymbolChange);
+	const slices = computeSlices({
+		changes: symbols,
+		baseCallEdges: reconstructCallEdgesFromIR(input.baseIR),
+		headCallEdges: reconstructCallEdgesFromIR(input.headIR)
+	});
 	return {
 		$schema: DIFF_SCHEMA,
 		generator: input.generator ?? DEFAULT_GENERATOR,
@@ -974,7 +1212,8 @@ function buildDiff(input) {
 		summary,
 		symbols,
 		components,
-		dependencies
+		dependencies,
+		slices
 	};
 }
 /** §9.1 — refuse to diff across schema versions. */
@@ -1037,5 +1276,5 @@ function writeCanonicalDiff(diff, options = {}) {
 }
 
 //#endregion
-export { DEFAULT_LINE_FUZZ, DiffError, MAX_LINE_FUZZ, MIN_LINE_FUZZ, buildDiff, classifyStatus, computeSymbolDelta, diffComponents, diffDependencies, dropDirection, jaccard, jaccardTokens, lastSegment, matchStageDroppedWeak, matchStageGitRename, matchStageId, matchStageLogicFingerprint, matchStageNameSignature, nameSimilarity, ownerSimilarity, signatureSimilarity, tokenizeName, writeCanonicalDiff };
+export { DEFAULT_LINE_FUZZ, DiffError, MAX_LINE_FUZZ, MIN_LINE_FUZZ, assertSliceRecordInvariant, buildDiff, classifyStatus, computeSlices, computeSymbolDelta, diffComponents, diffDependencies, dropDirection, jaccard, jaccardTokens, lastSegment, matchStageDroppedWeak, matchStageGitRename, matchStageId, matchStageLogicFingerprint, matchStageNameSignature, nameSimilarity, ownerSimilarity, signatureSimilarity, sliceAnchor, sliceRecordViolation, tokenizeName, writeCanonicalDiff };
 //# sourceMappingURL=index.mjs.map