@aburi/diff 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1041 @@
+import { serializeCanonical } from "@aburi/core";
+
+//#region src/components.ts
+/**
+* §6.1 — Component diff. 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 (§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
+	};
+}
+/**
+* §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).
+*/
+function diffDependencies(base, head) {
+	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 = [];
+	for (const [key, dep] of headKeys) {
+		const b = baseKeys.get(key);
+		if (b === void 0) {
+			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)) removed.push(dep);
+	added.sort(compareDependencies);
+	removed.sort(compareDependencies);
+	return {
+		added,
+		removed
+	};
+}
+function dependencyKey(d) {
+	return `${d.from}::${d.to}::${d.via}`;
+}
+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;
+}
+/**
+* Two-index diff: build key-indexed maps for both sides, then classify each key into
+* `added` / `removed` / `modified`. Line-fuzzed identities are matched within tolerance
+* so cosmetic line shifts do not produce added/removed noise. `modified` only fires when
+* the identity key stays the same but the content differs.
+*/
+function differentiate(base, head, isEqual, lineFuzz) {
+	const added = [];
+	const removed = [];
+	const modified = [];
+	const consumedBase = /* @__PURE__ */ new Set();
+	for (const h of head) {
+		let matchIdx = -1;
+		for (let j = 0; j < base.length; j++) {
+			if (consumedBase.has(j)) continue;
+			const b = base[j];
+			if (b === void 0) continue;
+			if (b.key !== h.key) continue;
+			if (Math.abs(b.line - h.line) > lineFuzz) continue;
+			matchIdx = j;
+			break;
+		}
+		if (matchIdx === -1) {
+			added.push(h.item);
+			continue;
+		}
+		consumedBase.add(matchIdx);
+		const bmatch = base[matchIdx];
+		if (bmatch === void 0) continue;
+		if (!isEqual(bmatch.item, h.item)) modified.push(h.item);
+	}
+	for (let j = 0; j < base.length; j++) {
+		if (consumedBase.has(j)) continue;
+		const b = base[j];
+		if (b === void 0) continue;
+		removed.push(b.item);
+	}
+	return {
+		added,
+		removed,
+		modified
+	};
+}
+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
+	});
+	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))
+		};
+	}
+	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.
+*/
+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) {
+	if (a.length === 0 && b.length === 0) return 1;
+	if (a.length === 0 || b.length === 0) return 0;
+	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 intersection / union;
+}
+/** name-token Jaccard shortcut used by nameSimilarity and ownerSimilarity call sites. */
+function jaccardTokens(a, b) {
+	return jaccard(tokenizeName(a), tokenizeName(b));
+}
+/**
+* §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 jaccardTokens(baseName, headName);
+}
+/**
+* §3.4.6 — owner similarity: same as nameSimilarity but restricted to everything **before**
+* the last segment. Compensates for the R-8 same-name-different-class collision, where
+* `UserRepo.getUser` should not be pair-swapped with `AdminRepo.getUser`.
+*
+* Owner extraction:
+* - `Class::method` → `Class`
+* - `A.B.C.method` → `A.B.C`
+* - `topLevel`     → `` (empty)
+*
+* When both owners are empty (top-level functions), returns 1.0 because both live in the
+* same "no-owner" bucket. When one is empty and the other is not, returns 0.0 because the
+* two Symbols live in structurally different scopes.
+*/
+function ownerSimilarity(baseName, headName) {
+	const baseOwner = extractOwner(baseName);
+	const headOwner = extractOwner(headName);
+	if (baseOwner === "" && headOwner === "") return 1;
+	if (baseOwner === "" || headOwner === "") return 0;
+	return jaccardTokens(baseOwner, headOwner);
+}
+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.1 — segments Symbols with identical `id` into paired matches. Runs first because it
+* is the highest-confidence signal (no heuristics, just hash lookup).
+*/
+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.
+*
+* 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 matched = [];
+	const usedHead = /* @__PURE__ */ new Set();
+	const remaining = [];
+	for (const b of remainingBase) {
+		const newPath = renameMap.get(b.source.file);
+		if (newPath === void 0) {
+			remaining.push(b);
+			continue;
+		}
+		const expectedId = rewriteIdFile(b.id, b.source.file, newPath);
+		const h = headById.get(expectedId);
+		if (h === void 0 || usedHead.has(h.id)) {
+			remaining.push(b);
+			continue;
+		}
+		matched.push({
+			base: b,
+			head: h,
+			rationale: "git-rename"
+		});
+		usedHead.add(h.id);
+	}
+	return {
+		matched,
+		remainingBase: remaining,
+		remainingHead: remainingHead.filter((h) => !usedHead.has(h.id))
+	};
+}
+function rewriteIdFile(id, oldPath, newPath) {
+	const colon = id.indexOf(":");
+	const hash = id.indexOf("#");
+	if (colon < 0 || hash < 0 || hash < colon) return id;
+	const language = id.slice(0, colon);
+	if (id.slice(colon + 1, hash) !== oldPath) return id;
+	return `${language}:${newPath}${id.slice(hash)}`;
+}
+/**
+* §3.3 — group base Symbols by `fingerprint.logic` and match head Symbols whose logic
+* fingerprint is in the map. Two disambiguation branches:
+* - single candidate → paired with `logic-fingerprint`
+* - multiple candidates → best `nameSimilarity` wins if ≥ 0.85; otherwise leave both
+*   sides in remaining 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 logicMap = /* @__PURE__ */ new Map();
+	const carryBase = [];
+	for (const b of remainingBase) {
+		if (b.dropped || b.fingerprint.logic === ZERO_LOGIC_FP) {
+			carryBase.push(b);
+			continue;
+		}
+		const bucket = logicMap.get(b.fingerprint.logic) ?? [];
+		bucket.push(b);
+		logicMap.set(b.fingerprint.logic, bucket);
+	}
+	const matched = [];
+	const carryHead = [];
+	const usedBaseIds = /* @__PURE__ */ new Set();
+	for (const h of remainingHead) {
+		if (h.dropped || h.fingerprint.logic === ZERO_LOGIC_FP) {
+			carryHead.push(h);
+			continue;
+		}
+		const candidates = logicMap.get(h.fingerprint.logic);
+		if (candidates === void 0 || candidates.length === 0) {
+			carryHead.push(h);
+			continue;
+		}
+		if (candidates.length === 1) {
+			const only = candidates[0];
+			if (only === void 0) continue;
+			matched.push({
+				base: only,
+				head: h,
+				rationale: "logic-fingerprint"
+			});
+			usedBaseIds.add(only.id);
+			logicMap.delete(h.fingerprint.logic);
+			continue;
+		}
+		let best = null;
+		for (const c of candidates) {
+			const score = nameSimilarity(c.name, h.name);
+			if (best === null || score > best.score) best = {
+				symbol: c,
+				score
+			};
+		}
+		if (best !== null && best.score >= .85) {
+			matched.push({
+				base: best.symbol,
+				head: h,
+				rationale: "logic-fingerprint+name-disambiguation"
+			});
+			usedBaseIds.add(best.symbol.id);
+			const remainingBucket = candidates.filter((c) => c.id !== best?.symbol.id);
+			if (remainingBucket.length === 0) logicMap.delete(h.fingerprint.logic);
+			else logicMap.set(h.fingerprint.logic, remainingBucket);
+		} else carryHead.push(h);
+	}
+	const finalBase = [...carryBase];
+	for (const bucket of logicMap.values()) for (const b of bucket) if (!usedBaseIds.has(b.id)) finalBase.push(b);
+	return {
+		matched,
+		remainingBase: finalBase,
+		remainingHead: carryHead
+	};
+}
+/**
+* §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.
+*
+* The composite score:
+*   0.5 * nameSimilarity + 0.3 * signatureSimilarity + 0.2 * ownerSimilarity
+*
+* §3.4.3 threshold table:
+* - 1-token name → 1.0 (unreachable → never paired; false-positive shield)
+* - 2-token name → 0.95 (strict, avoids `getUser` vs `getUsers`)
+* - default      → 0.85
+*
+* §3.4.3 tail — if both sides are signature-less, we skip pairing entirely because
+* signatureSimilarity always returns 1.0 for `null + null` and would flood the bucket with
+* false pairings.
+*/
+function matchStageNameSignature(remainingBase, remainingHead) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const b of remainingBase) {
+		if (b.dropped) continue;
+		const key = bucketKey(b);
+		const bucket = buckets.get(key) ?? [];
+		bucket.push(b);
+		buckets.set(key, bucket);
+	}
+	const matched = [];
+	const remainingHeadOut = [];
+	const usedBaseIds = /* @__PURE__ */ new Set();
+	for (const h of remainingHead) {
+		if (h.dropped) {
+			remainingHeadOut.push(h);
+			continue;
+		}
+		const key = bucketKey(h);
+		const bucket = buckets.get(key);
+		if (bucket === void 0 || bucket.length === 0) {
+			remainingHeadOut.push(h);
+			continue;
+		}
+		if ((h.signature === null || h.signature === void 0) && bucket.every((c) => c.signature === null || c.signature === void 0)) {
+			remainingHeadOut.push(h);
+			continue;
+		}
+		let best = null;
+		for (const c of bucket) {
+			const score = .5 * nameSimilarity(c.name, h.name) + .3 * signatureSimilarity(c.signature ?? null, h.signature ?? null) + .2 * ownerSimilarity(c.name, h.name);
+			if (best === null || score > best.score) best = {
+				symbol: c,
+				score
+			};
+		}
+		const threshold = thresholdFor(h.name);
+		if (best !== null && best.score >= threshold) {
+			matched.push({
+				base: best.symbol,
+				head: h,
+				rationale: "name-signature"
+			});
+			usedBaseIds.add(best.symbol.id);
+			buckets.set(key, bucket.filter((c) => c.id !== best?.symbol.id));
+		} else remainingHeadOut.push(h);
+	}
+	const remainingBaseOut = [];
+	for (const b of remainingBase) {
+		if (b.dropped) {
+			remainingBaseOut.push(b);
+			continue;
+		}
+		if (!usedBaseIds.has(b.id)) remainingBaseOut.push(b);
+	}
+	return {
+		matched,
+		remainingBase: remainingBaseOut,
+		remainingHead: remainingHeadOut
+	};
+}
+function bucketKey(s) {
+	const sig = s.signature === null || s.signature === void 0 ? "no-sig" : "has-sig";
+	return `${s.kind}::${sig}`;
+}
+function thresholdFor(qname) {
+	const tokens = tokenizeName(lastSegment(qname)).length;
+	if (tokens <= 1) return 1;
+	if (tokens === 2) return .95;
+	return .85;
+}
+/**
+* §3.4.5 — dropped-only weak matcher. For dropped Symbols the fingerprint is zeroed and
+* name/signature are the only remaining signals. Score is a coarse "did the last name
+* segment or file basename survive?" — if either half matches we pair (threshold 0.5).
+*
+* This is deliberately lax; diff-algorithm.md §3.4.5 already accepts that dropped Symbols live
+* outside the main IR review surface, so occasional false pairings only affect the
+* "Drop-rule variation" fold-out section in the Markdown projection.
+*/
+function matchStageDroppedWeak(remainingBase, remainingHead) {
+	const droppedBase = remainingBase.filter((s) => s.dropped);
+	const nonDroppedBase = remainingBase.filter((s) => !s.dropped);
+	const droppedHead = remainingHead.filter((s) => s.dropped);
+	const nonDroppedHead = remainingHead.filter((s) => !s.dropped);
+	const matched = [];
+	const usedBaseIds = /* @__PURE__ */ new Set();
+	const carryHead = [];
+	for (const h of droppedHead) {
+		let best = null;
+		for (const b of droppedBase) {
+			if (b.kind !== h.kind) continue;
+			if (usedBaseIds.has(b.id)) continue;
+			const nameHit = lastSegment(b.name) === lastSegment(h.name) ? 1 : 0;
+			const fileHit = basename(b.source.file) === basename(h.source.file) ? 1 : 0;
+			const score = .5 * nameHit + .5 * fileHit;
+			if (best === null || score > best.score) best = {
+				symbol: b,
+				score
+			};
+		}
+		if (best !== null && best.score >= .5) {
+			matched.push({
+				base: best.symbol,
+				head: h,
+				rationale: "dropped-weak-match"
+			});
+			usedBaseIds.add(best.symbol.id);
+		} else carryHead.push(h);
+	}
+	return {
+		matched,
+		remainingBase: [...nonDroppedBase, ...droppedBase.filter((b) => !usedBaseIds.has(b.id))],
+		remainingHead: [...nonDroppedHead, ...carryHead]
+	};
+}
+function basename(path) {
+	const slash = path.lastIndexOf("/");
+	return slash >= 0 ? path.slice(slash + 1) : path;
+}
+
+//#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
+* (同 file、同 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.dev/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) {
+	assertIRShape(input.baseIR, "baseIR");
+	assertIRShape(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 = {
+		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
+	};
+	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;
+	for (const h of finalRemainingHead) if (h.dropped) summary.droppedAdded++;
+	else {
+		summary.added++;
+		symbols.push({
+			status: "added",
+			symbol: h
+		});
+	}
+	for (const b of finalRemainingBase) if (b.dropped) summary.droppedRemoved++;
+	else {
+		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);
+	summary.depsAdded = dependencies.added.length;
+	summary.depsRemoved = dependencies.removed.length;
+	symbols.sort(compareSymbolChange);
+	return {
+		$schema: DIFF_SCHEMA,
+		generator: input.generator ?? DEFAULT_GENERATOR,
+		base: input.base,
+		head: input.head,
+		summary,
+		symbols,
+		components,
+		dependencies
+	};
+}
+/** §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
+	});
+}
+/**
+* Top-level shape check. Refuses to enter the 5-stage matcher when a caller hands in an
+* IR-shaped object that is missing one of the collections the matcher requires as an
+* array. Without this, a malformed `baseIR = { symbols: undefined, ... }` would crash
+* deep inside `matchStageId` with `TypeError: undefined is not iterable`, leaving the
+* root cause obscured. Not a full schema validation — just an entry-point smoke test.
+*/
+function assertIRShape(ir, name) {
+	if (ir === null || typeof ir !== "object") throw new DiffError(`${name} must be an IR object; got ${typeof ir}.`, {
+		code: "ir-shape-invalid",
+		value: name
+	});
+	if (typeof ir.$schema !== "string" || ir.$schema.length === 0) throw new DiffError(`${name}.$schema must be a non-empty schema URL.`, {
+		code: "ir-shape-invalid",
+		value: `${name}.$schema`
+	});
+	for (const field of [
+		"symbols",
+		"components",
+		"dependencies"
+	]) if (!Array.isArray(ir[field])) throw new DiffError(`${name}.${field} must be an array.`, {
+		code: "ir-shape-invalid",
+		value: `${name}.${field}`
+	});
+}
+/**
+* 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") return change.symbol.id;
+	return change.after.id;
+}
+/**
+* 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, buildDiff, classifyStatus, computeSymbolDelta, diffComponents, diffDependencies, dropDirection, jaccard, jaccardTokens, lastSegment, matchStageDroppedWeak, matchStageGitRename, matchStageId, matchStageLogicFingerprint, matchStageNameSignature, nameSimilarity, ownerSimilarity, signatureSimilarity, tokenizeName, writeCanonicalDiff };
+//# sourceMappingURL=index.mjs.map