@aburi/diff 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,2180 +1 @@
-import { RESERVED_LANGUAGE_IDS, computeWeaklyConnectedComponents, reconstructCallEdgesFromIR, serializeCanonical, trySymbolId } from "@aburi/core";
-
-//#region src/components.ts
-/**
-* `docs/design/diff-algorithm.md` §6.1 — Component diff. Assumes `components[].id` is unique on each side (ir-schema.md §14
-* #2) and does not check it: `buildDiff` establishes that before calling, and a caller
-* reaching this export directly owns the obligation, because the lookup map here is
-* last-write-wins and a repeat is lost rather than reported.
-*
-* Component identity is `id`; when a Component is present in both
-* base and head with the same id, the three delta booleans describe which axes actually
-* moved (roots reshuffle, public API globs, or framework hint list). `modified` deltas
-* are intentionally absent from this diff (diff-algorithm.md §5.2.3): fields are reported as before/after
-* pairs via the `changed[]` entries so consumers can render them without stringifying
-* arrays.
-*/
-function diffComponents(base, head) {
-	const baseById = /* @__PURE__ */ new Map();
-	for (const c of base) baseById.set(c.id, c);
-	const headById = /* @__PURE__ */ new Map();
-	for (const c of head) headById.set(c.id, c);
-	const added = [];
-	const removed = [];
-	const changed = [];
-	for (const [id, headComp] of headById) {
-		const baseComp = baseById.get(id);
-		if (baseComp === void 0) {
-			added.push(headComp);
-			continue;
-		}
-		const rootsChanged = !stringArraysEqual(baseComp.roots, headComp.roots);
-		const publicApiChanged = !stringArraysEqual(baseComp.publicApi ?? [], headComp.publicApi ?? []);
-		const frameworksChanged = !stringArraysEqual(baseComp.frameworks ?? [], headComp.frameworks ?? []);
-		if (rootsChanged || publicApiChanged || frameworksChanged) changed.push({
-			before: baseComp,
-			after: headComp,
-			delta: {
-				rootsChanged,
-				publicApiChanged,
-				frameworksChanged
-			}
-		});
-	}
-	for (const [id, baseComp] of baseById) if (!headById.has(id)) removed.push(baseComp);
-	sortById(added);
-	sortById(removed);
-	changed.sort((a, b) => a.after.id < b.after.id ? -1 : a.after.id > b.after.id ? 1 : 0);
-	return {
-		added,
-		removed,
-		changed
-	};
-}
-/**
-* Build a side view from a document. The only construction site there is.
-*
-* `buildDiff` reads `lostFiles` for its own Symbol classification too, from this same object,
-* so "a Symbol reported unknown and the edges it took with it cannot disagree about which file
-* went missing" is a property of the wiring rather than a claim in a comment.
-*
-* Exported because `DependencySideView` is public and `diffDependencies` requires one: without
-* a factory a caller would have to reproduce the `symbols[].source.file` keying and the
-* `stats.skippedFiles` read, and the likeliest outcome of that is a caller who gets it wrong.
-*/
-function dependencySideView(ir) {
-	const symbolFiles = /* @__PURE__ */ new Map();
-	for (const symbol of ir.symbols) symbolFiles.set(symbol.id, symbol.source.file);
-	const lostFiles = /* @__PURE__ */ new Map();
-	for (const file of ir.stats.skippedFiles ?? []) lostFiles.set(file.path, file.reason);
-	return {
-		symbolFiles,
-		lostFiles
-	};
-}
-/**
-* `docs/design/diff-algorithm.md` §6.2 — Dependency diff. Identity is the composite
-* `(from, to, via)` triple; direction and effect changes are surfaced as an added + removed
-* pair so `modified` is not part of the schema (§6.2 tail). Uniqueness of that triple is the caller's obligation on the same
-* terms as `diffComponents` above — a repeat here is indistinguishable in the output from
-* the flip it encodes.
-*
-* `sides` is what separates a deletion from a loss (`docs/design/diff-algorithm.md` §6.2.1).
-* It is required rather than optional: omitting it would classify every edge into a lost file
-* as a deletion again — silently, and while still writing `unknown: []`, which this schema
-* defines as "nothing was unknown" rather than "nobody looked". A caller with no skip list to
-* offer says so by passing a side view whose `lostFiles` is empty, which is the honest spelling
-* of an IR written before `stats.skippedFiles` existed.
-*
-* The return type declares `unknown` present, where the schema leaves it optional for documents
-* that predate the field. A reader may find it missing; this function always writes it.
-*/
-function diffDependencies(base, head, sides) {
-	const baseKeys = /* @__PURE__ */ new Map();
-	for (const d of base) baseKeys.set(dependencyKey(d), d);
-	const headKeys = /* @__PURE__ */ new Map();
-	for (const d of head) headKeys.set(dependencyKey(d), d);
-	const added = [];
-	const removed = [];
-	const unknown = [];
-	for (const [key, dep] of headKeys) {
-		const b = baseKeys.get(key);
-		if (b === void 0) {
-			const lostFiles = endpointsLostBy(dep, sides.head, sides.base);
-			if (lostFiles.length > 0) unknown.push({
-				dependency: dep,
-				absentFrom: "base",
-				lostFiles
-			});
-			else added.push(dep);
-			continue;
-		}
-		if (b.direction !== dep.direction || (b.effect ?? null) !== (dep.effect ?? null)) {
-			removed.push(b);
-			added.push(dep);
-		}
-	}
-	for (const [key, dep] of baseKeys) {
-		if (headKeys.has(key)) continue;
-		const lostFiles = endpointsLostBy(dep, sides.base, sides.head);
-		if (lostFiles.length > 0) unknown.push({
-			dependency: dep,
-			absentFrom: "head",
-			lostFiles
-		});
-		else removed.push(dep);
-	}
-	added.sort(compareDependencies);
-	removed.sort(compareDependencies);
-	unknown.sort((a, b) => compareDependencies(a.dependency, b.dependency));
-	return {
-		added,
-		removed,
-		unknown
-	};
-}
-/**
-* The endpoint files `absent` never analysed, read through `holder` because that is the
-* document the edge — and therefore the Symbol behind each endpoint — actually comes from.
-*
-* Both endpoints are checked: an edge dies when *either* end's file goes, including one whose
-* other end survived, and that half is the easiest to miss because the surviving Symbol is
-* right there in both documents.
-*
-* Deduped and sorted by path, so an intra-file edge collapses to the one file it lost.
-*/
-function endpointsLostBy(dep, holder, absent) {
-	const byPath = /* @__PURE__ */ new Map();
-	for (const endpoint of [dep.from, dep.to]) {
-		const file = holder.symbolFiles.get(endpoint);
-		if (file === void 0) continue;
-		const reason = absent.lostFiles.get(file);
-		if (reason === void 0) continue;
-		byPath.set(file, reason);
-	}
-	return [...byPath.entries()].map(([path, reason]) => ({
-		path,
-		reason
-	})).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-}
-/**
-* `docs/design/diff-algorithm.md` §6.2 — the fields Dependency identity is made of, in key order, and the join that turns
-* them into one. Both halves are exported so the entry-point uniqueness check keys on
-* exactly what this file keys on — a check with its own notion of identity would let through
-* the duplicates that actually collide here, and a check that shared only the join would
-* still be free to disagree about which fields identity is made of.
-*
-* Core's invariant #13 joins the same triple with a different separator. The two agree for
-* every endpoint that satisfies the id grammars of ir-schema.md §3.1 and §4, which is every
-* Document the integrity checker accepts; they could in principle disagree for one that does
-* not, and `buildDiff` runs no grammar check on the IRs it is handed.
-*/
-const DEPENDENCY_IDENTITY_FIELDS = [
-	"from",
-	"to",
-	"via"
-];
-function dependencyIdentity(parts) {
-	return parts.join("::");
-}
-function dependencyKey(d) {
-	return dependencyIdentity(DEPENDENCY_IDENTITY_FIELDS.map((field) => d[field]));
-}
-function compareDependencies(a, b) {
-	const keyA = dependencyKey(a);
-	const keyB = dependencyKey(b);
-	return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
-}
-function stringArraysEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
-function sortById(items) {
-	items.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-}
-
-//#endregion
-//#region src/errors.ts
-var DiffError = class extends Error {
-	code;
-	value;
-	constructor(message, detail, options) {
-		super(message, options);
-		this.name = "DiffError";
-		this.code = detail.code;
-		this.value = detail.value;
-	}
-};
-
-//#endregion
-//#region src/delta.ts
-const DEFAULT_LINE_FUZZ = 2;
-const MAX_LINE_FUZZ = 10;
-const MIN_LINE_FUZZ = 0;
-/**
-* §5 — Compute the full per-Symbol delta between two paired Symbols. The three axis
-* booleans (`apiChanged` / `logicChanged` / `syntaxChanged`) come from fingerprint
-* comparison; the array deltas (`rules` / `effects` / `calls` / `decorators`) come from
-* identity-preserving diff with configurable line fuzz.
-*/
-function computeSymbolDelta(base, head, options = {}) {
-	const fuzz = validateLineFuzz(options.lineFuzz ?? 2);
-	const delta = {
-		apiChanged: base.fingerprint.api !== head.fingerprint.api,
-		logicChanged: base.fingerprint.logic !== head.fingerprint.logic,
-		syntaxChanged: base.fingerprint.syntax !== head.fingerprint.syntax,
-		componentChanged: (base.component ?? null) !== (head.component ?? null),
-		visibilityChanged: base.visibility !== head.visibility
-	};
-	delta.rules = diffRules(base.rules, head.rules, fuzz);
-	delta.effects = diffEffects(base.effects, head.effects);
-	delta.calls = diffCalls(base.calls, head.calls, fuzz);
-	delta.decorators = diffDecorators(base.decorators, head.decorators, fuzz);
-	delta.signature = diffSignature(base.signature ?? null, head.signature ?? null);
-	return delta;
-}
-/**
-* §5.2.1 range check. Loud on violation rather than silently clamping so a config typo
-* (`lineFuzz: 999`) or an upstream numeric bug (`NaN`, `Infinity`) surfaces at the diff
-* boundary instead of quietly rounding into a range that produces the wrong deltas.
-*/
-function validateLineFuzz(value) {
-	if (!Number.isFinite(value) || !Number.isInteger(value)) throw new DiffError(`config.diff.lineFuzz must be an integer in [${0}, ${10}]; got ${String(value)}.`, {
-		code: "invalid-line-fuzz",
-		value: String(value)
-	});
-	if (value < 0 || value > 10) throw new DiffError(`config.diff.lineFuzz must be within [${0}, ${10}]; got ${value}.`, {
-		code: "invalid-line-fuzz",
-		value: String(value)
-	});
-	return value;
-}
-/**
-* §5.2 — pair the two sides by identity key within ±`lineFuzz`, then classify each element
-* into `added` / `removed` / `modified`. `modified` fires only when a pairing holds and the
-* content differs, so a cosmetic line shift produces nothing.
-*
-* Several elements of one Symbol routinely share a key — two `guard` rules, two calls to one
-* target, two `@Get` — so which base element a head element takes is a real choice. Two
-* passes make it: first the elements whose key **and content** agree, then whatever is left.
-* An untouched element is therefore claimed by its own counterpart before an edited or
-* deleted neighbour can take it, and the remainder pairs by proximity — where a genuine edit
-* lands. Taking the first key hit instead reported a deleted `guard@1` by removing its
-* untouched `guard@3` neighbour *and* listing that same neighbour as modified.
-*
-* Each pass is an order-preserving assignment rather than a per-element search, because a
-* greedy pass takes a pairing that leaves a better set unreachable. Two identical guards
-* shifted down two lines are the smallest case: the first head element is nearest to the
-* *second* base element, and claiming it strands the other head outside the window, so a
-* block that moved intact comes back as an `added` and a `removed`.
-*/
-function differentiate(base, head, isEqual, lineFuzz) {
-	const freeBase = new Set(base.map((_, index) => index));
-	const freeHead = new Set(head.map((_, index) => index));
-	const partnerOf = /* @__PURE__ */ new Map();
-	for (const contentMustAgree of [true, false]) {
-		const admits = (b, h) => b.key === h.key && Math.abs(b.line - h.line) <= lineFuzz && (!contentMustAgree || isEqual(b.item, h.item));
-		for (const [baseIndex, headIndex] of assignInOrder(base, head, freeBase, freeHead, admits)) {
-			freeBase.delete(baseIndex);
-			freeHead.delete(headIndex);
-			const counterpart = base[baseIndex];
-			if (counterpart !== void 0) partnerOf.set(headIndex, counterpart);
-		}
-	}
-	const added = [];
-	const modified = [];
-	for (const [index, h] of head.entries()) {
-		const counterpart = partnerOf.get(index);
-		if (counterpart === void 0) added.push(h.item);
-		else if (!isEqual(counterpart.item, h.item)) modified.push(h.item);
-	}
-	return {
-		added,
-		removed: base.filter((_, index) => freeBase.has(index)).map((b) => b.item),
-		modified
-	};
-}
-const NO_PAIRINGS = {
-	pairs: 0,
-	distance: 0
-};
-/** `a` is preferred over `b`: more pairings wins, and among equals the tighter one does. */
-function better(a, b) {
-	return a.pairs !== b.pairs ? a.pairs > b.pairs : a.distance < b.distance;
-}
-/**
-* The best set of non-crossing pairings between the still-free elements of `base` and `head`,
-* as `[baseIndex, headIndex]` in ascending order — most pairings first, then least total line
-* movement.
-*
-* Non-crossing is the whole content of the rule, and ir-schema §14 #11 is what licenses it:
-* these arrays are ordered by line, so `i < j` means element `i` sits above element `j` in the
-* file. Two pairings that cross would have an element move above one it was below, which is
-* not a line shift — it is a different element. Restricting to non-crossing sets also makes
-* the optimum reachable by a suffix recurrence rather than by a general assignment algorithm.
-*
-* Maximising the count before minimising distance is what stops a near pairing from being
-* taken at the cost of a far one that would otherwise have no partner at all.
-*/
-function assignInOrder(base, head, freeBase, freeHead, admits) {
-	const best = Array.from({ length: base.length + 1 }, () => Array.from({ length: head.length + 1 }, () => NO_PAIRINGS));
-	const pairingAt = (i, j) => {
-		const b = base[i];
-		const h = head[j];
-		if (b === void 0 || h === void 0) return null;
-		if (!freeBase.has(i) || !freeHead.has(j) || !admits(b, h)) return null;
-		const rest = best[i + 1]?.[j + 1] ?? NO_PAIRINGS;
-		return {
-			pairs: rest.pairs + 1,
-			distance: rest.distance + Math.abs(b.line - h.line)
-		};
-	};
-	for (let i = base.length - 1; i >= 0; i--) for (let j = head.length - 1; j >= 0; j--) {
-		const skipBase = best[i + 1]?.[j] ?? NO_PAIRINGS;
-		const skipHead = best[i]?.[j + 1] ?? NO_PAIRINGS;
-		let winner = better(skipBase, skipHead) ? skipBase : skipHead;
-		const paired = pairingAt(i, j);
-		if (paired !== null && better(paired, winner)) winner = paired;
-		const row = best[i];
-		if (row !== void 0) row[j] = winner;
-	}
-	const chosen = [];
-	let i = 0;
-	let j = 0;
-	while (i < base.length && j < head.length) {
-		const here = best[i]?.[j] ?? NO_PAIRINGS;
-		const paired = pairingAt(i, j);
-		if (paired !== null && paired.pairs === here.pairs && paired.distance === here.distance) {
-			chosen.push([i, j]);
-			i++;
-			j++;
-			continue;
-		}
-		const skipBase = best[i + 1]?.[j] ?? NO_PAIRINGS;
-		if (skipBase.pairs === here.pairs && skipBase.distance === here.distance) i++;
-		else j++;
-	}
-	return chosen;
-}
-function diffRules(base, head, lineFuzz) {
-	const mapper = (r) => ({
-		item: r,
-		key: r.type,
-		line: r.line
-	});
-	return differentiate(base.map(mapper), head.map(mapper), rulesEqual, lineFuzz);
-}
-function rulesEqual(a, b) {
-	return a.type === b.type && (a.condition ?? null) === (b.condition ?? null) && (a.what ?? null) === (b.what ?? null) && (a.expr ?? null) === (b.expr ?? null) && (a.loopKind ?? null) === (b.loopKind ?? null);
-}
-function diffEffects(base, head) {
-	const mapper = (e) => ({
-		item: e,
-		key: `${e.id}::${e.target}`,
-		line: e.line ?? 0
-	});
-	return differentiate(base.map(mapper), head.map(mapper), effectsEqual, Number.POSITIVE_INFINITY);
-}
-function effectsEqual(a, b) {
-	return a.id === b.id && a.target === b.target && a.plugin === b.plugin && a.confidence === b.confidence;
-}
-function diffCalls(base, head, lineFuzz) {
-	const mapper = (c) => ({
-		item: c,
-		key: c.target,
-		line: c.line
-	});
-	return differentiate(base.map(mapper), head.map(mapper), callsEqual, lineFuzz);
-}
-function callsEqual(a, b) {
-	return a.target === b.target && (a.resolved ?? null) === (b.resolved ?? null);
-}
-/**
-* §5.2.2 — decorator diff. Identity is `name`; when the same-named decorator is present
-* on both sides within the line-fuzz window, the argument list determines whether the
-* entry is a modified pair or an implicit no-op.
-*/
-function diffDecorators(base, head, lineFuzz) {
-	const mapper = (d) => ({
-		item: d,
-		key: d.name,
-		line: d.line
-	});
-	return differentiate(base.map(mapper), head.map(mapper), decoratorsEqual, lineFuzz);
-}
-function decoratorsEqual(a, b) {
-	if (a.name !== b.name) return false;
-	if (a.arguments.length !== b.arguments.length) return false;
-	for (let i = 0; i < a.arguments.length; i++) if (a.arguments[i] !== b.arguments[i]) return false;
-	return true;
-}
-/**
-* §5.3 — signature delta. Three cases:
-* - both sides `null` → `null` (nothing to compare)
-* - exactly one side `null` → the present side is emitted verbatim as
-*   `added` (when only head has a signature) or `removed` (when only base has one);
-*   the three axis booleans compare the missing side against `false` defaults
-* - both sides non-null → per-list sub-deltas:
-*   - `inputs`: strict positional compare via `differentiate(..., lineFuzz: 0)` — index
-*     used as the line key so ordered parameter lists match position-for-position
-*   - `outputs`: positional compare (added/removed emitted when the arrays diverge at
-*     an index), no `modified` category
-*   - `throws`: unordered set diff — duplicates collapse per Set semantics
-*   - `async` / `generator` / `typeParameters` change flags follow the raw fields
-*/
-function diffSignature(base, head) {
-	if (base === null && head === null) return null;
-	if (base === null || head === null) {
-		const empty = {
-			added: [],
-			removed: [],
-			modified: []
-		};
-		const present = base ?? head;
-		if (present === null) return null;
-		const isBaseNull = base === null;
-		return {
-			inputs: isBaseNull ? {
-				added: [...present.inputs],
-				removed: [],
-				modified: []
-			} : {
-				added: [],
-				removed: [...present.inputs],
-				modified: []
-			},
-			outputs: isBaseNull ? {
-				added: [...present.outputs],
-				removed: [],
-				modified: []
-			} : {
-				added: [],
-				removed: [...present.outputs],
-				modified: []
-			},
-			throws: isBaseNull ? {
-				added: [...present.throws],
-				removed: [],
-				modified: []
-			} : {
-				added: [],
-				removed: [...present.throws],
-				modified: []
-			},
-			asyncChanged: (base?.async ?? false) !== (head?.async ?? false),
-			generatorChanged: (base?.generator ?? false) !== (head?.generator ?? false),
-			typeParametersChanged: !arraysEqual(base?.typeParameters ?? empty.added.map(String), head?.typeParameters ?? empty.added.map(String))
-		};
-	}
-	/**
-	* Parameters are positional, so the index is part of the identity and the fuzz below is 0.
-	* That makes each key unique within its list, so §5.2.0 never has a choice to make here and
-	* both of its passes reduce to the same positional comparison. Dropping the index from the
-	* key would make two same-named parameters ambiguous and hand the choice back to §5.2.0,
-	* which is not what a positional list wants.
-	*/
-	const inputMapper = (input, index) => ({
-		item: input,
-		key: `${index}:${input.name}`,
-		line: index
-	});
-	return {
-		inputs: differentiate(base.inputs.map(inputMapper), head.inputs.map(inputMapper), (a, b) => a.name === b.name && a.type === b.type, 0),
-		outputs: diffStringList(base.outputs, head.outputs),
-		throws: diffStringSet(base.throws, head.throws),
-		asyncChanged: base.async !== head.async,
-		generatorChanged: base.generator !== head.generator,
-		typeParametersChanged: !arraysEqual(base.typeParameters, head.typeParameters)
-	};
-}
-function diffStringList(base, head) {
-	const added = [];
-	const removed = [];
-	const max = Math.max(base.length, head.length);
-	for (let i = 0; i < max; i++) {
-		const b = i < base.length ? base[i] : void 0;
-		const h = i < head.length ? head[i] : void 0;
-		if (b === void 0 && h !== void 0) added.push(h);
-		else if (h === void 0 && b !== void 0) removed.push(b);
-		else if (b !== h) {
-			if (b !== void 0) removed.push(b);
-			if (h !== void 0) added.push(h);
-		}
-	}
-	return {
-		added,
-		removed,
-		modified: []
-	};
-}
-function diffStringSet(base, head) {
-	const setB = new Set(base);
-	const setH = new Set(head);
-	const added = [];
-	const removed = [];
-	for (const h of setH) if (!setB.has(h)) added.push(h);
-	for (const b of setB) if (!setH.has(b)) removed.push(b);
-	return {
-		added,
-		removed,
-		modified: []
-	};
-}
-function arraysEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
-
-//#endregion
-//#region src/signature.ts
-/**
-* §3.4.2 signatureSimilarity — averaged type-similarity across `inputs`, `outputs`, and
-* `throws`. Follows diff-algorithm.md §3.4.2:
-* - null + null    → 1.0 (both symbols are signature-less; nothing to compare)
-* - null + non-null (either side) → 0.0
-* - both non-null: mean of three subscores
-*
-* Subscores:
-* - inputs: ordered type-string equality rate (`i-th type equal` counts as 1, else 0)
-* - outputs: same shape, but outputs is an array of type strings
-* - throws: unordered set intersection over union
-*
-* Empty subarrays on both sides count as 1.0 (they are trivially equal); on one side only
-* they count as 0.0 (asymmetric information).
-*/
-function signatureSimilarity(base, head) {
-	const baseSig = base ?? null;
-	const headSig = head ?? null;
-	if (baseSig === null && headSig === null) return 1;
-	if (baseSig === null || headSig === null) return 0;
-	const inputsScore = compareOrderedTypes(baseSig.inputs.map((i) => i.type), headSig.inputs.map((i) => i.type));
-	const outputsScore = compareOrderedTypes(baseSig.outputs, headSig.outputs);
-	const throwsScore = compareUnorderedSet(baseSig.throws, headSig.throws);
-	return (inputsScore + outputsScore + throwsScore) / 3;
-}
-function compareOrderedTypes(a, b) {
-	if (a.length === 0 && b.length === 0) return 1;
-	if (a.length !== b.length) return 0;
-	let matches = 0;
-	for (let i = 0; i < a.length; i++) if (a[i] === b[i]) matches++;
-	return matches / a.length;
-}
-function compareUnorderedSet(a, b) {
-	if (a.length === 0 && b.length === 0) return 1;
-	const setA = new Set(a);
-	const setB = new Set(b);
-	let intersection = 0;
-	for (const t of setA) if (setB.has(t)) intersection++;
-	const union = setA.size + setB.size - intersection;
-	return union === 0 ? 1 : intersection / union;
-}
-
-//#endregion
-//#region src/similarity.ts
-/**
-* String similarity utilities dedicated to the diff engine. Kept in one file so the
-* name/signature/owner formulas are auditable side by side against diff-algorithm.md §3.4.
-*/
-/**
-* Tokenise a qualified name into normalised lowercase word segments. Splits on:
-* - camelCase / PascalCase boundaries (`fooBar` → `foo`, `Bar`)
-* - snake_case underscores (`foo_bar` → `foo`, `bar`)
-* - dotted namespaces (`ns.Class` → `ns`, `Class`)
-* - `::` static-method separator (`Class::method` → `Class`, `method`)
-* - runs of digits (`get2Users` → `get`, `2`, `Users`)
-*
-* The result is de-duplicated so `InvoiceService.createInvoice` collapses to
-* `["invoice", "service", "create"]` — Jaccard similarity relies on set semantics, so
-* repeated tokens must not double-count.
-*
-* **The camel boundary is ASCII.** `isCamelBoundary` compares code points against `a`–`z`,
-* `A`–`Z` and `0`–`9`, so a name written in a script with no ASCII case boundary and no
-* separator comes back whole: `获取用户信息` and `ユーザー情報を取得する` are one token each,
-* and so is `получитьПользователя` — its camel hump does not register. A separator still
-* splits (`ユーザー.取得` gives two), and a mixed name splits on its ASCII half.
-*
-* That makes the token count a poor measure of how much such a name says, which matters
-* wherever a count is read as a proxy for that — see §3.4.3's admissibility rule.
-*/
-function tokenizeName(input) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const raw of input.split(/[.:_\-\s/]+/)) {
-		if (raw.length === 0) continue;
-		for (const piece of splitCamel(raw)) {
-			const norm = piece.toLowerCase();
-			if (norm.length === 0 || seen.has(norm)) continue;
-			seen.add(norm);
-			out.push(norm);
-		}
-	}
-	return out;
-}
-function splitCamel(word) {
-	const chunks = [];
-	let current = "";
-	for (const ch of word) {
-		if (current === "") {
-			current = ch;
-			continue;
-		}
-		if (isCamelBoundary(current.slice(-1), ch)) {
-			chunks.push(current);
-			current = ch;
-		} else current += ch;
-	}
-	if (current.length > 0) chunks.push(current);
-	return chunks;
-}
-function isCamelBoundary(prev, curr) {
-	const prevLower = prev >= "a" && prev <= "z";
-	const prevUpper = prev >= "A" && prev <= "Z";
-	const prevDigit = prev >= "0" && prev <= "9";
-	const currLower = curr >= "a" && curr <= "z";
-	const currUpper = curr >= "A" && curr <= "Z";
-	const currDigit = curr >= "0" && curr <= "9";
-	if (prevLower && currUpper) return true;
-	if ((prevLower || prevUpper) && currDigit) return true;
-	if (prevDigit && (currLower || currUpper)) return true;
-	return false;
-}
-/**
-* Jaccard similarity between two token multisets. Formula: |A ∩ B| / |A ∪ B|.
-* Empty on both sides returns 1.0 (both are "no tokens", which are equivalent for the
-* purpose of §3.4.1). Empty on one side only returns 0.0.
-*/
-function jaccard(a, b) {
-	return jaccardSets(new Set(a), new Set(b));
-}
-function jaccardSets(a, b) {
-	if (a.size === 0 && b.size === 0) return 1;
-	if (a.size === 0 || b.size === 0) return 0;
-	const [small, large] = a.size <= b.size ? [a, b] : [b, a];
-	let intersection = 0;
-	for (const token of small) if (large.has(token)) intersection++;
-	return intersection / (a.size + b.size - intersection);
-}
-/**
-* Jaccard over the tokens of two strings. Part of the module's surface rather than an
-* internal shortcut: the two formulas below go through a token table they share for one
-* matching pass, so this has no caller inside this file.
-*/
-function jaccardTokens(a, b) {
-	return jaccard(tokenizeName(a), tokenizeName(b));
-}
-const tokenizeEveryTime = (value) => new Set(tokenizeName(value));
-/**
-* §3.4.1 — Jaccard over the tokens of the full qualified name. The last segment is not
-* given extra weight; the entire path contributes uniformly because the intersection is
-* what the score should reward.
-*/
-function nameSimilarity(baseName, headName) {
-	return nameFormula(tokenizeEveryTime, baseName, headName);
-}
-/**
-* §3.4.1 — Jaccard over the tokens of the **last segment**: the member name with its owner
-* removed. What §3.4's composite reads, because §3.4.6 decides the owner separately and
-* reading it on both axes charges for it twice.
-*/
-function memberSimilarity(baseName, headName) {
-	return memberFormula(tokenizeEveryTime, baseName, headName);
-}
-/**
-* §3.4.6 (R-8) — whether two Symbols are close enough in *scope* to be the same Symbol: the
-* same owner, or one whose owner was renamed. A gate rather than a score, because grading the
-* owner cannot do what R-8 asks. `UserRepo.findById` and `AdminRepo.findById` agree on their
-* member name and their signature, so a shared `Repo` token at weight 0.2 carries them to
-* 0.8667 against a 0.85 threshold — while `UsersRepository.findById`, which *is* the rename,
-* shares no owner token and scores 0.8000. The collision outscores the rename, and raising the
-* weight only moves both: at 0.3 two three-token class names sharing two tokens land on
-* exactly 0.85.
-*
-* Owner extraction:
-* - `Class::method` → `Class`
-* - `A.B.C.method` → `A.B.C`
-* - `topLevel`     → `` (empty)
-*
-* Two empty owners are compatible: top-level Symbols share the one outer scope. One empty and
-* one not are never compatible — the two live at different depths.
-*
-* Otherwise the owners must correspond segment for segment, and within a segment every token
-* on each side must find a distinct partner on the other under `sameWord`. Both sides must be
-* covered, so `UserRepo` and `UserRepoV2` are two classes rather than one renamed — an added
-* token is as much evidence of a sibling as of a rename, and R-8's business is refusing the
-* collision.
-*/
-function ownersAreCompatible(baseName, headName) {
-	return ownerGate(tokenizeEveryTime, baseName, headName);
-}
-/**
-* §3.4.6 — the tokens `a` and `b` name the same thing.
-*
-* Equal, or the same word inflected: `user`/`users`, `entity`/`entities`. Nothing else, and
-* that is the whole of the rule rather than a first approximation.
-*
-* A bare prefix test is the obvious generalisation and it cannot be made to work. It admits
-* `repo`/`report`, `cache`/`cached`, `con`/`controller` — two distinct classes, which is
-* exactly the collision R-8 exists to refuse. Every measure that might separate those from a
-* real rename fails, because the two populations interleave rather than sitting on opposite
-* sides of anything:
-*
-* ```
-*                              dice    levenshtein
-*   accept  UserRepo/UsersRepository   0.571   7
-*   reject  RepoManager/ReportManager  0.818   2
-*   accept  Repo/Repository            0.500   6
-*   reject  CacheStore/CachedStore     0.842   1
-* ```
-*
-* The renames to accept score *lower* than the collisions to refuse, on both. There is no
-* threshold, and a length-growth rule fares no better: `con`→`controller` grows by 7 and
-* `user`→`users` by 1, so anything admitting the second admits the first.
-*
-* Inflection is not on that spectrum. It is a closed, mechanical relation between two spellings
-* of one word, so it can be recognised rather than estimated — and it covers the case a plain
-* equality test misses most often, a class pluralised in place.
-*
-* What this gives up is the abbreviation family: `UserRepo` → `UsersRepository` no longer
-* clears the gate on `repo`/`repository`. That is a real rename reported as `added` +
-* `removed`, and §3.4.6 records it as the price of refusing `repo`/`report`, which no rule
-* over the two strings alone can tell apart. The evidence that would settle it is not in the
-* strings: the owner is itself a Symbol, and whether *it* paired is the question being
-* guessed at here.
-*/
-function sameWord(a, b) {
-	if (a === b) return true;
-	const [short, long] = a.length <= b.length ? [a, b] : [b, a];
-	return pluralises(short, long);
-}
-/**
-* The longest owner segment the matching will search.
-*
-* `augment` is Kuhn's, so the search is cubic in the token count and recursive with it. A
-* class name is a handful of words; anything past this is not a name the gate has an opinion
-* about, and `buildDiff` takes IR JSON from a caller rather than only from `aburi scan`, so
-* the bound is what turns an adversarial 1600-token identifier from a hang into an answer.
-* Refusing is the safe direction: the pair falls to `added` + `removed`.
-*/
-const MAX_OWNER_SEGMENT_TOKENS = 32;
-/** English noun inflection, which is what a pluralised class name goes through. */
-function pluralises(singular, plural) {
-	if (plural === `${singular}s` || plural === `${singular}es`) return true;
-	return singular.endsWith("y") && plural === `${singular.slice(0, -1)}ies`;
-}
-function nameFormula(setOf, baseName, headName) {
-	return jaccardSets(setOf(baseName), setOf(headName));
-}
-function memberFormula(setOf, baseName, headName) {
-	return jaccardSets(setOf(lastSegment(baseName)), setOf(lastSegment(headName)));
-}
-function ownerGate(setOf, baseName, headName) {
-	const baseOwner = extractOwner(baseName);
-	const headOwner = extractOwner(headName);
-	if (baseOwner === "" && headOwner === "") return true;
-	if (baseOwner === "" || headOwner === "") return false;
-	if (baseOwner === headOwner) return true;
-	return segmentsCorrespond(baseOwner, headOwner, setOf);
-}
-/**
-* §3.4.6 — the two owners name the same scope: segment for segment, token for token.
-*
-* Compared per segment rather than over the owner as a whole, because `tokenizeName` dedups
-* and an owner is a *path*. `Users.UserRepo` collapses to `{users, user, repo}` while
-* `Users.UsersRepository` collapses to `{users, repository}` — the namespace and the class
-* share a word, so one side loses a token and the two stop being comparable before any
-* spelling is looked at. Segment by segment they line up: `Users`/`Users`, then
-* `UserRepo`/`UsersRepository`.
-*
-* A rename changes what a class is called, not how deeply it is nested, so a differing segment
-* count is a differing scope.
-*/
-function segmentsCorrespond(baseOwner, headOwner, setOf) {
-	const baseSegments = baseOwner.split(".");
-	const headSegments = headOwner.split(".");
-	if (baseSegments.length !== headSegments.length) return false;
-	return baseSegments.every((segment, index) => {
-		const counterpart = headSegments[index];
-		if (counterpart === void 0) return false;
-		if (segment === counterpart) return true;
-		return coversBothWays(setOf(segment), setOf(counterpart));
-	});
-}
-/**
-* Whether the two token sets admit a perfect matching under `sameWord`.
-*
-* Sizes must agree, after which an injection from one side is a bijection — so only one
-* direction is searched. The search is augmenting-path rather than greedy, because a greedy
-* pass can strand a token a different choice would have matched: over `{user, users}` and
-* `{user, userx}`, taking the identical pair first leaves `users` with nothing, though
-* `user`→`userx` with `users`→`user` covers both. One segment runs to a handful of tokens, so
-* the exact answer costs nothing worth saving.
-*/
-function coversBothWays(a, b) {
-	if (a.size !== b.size) return false;
-	if (a.size > MAX_OWNER_SEGMENT_TOKENS) return false;
-	const right = [...b];
-	const partnerOf = /* @__PURE__ */ new Map();
-	for (const token of a) if (!augment(token, right, partnerOf, /* @__PURE__ */ new Set())) return false;
-	return true;
-}
-/** Kuhn's step: claim a free partner for `token`, or displace one that can move on. */
-function augment(token, right, partnerOf, visited) {
-	for (const candidate of right) {
-		if (visited.has(candidate) || !sameWord(token, candidate)) continue;
-		visited.add(candidate);
-		const holder = partnerOf.get(candidate);
-		if (holder === void 0 || augment(holder, right, partnerOf, visited)) {
-			partnerOf.set(candidate, token);
-			return true;
-		}
-	}
-	return false;
-}
-/**
-* §3.4.6 — a necessary condition on two non-empty owners, cheaper than the full gate: their
-* first segments must correspond, since segments are compared positionally.
-*
-* A filter, not a decision. It relaxes `coversBothWays`' perfect matching to "every token
-* finds some partner", so it can only ever admit more than the gate does; answering `true`
-* says the gate has to be asked. Loosening it further costs correctness nothing and speed a
-* little — refusing something the gate would accept is the direction that would break recall.
-*/
-function firstSegmentsCouldAgree(baseOwner, headOwner, setOf) {
-	const baseFirst = baseOwner.slice(0, dotOrEnd(baseOwner));
-	const headFirst = headOwner.slice(0, dotOrEnd(headOwner));
-	if (baseFirst === headFirst) return true;
-	const baseTokens = setOf(baseFirst);
-	const headTokens = setOf(headFirst);
-	if (baseTokens.size !== headTokens.size) return false;
-	if (baseTokens.size > MAX_OWNER_SEGMENT_TOKENS) return false;
-	for (const token of baseTokens) {
-		let partnered = false;
-		for (const candidate of headTokens) if (sameWord(token, candidate)) {
-			partnered = true;
-			break;
-		}
-		if (!partnered) return false;
-	}
-	return true;
-}
-function dotOrEnd(owner) {
-	const dot = owner.indexOf(".");
-	return dot < 0 ? owner.length : dot;
-}
-/**
-* A scorer that tokenises each distinct name once.
-*
-* Stage 4 scores every (base, head) pair in a bucket, so a bucket of K on each side asks for
-* K² similarities over 2K distinct names — tokenising on every call splits the same strings
-* into the same tokens hundreds of thousands of times. The table lives for one call rather
-* than for the process, because the names it holds are only the ones that pass is comparing.
-*/
-function createNameScorer() {
-	const sets = /* @__PURE__ */ new Map();
-	const setOf = (value) => {
-		const cached = sets.get(value);
-		if (cached !== void 0) return cached;
-		const built = new Set(tokenizeName(value));
-		sets.set(value, built);
-		return built;
-	};
-	const owners = /* @__PURE__ */ new Map();
-	const ownerOf = (qname) => {
-		const cached = owners.get(qname);
-		if (cached !== void 0) return cached;
-		const built = extractOwner(qname);
-		owners.set(qname, built);
-		return built;
-	};
-	/**
-	* §3.4.6's gate, with the segment split and the matching skipped where they can be.
-	*
-	* The gate is the costliest thing stage 4 asks per candidate — it splits both owners into
-	* segments, tokenises each and runs an augmenting-path matching. Two shortcuts, in order of
-	* how much they save:
-	*
-	* - **Identical owners.** A bucket of methods on one class asks about the same owner over
-	*   and over, and `ownerGate` already answers those on a string compare; doing it here skips
-	*   the two `extractOwner` calls as well, which are substrings on every candidate.
-	* - **A different first segment.** Segments correspond positionally, so owners whose first
-	*   segments cannot be the same word are incompatible whatever the rest says. The check is
-	*   one `sameWord` over two token sets the table already holds, against a full matching over
-	*   every segment.
-	*
-	* Not memoised on the pair. A bulk rename produces as many distinct owner pairs as
-	* candidates, so a table keyed on them grows with the cross-product — enough to exceed
-	* V8's Map limit on the very input this is meant to make fast.
-	*/
-	const compatible = (baseName, headName) => {
-		const baseOwner = ownerOf(baseName);
-		const headOwner = ownerOf(headName);
-		if (baseOwner === headOwner) return true;
-		if (baseOwner === "" || headOwner === "") return false;
-		if (!firstSegmentsCouldAgree(baseOwner, headOwner, setOf)) return false;
-		return segmentsCorrespond(baseOwner, headOwner, setOf);
-	};
-	return {
-		name: (baseName, headName) => nameFormula(setOf, baseName, headName),
-		member: (baseName, headName) => memberFormula(setOf, baseName, headName),
-		ownersCompatible: compatible
-	};
-}
-function extractOwner(qname) {
-	const staticIdx = qname.indexOf("::");
-	if (staticIdx >= 0) return qname.slice(0, staticIdx);
-	const lastDot = qname.lastIndexOf(".");
-	if (lastDot >= 0) return qname.slice(0, lastDot);
-	return "";
-}
-/** §3.4.1 tail note — used by drop-4.5 weak matcher and threshold lookup. */
-function lastSegment(qname) {
-	const staticIdx = qname.indexOf("::");
-	if (staticIdx >= 0) return qname.slice(staticIdx + 2);
-	const lastDot = qname.lastIndexOf(".");
-	if (lastDot >= 0) return qname.slice(lastDot + 1);
-	return qname;
-}
-
-//#endregion
-//#region src/match.ts
-/** Fingerprint for the 12-hex-char "everything zero" (i.e. dropped) canonical hash. */
-const ZERO_LOGIC_FP = "000000000000";
-/** §3.3 — the similarity a multi-candidate logic-fingerprint group must reach to pair. */
-const NAME_DISAMBIGUATION_THRESHOLD = .85;
-/**
-* §3.8 — accept candidate pairings highest score first, taking each base and each head at
-* most once. Stages 3, 4 and 4.5 all choose from a set of possible pairings, and all three
-* used to decide one head at a time — which let an earlier head consume a base that was a
-* later head's exact match, and reported the loser as `added` beside the pair it lost.
-*
-* The two id sets come back with the pairings because every caller needs them to work out
-* what is left over, and deriving them again at the call site is a chance to derive the
-* wrong one: reading the head ids out as the base ids typechecks, and reproduces the very
-* symptom this exists to prevent.
-*
-* Not free, and §8.2 carries the bound: `candidates` is every pairing that clears its
-* threshold, so this holds O(base × head) records for stages 3 and 4 in the worst case where
-* the per-head loop it replaced held one, and sorting them is O(C log C). Stage 4 buys that
-* back and more with `createNameScorer`.
-*
-* It is not an optimal assignment — a greedy sweep can still strand a pair whose partners
-* were both taken by higher-scoring ones — but it never passes over the best available
-* pairing, which is the case that shows up in a review as one symbol appearing twice.
-*
-* Stage 4.5 does not call this, because that licence is what it cannot borrow: §3.4.5's
-* candidates are all worth the same, so no pairing is the best available and stranding one
-* buys nothing. See `bestPairing`.
-*/
-function acceptInScoreOrder(candidates) {
-	candidates.sort(compareCandidates);
-	const baseIds = /* @__PURE__ */ new Set();
-	const headIds = /* @__PURE__ */ new Set();
-	const pairs = [];
-	for (const candidate of candidates) {
-		if (baseIds.has(candidate.base.id) || headIds.has(candidate.head.id)) continue;
-		baseIds.add(candidate.base.id);
-		headIds.add(candidate.head.id);
-		pairs.push(candidate);
-	}
-	return {
-		pairs,
-		baseIds,
-		headIds
-	};
-}
-/**
-* Highest score first, then `(base.id, head.id)` ascending. The two id keys are what make
-* the order total, and they are a total order only because ids are unique within a Document
-* (ir-schema.md §14 #1), which `buildDiff` establishes before the first stage runs. Without
-* them equal scores resolve to enumeration order, and the diff stops being a function of the
-* two Documents.
-*/
-function compareCandidates(a, b) {
-	if (a.score !== b.score) return b.score - a.score;
-	if (a.base.id !== b.base.id) return a.base.id < b.base.id ? -1 : 1;
-	return a.head.id < b.head.id ? -1 : a.head.id > b.head.id ? 1 : 0;
-}
-/** The entries of `symbols` that no accepted pairing claimed, in their original order. */
-function unclaimed(symbols, claimed) {
-	return symbols.filter((symbol) => !claimed.has(symbol.id));
-}
-/**
-* §3.1 — segments Symbols with identical `id` into paired matches. Runs first because it
-* is the highest-confidence signal (no heuristics, just hash lookup).
-*
-* Assumes `id` is unique on each side (ir-schema.md §14 #1) and does not check it:
-* `buildDiff` establishes that before calling, and a caller reaching this export directly
-* owns the obligation. A repeat on the head side loses all but the last entry to the lookup
-* map and then removes every one of them from `remainingHead`; a repeat on the base side
-* pairs the same head Symbol more than once. The later stages track consumed base Symbols
-* by id and lose a repeat the same way.
-*/
-function matchStageId(base, head) {
-	const headById = /* @__PURE__ */ new Map();
-	for (const s of head) headById.set(s.id, s);
-	const matched = [];
-	const remainingBase = [];
-	const usedHead = /* @__PURE__ */ new Set();
-	for (const b of base) {
-		const h = headById.get(b.id);
-		if (h !== void 0) {
-			matched.push({
-				base: b,
-				head: h,
-				rationale: "id-match"
-			});
-			usedHead.add(b.id);
-		} else remainingBase.push(b);
-	}
-	return {
-		matched,
-		remainingBase,
-		remainingHead: head.filter((h) => !usedHead.has(h.id))
-	};
-}
-/**
-* §3.2 — git rename detection. When a rename map is available (typical of ref-driven
-* scans), rewrite the base id with the head-side file path and look for a hit. Two base
-* files renamed onto one target predict the same head id, so the claimants are collected
-* before one is chosen.
-*
-* The rewriter only touches the `file` portion of the id — the `<language>:` prefix and
-* the trailing `#<qualified-name>` segment stay unchanged so a moved file with the same
-* qualified name is picked up correctly. When a Symbol's file is not in the rename map,
-* it is left for later stages.
-*/
-function matchStageGitRename(remainingBase, remainingHead, renameMap) {
-	if (renameMap === null || renameMap.size === 0) return {
-		matched: [],
-		remainingBase: [...remainingBase],
-		remainingHead: [...remainingHead]
-	};
-	const headById = /* @__PURE__ */ new Map();
-	for (const h of remainingHead) headById.set(h.id, h);
-	const claimants = /* @__PURE__ */ new Map();
-	for (const b of remainingBase) {
-		const newPath = renameMap.get(b.source.file);
-		if (newPath === void 0) continue;
-		const expectedId = rewriteIdFile(b.id, b.source.file, newPath);
-		if (expectedId === null) continue;
-		const head = headById.get(expectedId);
-		if (head === void 0) continue;
-		const claim = claimants.get(expectedId);
-		if (claim === void 0) claimants.set(expectedId, {
-			head,
-			bases: [b]
-		});
-		else claim.bases.push(b);
-	}
-	const matched = [];
-	const usedBase = /* @__PURE__ */ new Set();
-	const usedHead = /* @__PURE__ */ new Set();
-	for (const { head, bases } of claimants.values()) {
-		const base = lowestId(bases);
-		matched.push({
-			base,
-			head,
-			rationale: "git-rename"
-		});
-		usedBase.add(base.id);
-		usedHead.add(head.id);
-	}
-	return {
-		matched,
-		remainingBase: unclaimed(remainingBase, usedBase),
-		remainingHead: unclaimed(remainingHead, usedHead)
-	};
-}
-/** Total on the non-empty claim lists above: a claim is created holding its first base. */
-function lowestId(symbols) {
-	let lowest = symbols[0];
-	for (const symbol of symbols) if (symbol.id < lowest.id) lowest = symbol;
-	return lowest;
-}
-/**
-* 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;
-	if (id.slice(colon + 1, hash) !== oldPath) return id;
-	return trySymbolId({
-		language: id.slice(0, colon),
-		file: newPath,
-		qualifiedName: id.slice(hash + 1)
-	});
-}
-/**
-* §3.3 — group both sides by `fingerprint.logic` and pair within each group. Two branches:
-* - single base candidate → paired with `logic-fingerprint`, no similarity test
-* - several → `nameSimilarity` disambiguates at ≥ 0.85; a group that cannot reach it is left
-*   whole for stage 4 to re-evaluate
-*
-* Dropped symbols are excluded (§3.3 tail) — their logic fingerprint is the sentinel
-* `"000000000000"` and would collide with every other dropped Symbol in the workspace.
-* They flow to the stage-4.5 weak matcher instead.
-*/
-function matchStageLogicFingerprint(remainingBase, remainingHead) {
-	const baseGroups = groupByLogic(remainingBase);
-	const headGroups = groupByLogic(remainingHead);
-	const scorer = createNameScorer();
-	const matched = [];
-	for (const [logic, heads] of headGroups) {
-		const bases = baseGroups.get(logic);
-		if (bases === void 0) continue;
-		matched.push(...pairWithinLogicGroup(bases, heads, scorer));
-	}
-	const usedBase = new Set(matched.map((pair) => pair.base.id));
-	const usedHead = new Set(matched.map((pair) => pair.head.id));
-	return {
-		matched,
-		remainingBase: unclaimed(remainingBase, usedBase),
-		remainingHead: unclaimed(remainingHead, usedHead)
-	};
-}
-/**
-* Symbols by logic fingerprint, skipping the ones §3.3 excludes. Both sides are grouped, so
-* a group is a self-contained problem: the Symbols in it can only pair with each other, and
-* no group’s outcome depends on any other’s.
-*/
-function groupByLogic(symbols) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const symbol of symbols) {
-		if (symbol.dropped || symbol.fingerprint.logic === ZERO_LOGIC_FP) continue;
-		const bucket = groups.get(symbol.fingerprint.logic) ?? [];
-		bucket.push(symbol);
-		groups.set(symbol.fingerprint.logic, bucket);
-	}
-	return groups;
-}
-/**
-* §3.3’s two branches, over one logic-fingerprint group.
-*
-* A lone base candidate pairs with no similarity test — identical logic is taken as proof on
-* its own. With more than one, names disambiguate and a group that cannot reach the
-* threshold is left whole for stage 4.
-*
-* The loop is what keeps the second branch feeding the first: a scored round that consumes
-* all but one base leaves that one unconditional, which is how the per-head version behaved
-* when its candidate list shrank to a single entry.
-*/
-function pairWithinLogicGroup(bases, heads, scorer) {
-	let freeBase = [...bases];
-	let freeHead = [...heads];
-	const matched = [];
-	while (freeBase.length > 0 && freeHead.length > 0) {
-		const lone = freeBase.length === 1 ? freeBase[0] : void 0;
-		if (lone !== void 0) {
-			const head = closestNameTo(lone, freeHead, scorer);
-			if (head === void 0) break;
-			matched.push({
-				base: lone,
-				head,
-				rationale: "logic-fingerprint"
-			});
-			break;
-		}
-		const candidates = [];
-		for (const base of freeBase) for (const head of freeHead) {
-			const score = scorer.name(base.name, head.name);
-			if (score >= NAME_DISAMBIGUATION_THRESHOLD) candidates.push({
-				base,
-				head,
-				score
-			});
-		}
-		const accepted = acceptInScoreOrder(candidates);
-		if (accepted.pairs.length === 0) break;
-		for (const { base, head } of accepted.pairs) matched.push({
-			base,
-			head,
-			rationale: "logic-fingerprint+name-disambiguation"
-		});
-		freeBase = unclaimed(freeBase, accepted.baseIds);
-		freeHead = unclaimed(freeHead, accepted.headIds);
-	}
-	return matched;
-}
-/**
-* The head whose name is closest to `base`, ties going to the lower id. The lone-candidate
-* branch pairs whatever it is given, so this only decides *which* head it takes — but that
-* decision was array order, and it is visible in the diff.
-*/
-function closestNameTo(base, heads, scorer) {
-	let best;
-	for (const head of heads) {
-		const score = scorer.name(base.name, head.name);
-		if (best === void 0 || score > best.score) {
-			best = {
-				head,
-				score
-			};
-			continue;
-		}
-		if (score === best.score && head.id < best.head.id) best = {
-			head,
-			score
-		};
-	}
-	return best?.head;
-}
-/**
-* §3.4 — name + signature similarity with `(kind, signatureNullness)` bucket pre-filter.
-* `signatureNullness` distinguishes symbols with no signature (`interface`, `type`,
-* `class`) from callable ones so that a class body is never paired against a function.
-*
-* §3.4.6's owner gate runs before the score: a pair whose owners are not the same class, or
-* one a rename of the other, is not the same Symbol however well the rest agrees, and no
-* weight small enough to leave the name axis meaning something can outvote a matching member
-* name and signature.
-*
-* The composite score, over the pairs that clear it:
-*   0.5 * memberSimilarity + 0.3 * signatureSimilarity + 0.2 * OWNER_AXIS_SATISFIED
-*
-* `memberSimilarity` reads the last segment, not the whole qualified name: the gate has
-* already settled the owner, and reading it again on the name axis charges for it twice —
-* which is what kept a renamed class from ever pairing (§3.4.6).
-*
-* §3.4.3 threshold table, applied per head by the token count of its last name segment:
-* - 1 token  → 1.0 (an exact match on both remaining axes)
-* - 2 tokens → 0.95 (strict, avoids `getUser` vs `getUsers`)
-* - default  → 0.85
-*
-* §3.4.3 also names two Symbols the stage does not read at all, because for them the score is
-* high on evidence it does not have rather than on a resemblance: one whose signature is
-* null, since `signatureSimilarity(null, null)` is 1.0 and the bucket key restricts it to
-* candidates that are equally signature-less; and one whose qualified name carries a single
-* distinct token, since that is the whole of what its identity amounts to. Neither can be
-* expressed as a threshold — the second wants a bar above the top of the scale.
-*
-* Every pairing in a bucket that clears its head’s threshold becomes a candidate, and the
-* candidates are settled in score order rather than one head at a time — see
-* `acceptInScoreOrder`. That doubles the pairings scored, from a bucket that shrank as heads
-* consumed it to the full bucket every time; `createNameScorer` more than pays for it by
-* tokenising each distinct name once per pass instead of once per comparison.
-*/
-function matchStageNameSignature(remainingBase, remainingHead) {
-	const buckets = /* @__PURE__ */ new Map();
-	for (const b of remainingBase) {
-		if (b.dropped) continue;
-		if (!saysEnoughToPair(b.name)) continue;
-		const key = bucketKey(b);
-		const bucket = buckets.get(key) ?? {
-			members: [],
-			byToken: /* @__PURE__ */ new Map()
-		};
-		const position = bucket.members.length;
-		bucket.members.push(b);
-		for (const token of memberTokens(b.name)) {
-			const sharing = bucket.byToken.get(token) ?? [];
-			sharing.push(position);
-			bucket.byToken.set(token, sharing);
-		}
-		buckets.set(key, bucket);
-	}
-	const visitsOf = /* @__PURE__ */ new Map();
-	for (const bucket of buckets.values()) visitsOf.set(bucket, new Int32Array(bucket.members.length));
-	const scorer = createNameScorer();
-	const candidates = [];
-	let visitCount = 0;
-	for (const h of remainingHead) {
-		if (h.dropped) continue;
-		if (h.signature === null || h.signature === void 0) continue;
-		if (!saysEnoughToPair(h.name)) continue;
-		const bucket = buckets.get(bucketKey(h));
-		if (bucket === void 0) continue;
-		const threshold = thresholdFor(h.name);
-		const memberFloor = lowestUsefulMember(threshold);
-		const tokens = memberTokens(h.name);
-		let reach = 0;
-		for (const token of tokens) reach += bucket.byToken.get(token)?.length ?? 0;
-		if (reach >= bucket.members.length) {
-			for (const b of bucket.members) collectCandidate(b, h, scorer, memberFloor, threshold, candidates);
-			continue;
-		}
-		const visited = visitsOf.get(bucket);
-		if (visited === void 0) continue;
-		visitCount++;
-		for (const token of tokens) for (const position of bucket.byToken.get(token) ?? []) {
-			if (visited[position] === visitCount) continue;
-			visited[position] = visitCount;
-			const b = bucket.members[position];
-			if (b !== void 0) collectCandidate(b, h, scorer, memberFloor, threshold, candidates);
-		}
-	}
-	const accepted = acceptInScoreOrder(candidates);
-	return {
-		matched: accepted.pairs.map(({ base, head }) => ({
-			base,
-			head,
-			rationale: "name-signature"
-		})),
-		remainingBase: unclaimed(remainingBase, accepted.baseIds),
-		remainingHead: unclaimed(remainingHead, accepted.headIds)
-	};
-}
-/**
-* §3.4 — score one candidate pairing and keep it if it clears the head's threshold.
-*
-* A plain function rather than a closure over the head loop: both branches of the walk need
-* it, and a closure built per head is the cross-product moved into the allocator — measurably
-* so, at around 1.6x on a bucket the index cannot narrow.
-*
-* §3.4.3's floor is read before §3.4.6's gate and is the only early exit here. It is one
-* Jaccard over token sets the pass already holds, where the gate splits both owners into
-* segments, tokenises each and runs an augmenting-path matching. The gate short-circuits
-* internally on identical owners and on first segments that cannot correspond, so there is
-* nothing left worth hoisting out of it.
-*/
-function collectCandidate(base, head, scorer, memberFloor, threshold, candidates) {
-	const member = scorer.member(base.name, head.name);
-	if (member < memberFloor) return;
-	if (!scorer.ownersCompatible(base.name, head.name)) return;
-	const score = .5 * member + .3 * signatureSimilarity(base.signature ?? null, head.signature ?? null) + .2 * OWNER_AXIS_SATISFIED;
-	if (score >= threshold) candidates.push({
-		base,
-		head,
-		score
-	});
-}
-function bucketKey(s) {
-	const sig = s.signature === null || s.signature === void 0 ? "no-sig" : "has-sig";
-	return `${s.kind}::${sig}`;
-}
-/**
-* §3.4.0 — the least `memberSimilarity` that leaves `threshold` reachable.
-*
-* `0.5 * member + 0.3 * signature + 0.2 * 1` must reach the threshold, and the signature axis
-* is worth at most 0.3, so `member >= 2 * (threshold - 0.5)`. Refusing below this is exact
-* rather than approximate: nothing the other two axes can do rescues a pair under it.
-*
-* Reading it before §3.4.6's gate is what keeps stage 4 off the cross-product. The gate splits
-* and tokenises two owners; this is one Jaccard over token sets the pass has already built,
-* and it refuses most of what a shared token admits.
-*/
-function lowestUsefulMember(threshold) {
-	return 2 * (threshold - .5);
-}
-/**
-* §3.4.0 — the token that stands in for a member name carrying none.
-*
-* `Foo.Bar.` has an empty last segment and two tokens in its qualified name, so it is
-* admissible, and two such Symbols score 1.0 on an axis comparing two empty sets. They have
-* no token to be indexed under and cannot pair with anything that has one, so they share a
-* key of their own. A real token cannot collide with it: `tokenizeName` never emits a space.
-*/
-const NO_MEMBER_TOKENS = " none";
-function memberTokens(qname) {
-	const tokens = tokenizeName(lastSegment(qname));
-	return tokens.length === 0 ? [NO_MEMBER_TOKENS] : tokens;
-}
-/**
-* §3.4.3 — the composite score a pair must reach, by how many tokens the head's last name
-* segment has. A one-token segment still asks for the whole scale, which a pair reaches on an
-* identical member name and signature past §3.4.6's gate: `0.5 + 0.3 + 0.2`, exactly 1 in
-* IEEE 754. The owner need not be identical, only compatible — `UserRepo.get` and
-* `UserRepos.get` reach it.
-*/
-const EXACT_MATCH_ONLY = 1;
-const TWO_TOKEN_THRESHOLD = .95;
-const DEFAULT_THRESHOLD = .85;
-/**
-* §3.4.6 — what the owner axis is worth to a pair that clears its gate, which is every pair
-* that reaches the score. Written as a value rather than folded into the weights so the
-* composite keeps the 0.5/0.3/0.2 shape §3.4.3's rows are calibrated against: dropping the
-* term and renormalising would move every threshold without changing what any of them means.
-*/
-const OWNER_AXIS_SATISFIED = 1;
-function thresholdFor(qname) {
-	const tokens = tokenizeName(lastSegment(qname)).length;
-	if (tokens <= 1) return EXACT_MATCH_ONLY;
-	if (tokens === 2) return TWO_TOKEN_THRESHOLD;
-	return DEFAULT_THRESHOLD;
-}
-/**
-* §3.4.3 — whether a Symbol's qualified name says enough for stage 4 to read it at all.
-*
-* The score is built from three things the name supplies: its tokens, its owner's tokens,
-* and a signature. A name of one distinct token supplies one word and an owner that either
-* repeats it or is empty, and `main(x: string): void` against another `main(x: string): void`
-* scores the full 1.0 on that — two unrelated CLI entry points reported as one move. The
-* table's first row was written to refuse this and could not: 1.0 is the top of the scale,
-* so no threshold sits above it. Being unpairable is a property of the name, not a score it
-* failed to reach, so it is decided here rather than by the comparison.
-*
-* Counted over the whole qualified name, because that is what the score reads.
-* `UserRepo.get` supplies three tokens and pairs, though its last segment is one — the
-* measure `thresholdFor` uses, and the wrong one for this question. Tokens are deduped, so
-* `Main.main` supplies one and does not.
-*
-* Read off both sides, because the property belongs to a pairing. It was once read off the
-* head alone, on the arithmetic that a short name anywhere capped the score at 0.75 — true
-* while the name axis read the whole qualified name, and false since §3.4.6 became a gate and
-* the axis moved to the last segment. `Main.main` is one deduped token and clears the gate
-* against `Mains.main`, whose member name is identical, so the pair reaches the top of the
-* scale from a name saying one word.
-*
-* The count stands in for how much the name says, and `tokenizeName` splits on ASCII case
-* boundaries, so a name written in a script that has none is one token however long it is:
-* `ユーザー情報を取得する` is refused here on the same footing as `main`. For that name the
-* proxy is wrong — two unrelated Symbols do not carry it by coincidence the way two carry
-* `main` — and the cost is a stage-4 move this stage will not find. Fixing it means measuring
-* the name by something other than a bare token count, which is §3.4.1's to change.
-*/
-function saysEnoughToPair(qname) {
-	return tokenizeName(qname).length > 1;
-}
-/**
-* §3.4.5 — dropped-only weak matcher. For dropped Symbols the fingerprint is zeroed, so the
-* only signals left are the trailing segment of the qualified name and the file basename.
-* Either one alone is enough to pair, which is deliberately lax: §3.4.5 accepts a
-* false-positive risk because dropped Symbols sit outside the IR's main review surface.
-*
-* What it does not accept is a signal that identifies nothing. A basename hit on `index.ts`
-* — the most common filename in a TypeScript monorepo — paired every dropped Symbol of one
-* kind under one with every other, at a score they all tied on, and the results landed in
-* `summary.moved`, which `--fail-on moved` gates on. So a half counts only when exactly one
-* dropped base and one dropped head carry that key: such a key names a pair, where a key
-* several Symbols carry names a group, and a group is not a pairing.
-*
-* That makes the candidates the identifying keys themselves — at most one pairing each,
-* two axes, so at most `2 × min(base, head)` of them rather than the cross-product a shared
-* basename used to produce.
-*
-* "Exactly one" is counted over the Symbols this stage is handed, not over every dropped
-* Symbol in the Document — stages 1 and 2 have already taken theirs, and a key they emptied
-* out identifies again. That is the intended reading, since the question is which leftover a
-* key picks out, but it is also how a shared `index.ts` comes back: three dropped classes
-* under one, two of them matched by id, and the basename identifies the two that are left.
-*
-* It also leaves nothing for §3.4.5's 0.5-per-half scale to rank, so §3.8's sweep is the
-* wrong instrument: it settles conflicts by score, and with none to settle by it would drop
-* one identified pairing for another over nothing but the id it sorts under. `bestPairing`
-* takes a maximum matching instead.
-*/
-function matchStageDroppedWeak(remainingBase, remainingHead) {
-	const bases = remainingBase.filter((s) => s.dropped);
-	const heads = remainingHead.filter((s) => s.dropped);
-	const identified = [];
-	for (const keyOf of [nameKey, fileKey]) identified.push(...pairsIdentifiedBy(bases, heads, keyOf));
-	const matched = bestPairing(identified);
-	return {
-		matched: matched.map(({ base, head }) => ({
-			base,
-			head,
-			rationale: "dropped-weak-match"
-		})),
-		remainingBase: unclaimed(remainingBase, new Set(matched.map((edge) => edge.base.id))),
-		remainingHead: unclaimed(remainingHead, new Set(matched.map((edge) => edge.head.id)))
-	};
-}
-/**
-* As many of the identified pairings as can hold at once.
-*
-* Each axis identifies a Symbol at most once, so a Symbol carries at most two pairings and
-* the whole set is the union of two matchings — which is a disjoint union of simple paths and
-* even cycles. Alternate pairings along a component are therefore a maximum matching of it,
-* and walking each component from a fixed end makes the choice among the maximum matchings
-* canonical rather than a property of the input order.
-*
-* The alternative would be §3.8's sweep, and it is the wrong instrument once §3.4.5's score
-* is gone: over `Shared.ts#Alpha`, `Other.ts#Beta` against `Other.ts#Alpha`,
-* `Shared.ts#Gamma`, all three pairings are identified and it takes one where two hold.
-*/
-function bestPairing(edges) {
-	const ordered = [...edges].sort(byEndpoints);
-	const atBase = /* @__PURE__ */ new Map();
-	const atHead = /* @__PURE__ */ new Map();
-	for (const [index, edge] of ordered.entries()) {
-		appendTo(atBase, edge.base.id, index);
-		appendTo(atHead, edge.head.id, index);
-	}
-	const adjacent = (index) => {
-		const edge = ordered[index];
-		if (edge === void 0) return [];
-		return [...atBase.get(edge.base.id) ?? [], ...atHead.get(edge.head.id) ?? []].filter((other) => other !== index);
-	};
-	const walked = ordered.map(() => false);
-	const matching = [];
-	/** Follow a component from `start`, taking every other pairing along it. */
-	const walkFrom = (start) => {
-		let step = start;
-		let take = true;
-		while (!walked[step]) {
-			walked[step] = true;
-			const edge = ordered[step];
-			if (take && edge !== void 0) matching.push(edge);
-			take = !take;
-			const next = adjacent(step).find((other) => walked[other] === false);
-			if (next === void 0) return;
-			step = next;
-		}
-	};
-	for (const [index] of ordered.entries()) if (!walked[index] && adjacent(index).length <= 1) walkFrom(index);
-	for (const [index] of ordered.entries()) if (!walked[index]) walkFrom(index);
-	return matching;
-}
-function byEndpoints(a, b) {
-	if (a.base.id !== b.base.id) return a.base.id < b.base.id ? -1 : 1;
-	return a.head.id < b.head.id ? -1 : a.head.id > b.head.id ? 1 : 0;
-}
-function appendTo(table, key, index) {
-	const bucket = table.get(key);
-	if (bucket === void 0) table.set(key, [index]);
-	else bucket.push(index);
-}
-/**
-* The pairings a key picks out on its own: those whose key exactly one dropped base and one
-* dropped head carry. A key held by two Symbols on either side is discarded rather than
-* resolved — with the fingerprint zeroed there is nothing left to tell the members apart, and
-* guessing between them is the false pairing this rule exists to refuse.
-*/
-function pairsIdentifiedBy(bases, heads, keyOf) {
-	const soleBase = soleCarriers(bases, keyOf);
-	const soleHead = soleCarriers(heads, keyOf);
-	const pairs = [];
-	for (const [key, base] of soleBase) {
-		const head = soleHead.get(key);
-		if (head !== void 0) pairs.push({
-			base,
-			head
-		});
-	}
-	return pairs;
-}
-/** Keys carried by exactly one of `symbols`, mapped to it. */
-function soleCarriers(symbols, keyOf) {
-	const sole = /* @__PURE__ */ new Map();
-	const shared = /* @__PURE__ */ new Set();
-	for (const symbol of symbols) {
-		const key = keyOf(symbol);
-		if (shared.has(key)) continue;
-		if (sole.has(key)) {
-			sole.delete(key);
-			shared.add(key);
-			continue;
-		}
-		sole.set(key, symbol);
-	}
-	return sole;
-}
-/**
-* The two halves §3.4.5 scores. `kind` leads because it gates a pair before either half is
-* read, and `/` separates because no kind, qualified-name segment or basename contains one.
-*/
-function nameKey(symbol) {
-	return `${symbol.kind}/${lastSegment(symbol.name)}`;
-}
-function fileKey(symbol) {
-	return `${symbol.kind}/${basename(symbol.source.file)}`;
-}
-function basename(path) {
-	const slash = path.lastIndexOf("/");
-	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 "unknown": 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
-/**
-* §4 — determine which of the five statuses a matched pair falls into. `dropped-toggled`
-* has absolute priority: whenever `dropped` differs between base and head, every other
-* signal is ignored because the underlying fingerprint change is a consequence of the
-* 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
-* (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.
-*/
-function classifyStatus(base, head) {
-	if (base.dropped !== head.dropped) return "dropped-toggled";
-	const pathChanged = base.source.file !== head.source.file || base.id !== head.id;
-	const fingerprintChanged = base.fingerprint.api !== head.fingerprint.api || base.fingerprint.logic !== head.fingerprint.logic || base.fingerprint.syntax !== head.fingerprint.syntax;
-	if (pathChanged && fingerprintChanged) return "moved+changed";
-	if (pathChanged) return "moved";
-	if (fingerprintChanged) return "changed";
-	return "unchanged";
-}
-function dropDirection(head) {
-	return head.dropped ? "to-dropped" : "to-kept";
-}
-
-//#endregion
-//#region src/diff.ts
-const DIFF_SCHEMA = "https://aburi.kage1020.com/schema/aburi.diff.v1.json";
-const DEFAULT_GENERATOR = {
-	name: "aburi",
-	version: "0.0.0"
-};
-/**
-* Top-level entry: run the 5-stage matcher, classify each pair, produce array deltas,
-* fold in Component / Dependency diffs, and assemble the `aburi.diff.v1` JSON projection.
-* The function is pure; write-to-disk is delegated to `writeCanonicalDiff` so callers can
-* pipe the result through additional steps (Markdown projection, `--fail-on` gate) before
-* serialisation.
-*/
-function buildDiff(input) {
-	assertDiffable(input.baseIR, "baseIR");
-	assertDiffable(input.headIR, "headIR");
-	ensureSchemasAgree(input.baseIR, input.headIR);
-	const stage1 = matchStageId(input.baseIR.symbols, input.headIR.symbols);
-	const stage2 = matchStageGitRename(stage1.remainingBase, stage1.remainingHead, input.gitRenames ?? null);
-	const stage3 = matchStageLogicFingerprint(stage2.remainingBase, stage2.remainingHead);
-	const stage4 = matchStageNameSignature(stage3.remainingBase, stage3.remainingHead);
-	const stage4_5 = matchStageDroppedWeak(stage4.remainingBase, stage4.remainingHead);
-	const pairs = [
-		...stage1.matched,
-		...stage2.matched,
-		...stage3.matched,
-		...stage4.matched,
-		...stage4_5.matched
-	];
-	const summary = {
-		unknown: 0,
-		depsUnknown: 0,
-		added: 0,
-		removed: 0,
-		moved: 0,
-		movedChanged: 0,
-		changed: 0,
-		droppedToggled: 0,
-		unchanged: 0,
-		droppedAdded: 0,
-		droppedRemoved: 0,
-		componentsAdded: 0,
-		componentsRemoved: 0,
-		componentsChanged: 0,
-		depsAdded: 0,
-		depsRemoved: 0
-	};
-	let unknown = 0;
-	const symbols = [];
-	for (const pair of pairs) {
-		const status = classifyStatus(pair.base, pair.head);
-		if (status === "unchanged") {
-			summary.unchanged++;
-			continue;
-		}
-		if (status === "dropped-toggled") {
-			summary.droppedToggled++;
-			symbols.push({
-				status: "dropped-toggled",
-				before: pair.base,
-				after: pair.head,
-				direction: dropDirection(pair.head)
-			});
-			continue;
-		}
-		if (status === "moved") {
-			summary.moved++;
-			symbols.push({
-				status: "moved",
-				before: pair.base,
-				after: pair.head,
-				rationale: pair.rationale
-			});
-			continue;
-		}
-		if (status === "changed") {
-			summary.changed++;
-			symbols.push({
-				status: "changed",
-				before: pair.base,
-				after: pair.head,
-				delta: computeSymbolDelta(pair.base, pair.head, input.delta ?? {})
-			});
-			continue;
-		}
-		summary.movedChanged++;
-		symbols.push({
-			status: "moved+changed",
-			before: pair.base,
-			after: pair.head,
-			rationale: pair.rationale,
-			delta: computeSymbolDelta(pair.base, pair.head, input.delta ?? {})
-		});
-	}
-	const finalRemainingHead = stage4_5.remainingHead;
-	const finalRemainingBase = stage4_5.remainingBase;
-	const baseSide = dependencySideView(input.baseIR);
-	const headSide = dependencySideView(input.headIR);
-	const lostByHead = headSide.lostFiles;
-	const lostByBase = baseSide.lostFiles;
-	for (const h of finalRemainingHead) {
-		if (h.dropped) {
-			summary.droppedAdded++;
-			continue;
-		}
-		const reason = lostByBase.get(h.source.file);
-		if (reason !== void 0) {
-			unknown++;
-			symbols.push({
-				status: "unknown",
-				symbol: h,
-				absentFrom: "base",
-				reason
-			});
-			continue;
-		}
-		summary.added++;
-		symbols.push({
-			status: "added",
-			symbol: h
-		});
-	}
-	for (const b of finalRemainingBase) {
-		if (b.dropped) {
-			summary.droppedRemoved++;
-			continue;
-		}
-		const reason = lostByHead.get(b.source.file);
-		if (reason !== void 0) {
-			unknown++;
-			symbols.push({
-				status: "unknown",
-				symbol: b,
-				absentFrom: "head",
-				reason
-			});
-			continue;
-		}
-		summary.removed++;
-		symbols.push({
-			status: "removed",
-			symbol: b
-		});
-	}
-	const components = diffComponents(input.baseIR.components, input.headIR.components);
-	summary.componentsAdded = components.added.length;
-	summary.componentsRemoved = components.removed.length;
-	summary.componentsChanged = components.changed.length;
-	const dependencies = diffDependencies(input.baseIR.dependencies, input.headIR.dependencies, {
-		base: baseSide,
-		head: headSide
-	});
-	summary.depsAdded = dependencies.added.length;
-	summary.depsRemoved = dependencies.removed.length;
-	summary.depsUnknown = dependencies.unknown.length;
-	summary.unknown = unknown;
-	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,
-		base: input.base,
-		head: input.head,
-		summary,
-		symbols,
-		components,
-		dependencies,
-		slices,
-		notCompared: filesNeitherSideRead(lostByBase, lostByHead)
-	};
-}
-/**
-* Paths both documents record as never analysed, with each side's own reason.
-*
-* This is the loss `unknown` cannot describe. That status is derived from the matcher's
-* leftovers — a Symbol one document holds and the other lacks — and a file skipped on both
-* sides contributes Symbols to neither, so it leaves no leftover to classify and the whole
-* document falls silent about it. Silence is the one thing it must not do here: a diff with
-* nothing to say about a path is exactly what a diff that compared it and found it unchanged
-* looks like.
-*
-* The intersection, not the union. A one-sided loss has leftovers on the other side and is
-* reported as `unknown` there; listing it here as well would count one loss twice, in two
-* vocabularies that mean different things.
-*
-* Always returns an array, empty included. Optionality in the schema covers documents written
-* before the field existed, and no arithmetic elsewhere in a diff would let a reader tell that
-* case from a run that missed nothing (docs/design/diff-algorithm.md §10.1).
-*/
-function filesNeitherSideRead(lostByBase, lostByHead) {
-	const both = [];
-	for (const [path, baseReason] of lostByBase) {
-		const headReason = lostByHead.get(path);
-		if (headReason === void 0) continue;
-		both.push({
-			path,
-			baseReason,
-			headReason
-		});
-	}
-	return both.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-}
-/** §9.1 — refuse to diff across schema versions. */
-function ensureSchemasAgree(base, head) {
-	if (base.$schema !== head.$schema) throw new DiffError(`Base IR schema "${base.$schema}" does not match head IR schema "${head.$schema}"; a diff across schema versions is not supported.`, {
-		code: "schema-mismatch",
-		value: base.$schema
-	});
-}
-/** Identity is a single field, so joining the one-member tuple is joining nothing. */
-const soleField = (parts) => parts.join("");
-const IDENTIFIED_COLLECTIONS = [
-	{
-		field: "symbols",
-		identityFields: ["id"],
-		keyOf: soleField,
-		noun: "id",
-		show: soleField,
-		consequence: "stage 1 pairs Symbols by id and every later stage tracks the base Symbols it has consumed by id, so a repeat leaves one entry out of the diff entirely or classifies its counterpart twice (ir-schema.md §14 #1)"
-	},
-	{
-		field: "components",
-		identityFields: ["id"],
-		keyOf: soleField,
-		noun: "id",
-		show: soleField,
-		consequence: "Component identity is the id, so a repeat hides one entry and can report a change the two revisions do not contain (ir-schema.md §14 #2)"
-	},
-	{
-		field: "dependencies",
-		identityFields: DEPENDENCY_IDENTITY_FIELDS,
-		keyOf: dependencyIdentity,
-		noun: "(from, to, via) triple",
-		show: (parts) => `(${parts.join(", ")})`,
-		consequence: "direction and effect are deliberately outside Dependency identity (§6.2), so a repeat surfaces as an added + removed pair no reader can tell from a real flip (ir-schema.md §14 #13)"
-	}
-];
-/**
-* The two things `buildDiff` needs before stage 1 runs: a Document it can walk, and
-* identities it can key on. diff-algorithm.md §3.7 states the second and why it is checked
-* here as well as at extraction time.
-*
-* Neither half is a full schema validation. A Symbol that reaches stage 1 is an object with
-* a string `id`, because the identity scan reads that much; nothing checks it carries a
-* `fingerprint`, which is `checkIRIntegrity` #20's job and runs when the CLI reads an IR off
-* disk. What this does buy is that a malformed collection is named — `symbols: undefined`
-* used to surface as `TypeError: undefined is not iterable` and `symbols: [null]` as
-* `TypeError: Cannot read properties of null (reading 'id')`, both from inside
-* `matchStageId`, with neither the collection nor the index named.
-*/
-function assertDiffable(ir, name) {
-	if (ir === null || typeof ir !== "object") throw shapeError(name, `${name} must be an IR object; got ${describeValue(ir)}.`);
-	if (typeof ir.$schema !== "string" || ir.$schema.length === 0) throw shapeError(`${name}.$schema`, `${name}.$schema must be a non-empty schema URL.`);
-	for (const collection of IDENTIFIED_COLLECTIONS) assertUniqueIdentity(ir[collection.field], `${name}.${collection.field}`, collection);
-}
-function assertUniqueIdentity(entries, subject, collection) {
-	if (!Array.isArray(entries)) throw shapeError(subject, `${subject} must be an array.`);
-	const firstSeen = /* @__PURE__ */ new Map();
-	for (const [index, entry] of entries.entries()) {
-		const entrySubject = `${subject}[${index}]`;
-		const parts = identityFieldsOf(entry, entrySubject, collection);
-		const key = collection.keyOf(parts);
-		const first = firstSeen.get(key);
-		if (first === void 0) {
-			firstSeen.set(key, index);
-			continue;
-		}
-		const shown = collection.show(parts);
-		throw new DiffError(`${entrySubject} repeats the ${collection.noun} "${shown}" first seen at index ${first}; ${collection.consequence}.`, {
-			code: "ir-identity-collision",
-			value: shown
-		});
-	}
-}
-/**
-* The identity fields of one entry, established as strings on the way out. Reading them is
-* what forces the check: without it a Symbol carrying no `id` has nothing to collide with,
-* passes, and derives a Slice anchored on `undefined` several stages later — which
-* `assertSliceRecordInvariant` reports as `slice-invariant-violated`, the one code the CLI
-* presents as a bug in Aburi rather than in the caller's IR.
-*/
-function identityFieldsOf(entry, subject, collection) {
-	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw shapeError(subject, `${subject} must be an object; got ${describeValue(entry)}.`);
-	const parts = [];
-	for (const field of collection.identityFields) {
-		const value = entry[field];
-		if (typeof value !== "string") throw shapeError(`${subject}.${field}`, `${subject}.${field} must be a string; got ${describeValue(value)}.`);
-		parts.push(value);
-	}
-	return parts;
-}
-function shapeError(subject, message) {
-	return new DiffError(message, {
-		code: "ir-shape-invalid",
-		value: subject
-	});
-}
-function describeValue(value) {
-	if (value === void 0) return "undefined";
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "an array";
-	return `a ${typeof value}`;
-}
-/**
-* Deterministic ordering of the `symbols[]` output:
-* 1. by status (alphabetical) — pins added/changed/moved sections
-* 2. by the "reference" id (`after` for change/move/toggle, otherwise `symbol`)
-*
-* The result is stable byte-for-byte for equal inputs, matching the canonicalisation
-* guarantee the diff JSON must uphold when persisted to `out/diff.json`.
-*/
-function compareSymbolChange(a, b) {
-	if (a.status !== b.status) return a.status < b.status ? -1 : 1;
-	const idA = referenceId(a);
-	const idB = referenceId(b);
-	return idA < idB ? -1 : idA > idB ? 1 : 0;
-}
-function referenceId(change) {
-	if (change.status === "added" || change.status === "removed" || change.status === "unknown") return change.symbol.id;
-	return change.after.id;
-}
-/**
-* The files a document's scan never analysed, by path, with why.
-*
-* `stats.skippedFiles` is Class B: absent means the writer predates the field, not that
-* nothing was lost. An empty map is the honest answer either way — with no enumeration
-* there is no absence this function can explain, and guessing from
-* `totalFiles > parsedFiles` would attach a reason to whichever Symbols happened to be
-* missing. The CLI says so on stderr instead; a diff cannot invent the list.
-*/
-/**
-* Byte-deterministic serialiser for a DiffResult. Delegates to `@aburi/core`
-* `serializeCanonical` so the sort order, NFC normalisation, and codepoint key sort are
-* shared with the IR side.
-*/
-function writeCanonicalDiff(diff, options = {}) {
-	return serializeCanonical(diff, options);
-}
-
-//#endregion
-export { DEFAULT_LINE_FUZZ, DiffError, MAX_LINE_FUZZ, MIN_LINE_FUZZ, assertSliceRecordInvariant, buildDiff, classifyStatus, computeSlices, computeSymbolDelta, dependencySideView, diffComponents, diffDependencies, dropDirection, jaccard, jaccardTokens, lastSegment, matchStageDroppedWeak, matchStageGitRename, matchStageId, matchStageLogicFingerprint, matchStageNameSignature, memberSimilarity, nameSimilarity, ownersAreCompatible, signatureSimilarity, sliceAnchor, sliceRecordViolation, tokenizeName, writeCanonicalDiff };
-//# sourceMappingURL=index.mjs.map
+import{DOCUMENT_SUBJECT as e,RESERVED_LANGUAGE_IDS as t,checkDocumentShape as n,computeWeaklyConnectedComponents as r,reconstructCallEdgesFromIR as i,serializeCanonical as a,trySymbolId as o}from"@aburi/core";var s=class extends Error{code;value;violations;constructor(e,t,n){super(e,n),this.name=`DiffError`,this.code=t.code,this.value=t.value,this.violations=t.violations}};function c(e,t){let n=new Map;for(let t of e)n.set(t.id,t);let r=new Map;for(let e of t)r.set(e.id,e);let i=[],a=[],o=[];for(let[e,t]of r){let r=n.get(e);if(r===void 0){i.push(t);continue}g(r,t)||o.push({before:r,after:t,delta:{rootsChanged:!b(r.roots,t.roots),publicApiChanged:!b(r.publicApi??[],t.publicApi??[]),frameworksChanged:!b(r.frameworks??[],t.frameworks??[])}})}for(let[e,t]of n)r.has(e)||a.push(t);return x(i),x(a),o.sort((e,t)=>e.after.id<t.after.id?-1:+(e.after.id>t.after.id)),{added:i,removed:a,changed:o}}function l(e){let t=new Map;for(let n of e.symbols)t.set(n.id,n.source.file);let n=new Map;for(let t of e.stats.skippedFiles??[])n.set(t.path,t.reason);return{symbolFiles:t,lostFiles:n}}function u(e,t,n){let r=new Map;for(let t of e)r.set(m(t),t);let i=new Map;for(let e of t)i.set(m(e),e);let a=[],o=[],s=[];for(let[e,t]of i){let i=r.get(e);if(i===void 0){let e=d(t,n.head,n.base);e.length>0?s.push({dependency:t,absentFrom:`base`,lostFiles:e}):a.push(t);continue}(i.direction!==t.direction||(i.effect??null)!==(t.effect??null))&&(o.push(i),a.push(t))}for(let[e,t]of r){if(i.has(e))continue;let r=d(t,n.base,n.head);r.length>0?s.push({dependency:t,absentFrom:`head`,lostFiles:r}):o.push(t)}return a.sort(h),o.sort(h),s.sort((e,t)=>h(e.dependency,t.dependency)),{added:a,removed:o,unknown:s}}function d(e,t,n){let r=new Map;for(let i of[e.from,e.to]){let e=t.symbolFiles.get(i);if(e===void 0)continue;let a=n.lostFiles.get(e);a!==void 0&&r.set(e,a)}return[...r.entries()].map(([e,t])=>({path:e,reason:t})).sort((e,t)=>e.path<t.path?-1:+(e.path>t.path))}const f=[`from`,`to`,`via`];function p(e){return e.join(`::`)}function m(e){return p(f.map(t=>e[t]))}function h(e,t){let n=m(e),r=m(t);return n<r?-1:+(n>r)}function g(e,t){return _(e,`base`)===_(t,`head`)}function _(e,t){try{return a(v(e),{format:`compact`})}catch(n){throw new s(`${t} components[id=${e.id}] cannot be compared: ${n instanceof Error?n.message:String(n)}`,{code:`ir-shape-invalid`,value:`components[id=${e.id}]`},{cause:n})}}function v(e){let t={...e};(t.description===null||t.description===void 0)&&delete t.description;for(let e of y){let n=t[e];(n===void 0||Array.isArray(n)&&n.length===0)&&delete t[e]}return t}const y=[`publicApi`,`frameworks`];function b(e,t){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n++)if(e[n]!==t[n])return!1;return!0}function x(e){e.sort((e,t)=>e.id<t.id?-1:+(e.id>t.id))}const S=2,ee=10,te=0;function C(e,t,n={}){let r=ne(n.lineFuzz??2),i={apiChanged:e.fingerprint.api!==t.fingerprint.api,logicChanged:e.fingerprint.logic!==t.fingerprint.logic,syntaxChanged:e.fingerprint.syntax!==t.fingerprint.syntax,componentChanged:(e.component??null)!==(t.component??null),visibilityChanged:e.visibility!==t.visibility};return i.rules=ae(e.rules,t.rules,r),i.effects=se(e.effects,t.effects),i.calls=le(e.calls,t.calls,r),i.decorators=de(e.decorators,t.decorators,r),i.signature=pe(e.signature??null,t.signature??null),i}function ne(e){if(!Number.isFinite(e)||!Number.isInteger(e))throw new s(`config.diff.lineFuzz must be an integer in [0, 10]; got ${String(e)}.`,{code:`invalid-line-fuzz`,value:String(e)});if(e<0||e>10)throw new s(`config.diff.lineFuzz must be within [0, 10]; got ${e}.`,{code:`invalid-line-fuzz`,value:String(e)});return e}function w(e,t,n,r){let i=new Set(e.map((e,t)=>t)),a=new Set(t.map((e,t)=>t)),o=new Map;for(let s of[!0,!1]){let c=(e,t)=>e.key===t.key&&Math.abs(e.line-t.line)<=r&&(!s||n(e.item,t.item));for(let[n,r]of ie(e,t,i,a,c)){i.delete(n),a.delete(r);let t=e[n];t!==void 0&&o.set(r,t)}}let s=[],c=[];for(let[e,r]of t.entries()){let t=o.get(e);t===void 0?s.push(r.item):n(t.item,r.item)||c.push(r.item)}return{added:s,removed:e.filter((e,t)=>i.has(t)).map(e=>e.item),modified:c}}const T={pairs:0,distance:0};function re(e,t){return e.pairs===t.pairs?e.distance<t.distance:e.pairs>t.pairs}function ie(e,t,n,r,i){let a=Array.from({length:e.length+1},()=>Array.from({length:t.length+1},()=>T)),o=(o,s)=>{let c=e[o],l=t[s];if(c===void 0||l===void 0||!n.has(o)||!r.has(s)||!i(c,l))return null;let u=a[o+1]?.[s+1]??T;return{pairs:u.pairs+1,distance:u.distance+Math.abs(c.line-l.line)}};for(let n=e.length-1;n>=0;n--)for(let e=t.length-1;e>=0;e--){let t=a[n+1]?.[e]??T,r=a[n]?.[e+1]??T,i=re(t,r)?t:r,s=o(n,e);s!==null&&re(s,i)&&(i=s);let c=a[n];c!==void 0&&(c[e]=i)}let s=[],c=0,l=0;for(;c<e.length&&l<t.length;){let e=a[c]?.[l]??T,t=o(c,l);if(t!==null&&t.pairs===e.pairs&&t.distance===e.distance){s.push([c,l]),c++,l++;continue}let n=a[c+1]?.[l]??T;n.pairs===e.pairs&&n.distance===e.distance?c++:l++}return s}function ae(e,t,n){let r=e=>({item:e,key:e.type,line:e.line});return w(e.map(r),t.map(r),oe,n)}function oe(e,t){return e.type===t.type&&(e.condition??null)===(t.condition??null)&&(e.what??null)===(t.what??null)&&(e.expr??null)===(t.expr??null)&&(e.loopKind??null)===(t.loopKind??null)}function se(e,t){let n=e=>({item:e,key:`${e.id}::${e.target}`,line:e.line??0});return w(e.map(n),t.map(n),ce,1/0)}function ce(e,t){return e.id===t.id&&e.target===t.target&&e.plugin===t.plugin&&e.confidence===t.confidence}function le(e,t,n){let r=e=>({item:e,key:e.target,line:e.line});return w(e.map(r),t.map(r),ue,n)}function ue(e,t){return e.target===t.target&&(e.resolved??null)===(t.resolved??null)}function de(e,t,n){let r=e=>({item:e,key:e.name,line:e.line});return w(e.map(r),t.map(r),fe,n)}function fe(e,t){if(e.name!==t.name||e.arguments.length!==t.arguments.length)return!1;for(let n=0;n<e.arguments.length;n++)if(e.arguments[n]!==t.arguments[n])return!1;return!0}function pe(e,t){if(e===null&&t===null)return null;if(e===null||t===null){let n={added:[],removed:[],modified:[]},r=e??t;if(r===null)return null;let i=e===null;return{inputs:i?{added:[...r.inputs],removed:[],modified:[]}:{added:[],removed:[...r.inputs],modified:[]},outputs:i?{added:[...r.outputs],removed:[],modified:[]}:{added:[],removed:[...r.outputs],modified:[]},throws:i?{added:[...r.throws],removed:[],modified:[]}:{added:[],removed:[...r.throws],modified:[]},asyncChanged:(e?.async??!1)!==(t?.async??!1),generatorChanged:(e?.generator??!1)!==(t?.generator??!1),typeParametersChanged:!ge(e?.typeParameters??n.added.map(String),t?.typeParameters??n.added.map(String))}}let n=(e,t)=>({item:e,key:`${t}:${e.name}`,line:t});return{inputs:w(e.inputs.map(n),t.inputs.map(n),(e,t)=>e.name===t.name&&e.type===t.type,0),outputs:me(e.outputs,t.outputs),throws:he(e.throws,t.throws),asyncChanged:e.async!==t.async,generatorChanged:e.generator!==t.generator,typeParametersChanged:!ge(e.typeParameters,t.typeParameters)}}function me(e,t){let n=[],r=[],i=Math.max(e.length,t.length);for(let a=0;a<i;a++){let i=a<e.length?e[a]:void 0,o=a<t.length?t[a]:void 0;i===void 0&&o!==void 0?n.push(o):o===void 0&&i!==void 0?r.push(i):i!==o&&(i!==void 0&&r.push(i),o!==void 0&&n.push(o))}return{added:n,removed:r,modified:[]}}function he(e,t){let n=new Set(e),r=new Set(t),i=[],a=[];for(let e of r)n.has(e)||i.push(e);for(let e of n)r.has(e)||a.push(e);return{added:i,removed:a,modified:[]}}function ge(e,t){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n++)if(e[n]!==t[n])return!1;return!0}function E(e,t){let n=e??null,r=t??null;if(n===null&&r===null)return 1;if(n===null||r===null)return 0;let i=D(n.inputs.map(e=>e.type),r.inputs.map(e=>e.type)),a=D(n.outputs,r.outputs),o=_e(n.throws,r.throws);return(i+a+o)/3}function D(e,t){if(e.length===0&&t.length===0)return 1;if(e.length!==t.length)return 0;let n=0;for(let r=0;r<e.length;r++)e[r]===t[r]&&n++;return n/e.length}function _e(e,t){if(e.length===0&&t.length===0)return 1;let n=new Set(e),r=new Set(t),i=0;for(let e of n)r.has(e)&&i++;let a=n.size+r.size-i;return a===0?1:i/a}function O(e){let t=new Set,n=[];for(let r of e.split(/[.:_\-\s/]+/))if(r.length!==0)for(let e of ve(r)){let r=e.toLowerCase();r.length===0||t.has(r)||(t.add(r),n.push(r))}return n}function ve(e){let t=[],n=``;for(let r of e){if(n===``){n=r;continue}ye(n.slice(-1),r)?(t.push(n),n=r):n+=r}return n.length>0&&t.push(n),t}function ye(e,t){let n=e>=`a`&&e<=`z`,r=e>=`A`&&e<=`Z`,i=e>=`0`&&e<=`9`,a=t>=`a`&&t<=`z`,o=t>=`A`&&t<=`Z`;return!!(n&&o||(n||r)&&t>=`0`&&t<=`9`||i&&(a||o))}function be(e,t){return k(new Set(e),new Set(t))}function k(e,t){if(e.size===0&&t.size===0)return 1;if(e.size===0||t.size===0)return 0;let[n,r]=e.size<=t.size?[e,t]:[t,e],i=0;for(let e of n)r.has(e)&&i++;return i/(e.size+t.size-i)}function xe(e,t){return be(O(e),O(t))}const A=e=>new Set(O(e));function Se(e,t){return j(A,e,t)}function Ce(e,t){return M(A,e,t)}function we(e,t){return De(A,e,t)}function Te(e,t){if(e===t)return!0;let[n,r]=e.length<=t.length?[e,t]:[t,e];return Ee(n,r)}function Ee(e,t){return t===`${e}s`||t===`${e}es`?!0:e.endsWith(`y`)&&t===`${e.slice(0,-1)}ies`}function j(e,t,n){return k(e(t),e(n))}function M(e,t,n){return k(e(R(t)),e(R(n)))}function De(e,t,n){let r=L(t),i=L(n);return r===``&&i===``?!0:r===``||i===``?!1:r===i?!0:N(r,i,e)}function N(e,t,n){let r=e.split(`.`),i=t.split(`.`);return r.length===i.length?r.every((e,t)=>{let r=i[t];return r===void 0?!1:e===r?!0:Oe(n(e),n(r))}):!1}function Oe(e,t){if(e.size!==t.size||e.size>32)return!1;let n=[...t],r=new Map;for(let t of e)if(!P(t,n,r,new Set))return!1;return!0}function P(e,t,n,r){for(let i of t){if(r.has(i)||!Te(e,i))continue;r.add(i);let a=n.get(i);if(a===void 0||P(a,t,n,r))return n.set(i,e),!0}return!1}function ke(e,t,n){let r=e.slice(0,F(e)),i=t.slice(0,F(t));if(r===i)return!0;let a=n(r),o=n(i);if(a.size!==o.size||a.size>32)return!1;for(let e of a){let t=!1;for(let n of o)if(Te(e,n)){t=!0;break}if(!t)return!1}return!0}function F(e){let t=e.indexOf(`.`);return t<0?e.length:t}function I(){let e=new Map,t=t=>{let n=e.get(t);if(n!==void 0)return n;let r=new Set(O(t));return e.set(t,r),r},n=new Map,r=e=>{let t=n.get(e);if(t!==void 0)return t;let r=L(e);return n.set(e,r),r};return{name:(e,n)=>j(t,e,n),member:(e,n)=>M(t,e,n),ownersCompatible:(e,n)=>{let i=r(e),a=r(n);return i===a?!0:i===``||a===``||!ke(i,a,t)?!1:N(i,a,t)}}}function L(e){let t=e.indexOf(`::`);if(t>=0)return e.slice(0,t);let n=e.lastIndexOf(`.`);return n>=0?e.slice(0,n):``}function R(e){let t=e.indexOf(`::`);if(t>=0)return e.slice(t+2);let n=e.lastIndexOf(`.`);return n>=0?e.slice(n+1):e}function z(e){e.sort(Ae);let t=new Set,n=new Set,r=[];for(let i of e)t.has(i.base.id)||n.has(i.head.id)||(t.add(i.base.id),n.add(i.head.id),r.push(i));return{pairs:r,baseIds:t,headIds:n}}function Ae(e,t){return e.score===t.score?e.base.id===t.base.id?e.head.id<t.head.id?-1:+(e.head.id>t.head.id):e.base.id<t.base.id?-1:1:t.score-e.score}function B(e,t){return e.filter(e=>!t.has(e.id))}function V(e,t){let n=new Map;for(let e of t)n.set(e.id,e);let r=[],i=[],a=new Set;for(let t of e){let e=n.get(t.id);e===void 0?i.push(t):(r.push({base:t,head:e,rationale:`id-match`}),a.add(t.id))}return{matched:r,remainingBase:i,remainingHead:t.filter(e=>!a.has(e.id))}}function H(e,t,n){if(n===null||n.size===0)return{matched:[],remainingBase:[...e],remainingHead:[...t]};let r=new Map;for(let e of t)r.set(e.id,e);let i=new Map;for(let t of e){let e=n.get(t.source.file);if(e===void 0)continue;let a=Me(t.id,t.source.file,e);if(a===null)continue;let o=r.get(a);if(o===void 0)continue;let s=i.get(a);s===void 0?i.set(a,{head:o,bases:[t]}):s.bases.push(t)}let a=[],o=new Set,s=new Set;for(let{head:e,bases:t}of i.values()){let n=je(t);a.push({base:n,head:e,rationale:`git-rename`}),o.add(n.id),s.add(e.id)}return{matched:a,remainingBase:B(e,o),remainingHead:B(t,s)}}function je(e){let t=e[0];for(let n of e)n.id<t.id&&(t=n);return t}function Me(e,t,n){let r=e.indexOf(`:`),i=e.indexOf(`#`);return r<0||i<0||i<r||e.slice(r+1,i)!==t?e:o({language:e.slice(0,r),file:n,qualifiedName:e.slice(i+1)})}function U(e,t){let n=W(e),r=W(t),i=I(),a=[];for(let[e,t]of r){let r=n.get(e);r!==void 0&&a.push(...Ne(r,t,i))}let o=new Set(a.map(e=>e.base.id)),s=new Set(a.map(e=>e.head.id));return{matched:a,remainingBase:B(e,o),remainingHead:B(t,s)}}function W(e){let t=new Map;for(let n of e){if(n.dropped||n.fingerprint.logic===`000000000000`)continue;let e=t.get(n.fingerprint.logic)??[];e.push(n),t.set(n.fingerprint.logic,e)}return t}function Ne(e,t,n){let r=[...e],i=[...t],a=[];for(;r.length>0&&i.length>0;){let e=r.length===1?r[0]:void 0;if(e!==void 0){let t=Pe(e,i,n);if(t===void 0)break;a.push({base:e,head:t,rationale:`logic-fingerprint`});break}let t=[];for(let e of r)for(let r of i){let i=n.name(e.name,r.name);i>=.85&&t.push({base:e,head:r,score:i})}let o=z(t);if(o.pairs.length===0)break;for(let{base:e,head:t}of o.pairs)a.push({base:e,head:t,rationale:`logic-fingerprint+name-disambiguation`});r=B(r,o.baseIds),i=B(i,o.headIds)}return a}function Pe(e,t,n){let r;for(let i of t){let t=n.name(e.name,i.name);if(r===void 0||t>r.score){r={head:i,score:t};continue}t===r.score&&i.id<r.head.id&&(r={head:i,score:t})}return r?.head}function G(e,t){let n=new Map;for(let t of e){if(t.dropped||!J(t.name))continue;let e=Fe(t),r=n.get(e)??{members:[],byToken:new Map},i=r.members.length;r.members.push(t);for(let e of q(t.name)){let t=r.byToken.get(e)??[];t.push(i),r.byToken.set(e,t)}n.set(e,r)}let r=new Map;for(let e of n.values())r.set(e,new Int32Array(e.members.length));let i=I(),a=[],o=0;for(let e of t){if(e.dropped||e.signature===null||e.signature===void 0||!J(e.name))continue;let t=n.get(Fe(e));if(t===void 0)continue;let s=Re(e.name),c=Ie(s),l=q(e.name),u=0;for(let e of l)u+=t.byToken.get(e)?.length??0;if(u>=t.members.length){for(let n of t.members)K(n,e,i,c,s,a);continue}let d=r.get(t);if(d!==void 0){o++;for(let n of l)for(let r of t.byToken.get(n)??[]){if(d[r]===o)continue;d[r]=o;let n=t.members[r];n!==void 0&&K(n,e,i,c,s,a)}}}let s=z(a);return{matched:s.pairs.map(({base:e,head:t})=>({base:e,head:t,rationale:`name-signature`})),remainingBase:B(e,s.baseIds),remainingHead:B(t,s.headIds)}}function K(e,t,n,r,i,a){let o=n.member(e.name,t.name);if(o<r||!n.ownersCompatible(e.name,t.name))return;let s=.5*o+.3*E(e.signature??null,t.signature??null)+.2*Le;s>=i&&a.push({base:e,head:t,score:s})}function Fe(e){let t=e.signature===null||e.signature===void 0?`no-sig`:`has-sig`;return`${e.kind}::${t}`}function Ie(e){return 2*(e-.5)}function q(e){let t=O(R(e));return t.length===0?[` none`]:t}const Le=1;function Re(e){let t=O(R(e)).length;return t<=1?1:t===2?.95:.85}function J(e){return O(e).length>1}function Y(e,t){let n=e.filter(e=>e.dropped),r=t.filter(e=>e.dropped),i=[];for(let e of[Ue,We])i.push(...Ve(n,r,e));let a=ze(i);return{matched:a.map(({base:e,head:t})=>({base:e,head:t,rationale:`dropped-weak-match`})),remainingBase:B(e,new Set(a.map(e=>e.base.id))),remainingHead:B(t,new Set(a.map(e=>e.head.id)))}}function ze(e){let t=[...e].sort(Be),n=new Map,r=new Map;for(let[e,i]of t.entries())X(n,i.base.id,e),X(r,i.head.id,e);let i=e=>{let i=t[e];return i===void 0?[]:[...n.get(i.base.id)??[],...r.get(i.head.id)??[]].filter(t=>t!==e)},a=t.map(()=>!1),o=[],s=e=>{let n=e,r=!0;for(;!a[n];){a[n]=!0;let e=t[n];r&&e!==void 0&&o.push(e),r=!r;let s=i(n).find(e=>a[e]===!1);if(s===void 0)return;n=s}};for(let[e]of t.entries())!a[e]&&i(e).length<=1&&s(e);for(let[e]of t.entries())a[e]||s(e);return o}function Be(e,t){return e.base.id===t.base.id?e.head.id<t.head.id?-1:+(e.head.id>t.head.id):e.base.id<t.base.id?-1:1}function X(e,t,n){let r=e.get(t);r===void 0?e.set(t,[n]):r.push(n)}function Ve(e,t,n){let r=He(e,n),i=He(t,n),a=[];for(let[e,t]of r){let n=i.get(e);n!==void 0&&a.push({base:t,head:n})}return a}function He(e,t){let n=new Map,r=new Set;for(let i of e){let e=t(i);if(!r.has(e)){if(n.has(e)){n.delete(e),r.add(e);continue}n.set(e,i)}}return n}function Ue(e){return`${e.kind}/${R(e.name)}`}function We(e){return`${e.kind}/${Ge(e.source.file)}`}function Ge(e){let t=e.lastIndexOf(`/`);return t>=0?e.slice(t+1):e}function Ke(e){let t=$e(e.changes);if(t.length===0)return[];let n=new Set(t);return r(t,tt(e.baseCallEdges,e.headCallEdges,n),e=>e).map(Je)}function qe(e){return`slice:${e}`}function Je(e){let t=e[0];if(t===void 0)throw new s(`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`});let n={id:qe(t),members:[...e]};return Z(n),n}function Ye(e){let t=e.members[0];if(t===void 0){let t=Qe(e.id);throw new s(t.message,{code:`slice-invariant-violated`,value:t.subject})}return t}function Xe(e){if(typeof e!=`object`||!e)return{kind:`malformed-shape`,subject:`<not an object>`,message:`Expected a SliceRecord object; got ${e===null?`null`:typeof e}.`};let{id:t,members:n}=e,r=typeof t==`string`?t:`<missing id>`;if(typeof t!=`string`)return{kind:`malformed-shape`,subject:r,message:`SliceRecord ${r}: id must be a string; got ${typeof t}.`};if(!Array.isArray(n)||n.some(e=>typeof e!=`string`))return{kind:`malformed-shape`,subject:r,message:`SliceRecord ${r}: members must be an array of strings.`};let i=n[0];if(i===void 0)return Qe(r);let a=Ze(i);if(a!==null)return{kind:`anchor-in-reserved-namespace`,subject:r,message:`SliceRecord anchor "${i}" uses the reserved language token "${a}", so its Slice id would repeat the prefix (ir-schema.md §3.5, slice-view.md §7.5).`};for(let e=1;e<n.length;e++){let t=n[e-1],i=n[e];if(!(t<i))return{kind:`members-unordered`,subject:r,message:`SliceRecord ${r}: members[] is not in strictly ascending order at index ${e} ("${i}" follows "${t}"), so members[0] is not necessarily the anchor (slice-view.md §8.2 for the order, §11.1 for uniqueness).`}}let o=qe(i);return t===o?null:{kind:`id-not-derived`,subject:r,message:`SliceRecord id "${t}" is not derived from the anchor "${i}"; expected "${o}" (slice-view.md §7.1).`}}function Ze(e){let n=e.indexOf(`:`);if(n<0)return null;let r=e.slice(0,n);return t.has(r)?r:null}function Qe(e){return{kind:`members-empty`,subject:e,message:`SliceRecord ${e}: members[] is empty, so the Slice has no anchor (slice-view.md §11.1 requires at least one member).`}}function Z(e){let t=Xe(e);if(t!==null)throw new s(t.message,{code:`slice-invariant-violated`,value:t.subject})}function $e(e){let t=[];for(let n of e){let e=et(n);e!==null&&t.push(e)}return t}function et(e){switch(e.status){case`added`:return e.symbol.id;case`removed`:return e.symbol.id;case`unknown`:return e.symbol.id;case`changed`:case`moved+changed`:case`dropped-toggled`:return e.after.id;case`moved`:return null}}function tt(e,t,n){let r=[];for(let t of e)nt(t,n,r);for(let e of t)nt(e,n,r);return r}function nt(e,t,n){!t.has(e.from)||!t.has(e.to)||n.push([e.from,e.to])}function rt(e,t){if(e.dropped!==t.dropped)return`dropped-toggled`;let n=e.source.file!==t.source.file||e.id!==t.id,r=e.fingerprint.api!==t.fingerprint.api||e.fingerprint.logic!==t.fingerprint.logic||e.fingerprint.syntax!==t.fingerprint.syntax;return n&&r?`moved+changed`:n?`moved`:r?`changed`:`unchanged`}function it(e){return e.dropped?`to-dropped`:`to-kept`}const at={name:`aburi`,version:`0.0.0`};function ot(e){ut(e.baseIR,`baseIR`),ut(e.headIR,`headIR`),ct(e.baseIR,e.headIR);let t=V(e.baseIR.symbols,e.headIR.symbols),n=H(t.remainingBase,t.remainingHead,e.gitRenames??null),r=U(n.remainingBase,n.remainingHead),a=G(r.remainingBase,r.remainingHead),o=Y(a.remainingBase,a.remainingHead),s=[...t.matched,...n.matched,...r.matched,...a.matched,...o.matched],d={unknown:0,depsUnknown:0,added:0,removed:0,moved:0,movedChanged:0,changed:0,droppedToggled:0,unchanged:0,droppedAdded:0,droppedRemoved:0,componentsAdded:0,componentsRemoved:0,componentsChanged:0,depsAdded:0,depsRemoved:0},f=0,p=[];for(let t of s){let n=rt(t.base,t.head);if(n===`unchanged`){d.unchanged++;continue}if(n===`dropped-toggled`){d.droppedToggled++,p.push({status:`dropped-toggled`,before:t.base,after:t.head,direction:it(t.head)});continue}if(n===`moved`){d.moved++,p.push({status:`moved`,before:t.base,after:t.head,rationale:t.rationale});continue}if(n===`changed`){d.changed++,p.push({status:`changed`,before:t.base,after:t.head,delta:C(t.base,t.head,e.delta??{})});continue}d.movedChanged++,p.push({status:`moved+changed`,before:t.base,after:t.head,rationale:t.rationale,delta:C(t.base,t.head,e.delta??{})})}let m=o.remainingHead,h=o.remainingBase,g=l(e.baseIR),_=l(e.headIR),v=_.lostFiles,y=g.lostFiles;for(let e of m){if(e.dropped){d.droppedAdded++;continue}let t=y.get(e.source.file);if(t!==void 0){f++,p.push({status:`unknown`,symbol:e,absentFrom:`base`,reason:t});continue}d.added++,p.push({status:`added`,symbol:e})}for(let e of h){if(e.dropped){d.droppedRemoved++;continue}let t=v.get(e.source.file);if(t!==void 0){f++,p.push({status:`unknown`,symbol:e,absentFrom:`head`,reason:t});continue}d.removed++,p.push({status:`removed`,symbol:e})}let b=c(e.baseIR.components,e.headIR.components);d.componentsAdded=b.added.length,d.componentsRemoved=b.removed.length,d.componentsChanged=b.changed.length;let x=u(e.baseIR.dependencies,e.headIR.dependencies,{base:g,head:_});d.depsAdded=x.added.length,d.depsRemoved=x.removed.length,d.depsUnknown=x.unknown.length,d.unknown=f,p.sort(ht);let S=Ke({changes:p,baseCallEdges:i(e.baseIR),headCallEdges:i(e.headIR)});return{$schema:`https://aburi.kage1020.com/schema/aburi.diff.v1.json`,generator:e.generator??at,base:e.base,head:e.head,summary:d,symbols:p,components:b,dependencies:x,slices:S,notCompared:st(y,v)}}function st(e,t){let n=[];for(let[r,i]of e){let e=t.get(r);e!==void 0&&n.push({path:r,baseReason:i,headReason:e})}return n.sort((e,t)=>e.path<t.path?-1:+(e.path>t.path))}function ct(e,t){if(e.$schema!==t.$schema)throw new s(`Base IR schema "${e.$schema}" does not match head IR schema "${t.$schema}"; a diff across schema versions is not supported.`,{code:`schema-mismatch`,value:e.$schema})}const Q=e=>e.join(``),lt=[{field:`symbols`,identityFields:[`id`],keyOf:Q,noun:`id`,show:Q,consequence:`stage 1 pairs Symbols by id and every later stage tracks the base Symbols it has consumed by id, so a repeat leaves one entry out of the diff entirely or classifies its counterpart twice (ir-schema.md §14 #1)`},{field:`components`,identityFields:[`id`],keyOf:Q,noun:`id`,show:Q,consequence:`Component identity is the id, so a repeat hides one entry and can report a change the two revisions do not contain (ir-schema.md §14 #2)`},{field:`dependencies`,identityFields:f,keyOf:p,noun:`(from, to, via) triple`,show:e=>`(${e.join(`, `)})`,consequence:`direction and effect are deliberately outside Dependency identity (§6.2), so a repeat surfaces as an added + removed pair no reader can tell from a real flip (ir-schema.md §14 #13)`}];function ut(e,t){let r=n(e),i=r[0];if(i!==void 0){let e=dt(t,i.subject),n=r.length-1,a=n>0?` (and ${n} more)`:``;throw new s(`${e}: ${i.message}${a}.`,{code:`ir-shape-invalid`,value:e,violations:r.map(e=>({...e,subject:dt(t,e.subject)}))})}if(e.$schema.length===0)throw $(t,`${t}: "$schema" is empty, not a schema URL.`);for(let n of lt)ft(e[n.field],`${t}.${n.field}`,n)}function dt(t,n){return n===e?t:`${t}.${n}`}function ft(e,t,n){if(!Array.isArray(e))throw $(t,`${t} must be an array.`);let r=new Map;for(let[i,a]of e.entries()){let e=`${t}[${i}]`,o=pt(a,e,n),c=n.keyOf(o),l=r.get(c);if(l===void 0){r.set(c,i);continue}let u=n.show(o);throw new s(`${e} repeats the ${n.noun} "${u}" first seen at index ${l}; ${n.consequence}.`,{code:`ir-identity-collision`,value:u})}}function pt(e,t,n){if(typeof e!=`object`||!e||Array.isArray(e))throw $(t,`${t} must be an object; got ${mt(e)}.`);let r=[];for(let i of n.identityFields){let n=e[i];if(typeof n!=`string`)throw $(`${t}.${i}`,`${t}.${i} must be a string; got ${mt(n)}.`);r.push(n)}return r}function $(e,t){return new s(t,{code:`ir-shape-invalid`,value:e})}function mt(e){return e===void 0?`undefined`:e===null?`null`:Array.isArray(e)?`an array`:`a ${typeof e}`}function ht(e,t){if(e.status!==t.status)return e.status<t.status?-1:1;let n=gt(e),r=gt(t);return n<r?-1:+(n>r)}function gt(e){return e.status===`added`||e.status===`removed`||e.status===`unknown`?e.symbol.id:e.after.id}function _t(e,t={}){return a(e,t)}export{S as DEFAULT_LINE_FUZZ,s as DiffError,ee as MAX_LINE_FUZZ,te as MIN_LINE_FUZZ,Z as assertSliceRecordInvariant,ot as buildDiff,rt as classifyStatus,Ke as computeSlices,C as computeSymbolDelta,l as dependencySideView,c as diffComponents,u as diffDependencies,it as dropDirection,be as jaccard,xe as jaccardTokens,R as lastSegment,Y as matchStageDroppedWeak,H as matchStageGitRename,V as matchStageId,U as matchStageLogicFingerprint,G as matchStageNameSignature,Ce as memberSimilarity,Se as nameSimilarity,we as ownersAreCompatible,E as signatureSimilarity,Ye as sliceAnchor,Xe as sliceRecordViolation,O as tokenizeName,_t as writeCanonicalDiff};