@aburi/diff 0.2.0 → 0.4.0

package/src/diff.ts

@@ -1,250 +0,0 @@
-import { reconstructCallEdgesFromIR, type SerializeOptions, serializeCanonical } from "@aburi/core"
-import type { DiffResult, IR, IRRef, Summary, SymbolChange } from "@aburi/types"
-import { diffComponents, diffDependencies } from "./components"
-import { computeSymbolDelta, type DeltaOptions } from "./delta"
-import { DiffError } from "./errors"
-import {
-  type GitRenameMap,
-  matchStageDroppedWeak,
-  matchStageGitRename,
-  matchStageId,
-  matchStageLogicFingerprint,
-  matchStageNameSignature,
-  type SymbolPair,
-} from "./match"
-import { computeSlices } from "./slice"
-import { classifyStatus, dropDirection } from "./status"
-
-const DIFF_SCHEMA = "https://aburi.dev/schema/aburi.diff.v1.json"
-
-export interface DiffInput {
-  baseIR: IR
-  headIR: IR
-  /** IR reference metadata (git ref / file path) for provenance. */
-  base: IRRef
-  head: IRRef
-  /** Generator record for the diff output. Defaults to `{name: "aburi", version: "0.0.0"}`. */
-  generator?: { name: string; version: string }
-  /** Optional stage-2 rename table. When null/undefined stage 2 is skipped. */
-  gitRenames?: GitRenameMap | null
-  /** Passed through to computeSymbolDelta (§5.2.1 line fuzz). */
-  delta?: DeltaOptions
-}
-
-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.
- */
-export function buildDiff(input: DiffInput): DiffResult {
-  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: SymbolPair[] = [
-    ...stage1.matched,
-    ...stage2.matched,
-    ...stage3.matched,
-    ...stage4.matched,
-    ...stage4_5.matched,
-  ]
-
-  const summary: 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: SymbolChange[] = []
-  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
-    }
-    // moved+changed
-    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)
-
-  // Slice View clustering (docs/design/slice-view.md §2). Runs after status /
-  // delta computation and before Markdown projection. Consumes the resolved
-  // CallEdge[] reconstructed from each IR — §5.4 requires only resolved edges,
-  // never `Symbol.calls[]` directly. Emits `slices[]` unconditionally (§11.2);
-  // the Markdown side omits the section when the array is empty (§12.5).
-  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,
-  }
-}
-
-/** §9.1 — refuse to diff across schema versions. */
-function ensureSchemasAgree(base: IR, head: IR): void {
-  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: IR, name: "baseIR" | "headIR"): void {
-  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"] as const) {
-    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: SymbolChange, b: SymbolChange): number {
-  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: SymbolChange): string {
-  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.
- */
-export function writeCanonicalDiff(diff: DiffResult, options: SerializeOptions = {}): string {
-  return serializeCanonical(diff, options)
-}

package/src/errors.ts

@@ -1,44 +0,0 @@
-/**
- * Coded error class for every @aburi/diff failure. Consumers branch on `code` without
- * parsing message text. Codes are stable and additions are non-breaking; renames are not.
- */
-
-export type DiffErrorCode =
-  /** `base.$schema` and `head.$schema` disagree; a diff across schema versions cannot be trusted (§9.1). */
-  | "schema-mismatch"
-  /** `config.diff.lineFuzz` was outside the documented [0, 10] range (diff-algorithm.md §5.2.1). */
-  | "invalid-line-fuzz"
-  /**
-   * `baseIR` or `headIR` failed the top-level shape check that `buildDiff` enforces
-   * before touching any Symbol. Missing / non-array `symbols`, `components`,
-   * `dependencies`, or an absent `$schema` — anything that would otherwise crash with a
-   * cryptic `TypeError: undefined is not iterable` deep in a matching stage.
-   */
-  | "ir-shape-invalid"
-  /**
-   * A `SliceRecord` broke the derivation invariant of slice-view.md §7.1 / §8.2:
-   * `members[]` empty, `members[]` not in strictly ascending order, or `id` not
-   * equal to `"slice:" + members[0]`. The last two compare one property against
-   * another and so have no JSON Schema equivalent; the pass checks them itself
-   * (§7.4). Raised only by an Aburi bug, never by user input — see
-   * `SliceRecordViolation.kind` for which clause broke.
-   */
-  | "slice-invariant-violated"
-
-export interface DiffErrorDetail {
-  code: DiffErrorCode
-  /** Offending value (schema id, fuzz value, etc.) when applicable. */
-  value?: string
-}
-
-export class DiffError extends Error {
-  readonly code: DiffErrorCode
-  readonly value: string | undefined
-
-  constructor(message: string, detail: DiffErrorDetail, options?: { cause?: unknown }) {
-    super(message, options)
-    this.name = "DiffError"
-    this.code = detail.code
-    this.value = detail.value
-  }
-}

package/src/index.ts

@@ -1,54 +0,0 @@
-export {
-  diffComponents,
-  diffDependencies,
-} from "./components"
-export {
-  computeSymbolDelta,
-  DEFAULT_LINE_FUZZ,
-  type DeltaOptions,
-  MAX_LINE_FUZZ,
-  MIN_LINE_FUZZ,
-} from "./delta"
-export {
-  buildDiff,
-  type DiffInput,
-  writeCanonicalDiff,
-} from "./diff"
-export {
-  DiffError,
-  type DiffErrorCode,
-  type DiffErrorDetail,
-} from "./errors"
-export {
-  type GitRenameMap,
-  matchStageDroppedWeak,
-  matchStageGitRename,
-  matchStageId,
-  matchStageLogicFingerprint,
-  matchStageNameSignature,
-  type SymbolPair,
-} from "./match"
-export { signatureSimilarity } from "./signature"
-export {
-  jaccard,
-  jaccardTokens,
-  lastSegment,
-  nameSimilarity,
-  ownerSimilarity,
-  tokenizeName,
-} from "./similarity"
-export {
-  assertSliceRecordInvariant,
-  computeSlices,
-  type SliceInput,
-  type SliceRecordViolation,
-  type SliceViolationKind,
-  sliceAnchor,
-  sliceRecordViolation,
-} from "./slice"
-export {
-  classifyStatus,
-  type DropDirection,
-  dropDirection,
-  type SymbolStatus,
-} from "./status"

package/src/match.ts

@@ -1,351 +0,0 @@
-import { trySymbolId } from "@aburi/core"
-import type { Symbol as IRSymbol, MatchRationale, SymbolId } from "@aburi/types"
-import { signatureSimilarity } from "./signature"
-import { lastSegment, nameSimilarity, ownerSimilarity, tokenizeName } from "./similarity"
-
-/**
- * A concluded pairing of one base Symbol with one head Symbol, along with the
- * `MatchRationale` that placed them in the same pair. Stage 4 uses this shape both to
- * carry results out and to feed the delta / status classifier downstream.
- */
-export interface SymbolPair {
-  base: IRSymbol
-  head: IRSymbol
-  rationale: MatchRationale
-}
-
-/** Optional map returned by git for stage 2 (`old path` → `new path`). */
-export type GitRenameMap = ReadonlyMap<string, string>
-
-/** 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).
- */
-export function matchStageId(
-  base: readonly IRSymbol[],
-  head: readonly IRSymbol[],
-): {
-  matched: SymbolPair[]
-  remainingBase: IRSymbol[]
-  remainingHead: IRSymbol[]
-} {
-  const headById = new Map<SymbolId, IRSymbol>()
-  for (const s of head) headById.set(s.id, s)
-  const matched: SymbolPair[] = []
-  const remainingBase: IRSymbol[] = []
-  const usedHead = new Set<SymbolId>()
-  for (const b of base) {
-    const h = headById.get(b.id)
-    if (h !== undefined) {
-      matched.push({ base: b, head: h, rationale: "id-match" })
-      usedHead.add(b.id)
-    } else {
-      remainingBase.push(b)
-    }
-  }
-  const remainingHead = head.filter((h) => !usedHead.has(h.id))
-  return { matched, remainingBase, remainingHead }
-}
-
-/**
- * §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.
- */
-export function matchStageGitRename(
-  remainingBase: readonly IRSymbol[],
-  remainingHead: readonly IRSymbol[],
-  renameMap: GitRenameMap | null,
-): {
-  matched: SymbolPair[]
-  remainingBase: IRSymbol[]
-  remainingHead: IRSymbol[]
-} {
-  if (renameMap === null || renameMap.size === 0) {
-    return { matched: [], remainingBase: [...remainingBase], remainingHead: [...remainingHead] }
-  }
-  const headById = new Map<SymbolId, IRSymbol>()
-  for (const h of remainingHead) headById.set(h.id, h)
-  const matched: SymbolPair[] = []
-  const usedHead = new Set<SymbolId>()
-  const remaining: IRSymbol[] = []
-  for (const b of remainingBase) {
-    const newPath = renameMap.get(b.source.file)
-    if (newPath === undefined) {
-      remaining.push(b)
-      continue
-    }
-    const expectedId = rewriteIdFile(b.id, b.source.file, newPath)
-    const h = expectedId === null ? undefined : headById.get(expectedId)
-    if (h === undefined || usedHead.has(h.id)) {
-      remaining.push(b)
-      continue
-    }
-    matched.push({ base: b, head: h, rationale: "git-rename" })
-    usedHead.add(h.id)
-  }
-  const remainingHeadOut = remainingHead.filter((h) => !usedHead.has(h.id))
-  return { matched, remainingBase: remaining, remainingHead: remainingHeadOut }
-}
-
-/**
- * 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: SymbolId, oldPath: string, newPath: string): SymbolId | null {
-  const colon = id.indexOf(":")
-  const hash = id.indexOf("#")
-  if (colon < 0 || hash < 0 || hash < colon) return id
-  const filePart = id.slice(colon + 1, hash)
-  if (filePart !== oldPath) return id
-  return trySymbolId({
-    language: id.slice(0, colon),
-    file: newPath,
-    qualifiedName: id.slice(hash + 1),
-  })
-}
-
-/**
- * §3.3 — group base Symbols by `fingerprint.logic` and match head Symbols whose logic
- * 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.
- */
-export function matchStageLogicFingerprint(
-  remainingBase: readonly IRSymbol[],
-  remainingHead: readonly IRSymbol[],
-): {
-  matched: SymbolPair[]
-  remainingBase: IRSymbol[]
-  remainingHead: IRSymbol[]
-} {
-  const logicMap = new Map<string, IRSymbol[]>()
-  const carryBase: IRSymbol[] = []
-  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: SymbolPair[] = []
-  const carryHead: IRSymbol[] = []
-  const usedBaseIds = new Set<SymbolId>()
-  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 === undefined || candidates.length === 0) {
-      carryHead.push(h)
-      continue
-    }
-    if (candidates.length === 1) {
-      const only = candidates[0]
-      if (only === undefined) continue
-      matched.push({ base: only, head: h, rationale: "logic-fingerprint" })
-      usedBaseIds.add(only.id)
-      logicMap.delete(h.fingerprint.logic)
-      continue
-    }
-    let best: { symbol: IRSymbol; score: number } | null = 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 >= 0.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: IRSymbol[] = [...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.
- */
-export function matchStageNameSignature(
-  remainingBase: readonly IRSymbol[],
-  remainingHead: readonly IRSymbol[],
-): {
-  matched: SymbolPair[]
-  remainingBase: IRSymbol[]
-  remainingHead: IRSymbol[]
-} {
-  type BucketKey = string
-  const buckets = new Map<BucketKey, IRSymbol[]>()
-  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: SymbolPair[] = []
-  const remainingHeadOut: IRSymbol[] = []
-  const usedBaseIds = new Set<SymbolId>()
-  for (const h of remainingHead) {
-    if (h.dropped) {
-      remainingHeadOut.push(h)
-      continue
-    }
-    const key = bucketKey(h)
-    const bucket = buckets.get(key)
-    if (bucket === undefined || bucket.length === 0) {
-      remainingHeadOut.push(h)
-      continue
-    }
-    const headSigNull = h.signature === null || h.signature === undefined
-    if (headSigNull && bucket.every((c) => c.signature === null || c.signature === undefined)) {
-      remainingHeadOut.push(h)
-      continue
-    }
-    let best: { symbol: IRSymbol; score: number } | null = null
-    for (const c of bucket) {
-      const score =
-        0.5 * nameSimilarity(c.name, h.name) +
-        0.3 * signatureSimilarity(c.signature ?? null, h.signature ?? null) +
-        0.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: IRSymbol[] = []
-  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: IRSymbol): string {
-  const sig = s.signature === null || s.signature === undefined ? "no-sig" : "has-sig"
-  return `${s.kind}::${sig}`
-}
-
-function thresholdFor(qname: string): number {
-  const tokens = tokenizeName(lastSegment(qname)).length
-  if (tokens <= 1) return 1
-  if (tokens === 2) return 0.95
-  return 0.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.
- */
-export function matchStageDroppedWeak(
-  remainingBase: readonly IRSymbol[],
-  remainingHead: readonly IRSymbol[],
-): {
-  matched: SymbolPair[]
-  remainingBase: IRSymbol[]
-  remainingHead: IRSymbol[]
-} {
-  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: SymbolPair[] = []
-  const usedBaseIds = new Set<SymbolId>()
-  const carryHead: IRSymbol[] = []
-  for (const h of droppedHead) {
-    let best: { symbol: IRSymbol; score: number } | null = 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 = 0.5 * nameHit + 0.5 * fileHit
-      if (best === null || score > best.score) best = { symbol: b, score }
-    }
-    if (best !== null && best.score >= 0.5) {
-      matched.push({ base: best.symbol, head: h, rationale: "dropped-weak-match" })
-      usedBaseIds.add(best.symbol.id)
-    } else {
-      carryHead.push(h)
-    }
-  }
-  const carryBase: IRSymbol[] = [
-    ...nonDroppedBase,
-    ...droppedBase.filter((b) => !usedBaseIds.has(b.id)),
-  ]
-  return {
-    matched,
-    remainingBase: carryBase,
-    remainingHead: [...nonDroppedHead, ...carryHead],
-  }
-}
-
-function basename(path: string): string {
-  const slash = path.lastIndexOf("/")
-  return slash >= 0 ? path.slice(slash + 1) : path
-}