@0xcraft/powershot 1.1.3 → 1.1.5

package/dist/verifiers/foreign-reinvented.js

@@ -1,4 +1,6 @@
-import { finding, topLevelDeclarations } from './foreign-tokens.js';
+import { posix } from 'node:path';
+import { createReinventionScopeResolver, implementationFingerprint } from '#app/reinvention.js';
+import { finding, reusableDeclarations } from './foreign-tokens.js';
 /** Names too common to mean anything across files, as in the TypeScript version. */
 const GENERIC = new Set([
     'render', 'handler', 'handle', 'create', 'update', 'remove', 'delete', 'insert',
@@ -14,6 +16,26 @@ const GENERIC = new Set([
  * repository this was the single largest source of noise.
  */
 const TESTISH = /(^|\/)(tests?|spec|__tests__)\/|(^|\/)(test_[^/]+|[^/]+_test|[^/]+\.(test|spec))\.[a-z]+$/;
+function normalized(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function declarationIndex(root, pack, path) {
+    const index = new Map();
+    const sourceScope = pack.name === 'go'
+        ? ['directory:' + posix.dirname(path.replaceAll('\\', '/'))]
+        : [];
+    for (const declaration of reusableDeclarations(root, pack, path)) {
+        const { scope, name, node, tokens } = declaration;
+        // Declaration names deliberately bridge snake/camel spelling. Language
+        // namespaces do not: changing only their case still names a different scope in
+        // case-sensitive languages.
+        const key = [...sourceScope, ...scope].join('::') + '|' + normalized(name);
+        const list = index.get(key) ?? [];
+        list.push({ name, node, fingerprint: implementationFingerprint(tokens) });
+        index.set(key, list);
+    }
+    return index;
+}
 export const foreignReinvented = {
     name: 'reinvented',
     needs: ['syntax'],
@@ -24,39 +46,78 @@ export const foreignReinvented = {
         // Keyed by language as well as name: a Ruby `charge` and a C++ `charge` are two
         // unrelated functions that happen to share a word, and calling that duplication
         // would be nonsense — nothing can be reused across the boundary anyway.
+        const scopeFor = createReinventionScopeResolver(g.root);
         const index = new Map();
+        const declarations = new Map();
         for (const file of g.foreign) {
-            if (TESTISH.test(file.path))
+            declarations.set(file.path, {
+                current: declarationIndex(file.tree.rootNode, file.pack, file.path),
+                base: file.beforeTree
+                    ? declarationIndex(file.beforeTree.rootNode, file.pack, file.changed.beforePath ?? file.path)
+                    : undefined,
+            });
+        }
+        for (const file of g.foreign) {
+            if (TESTISH.test(file.path) || !file.beforeTree)
                 continue;
-            for (const [name, decl] of topLevelDeclarations(file.tree.rootNode, file.pack)) {
-                const key = file.pack.name + '|' + name.toLowerCase().replace(/[^a-z0-9]/g, '');
-                const list = index.get(key) ?? [];
-                list.push({ file: file.path, line: decl.startPosition.row + 1 });
-                index.set(key, list);
+            const fileDeclarations = declarations.get(file.path);
+            for (const [nameKey, baseDeclarations] of fileDeclarations.base ?? []) {
+                for (const baseDeclaration of baseDeclarations) {
+                    const currentDeclaration = (fileDeclarations.current.get(nameKey) ?? []).find((declaration) => declaration.fingerprint === baseDeclaration.fingerprint);
+                    // The reusable declaration must both predate the change and remain available
+                    // at the reviewed head. A removed or rewritten helper is not a candidate.
+                    if (!currentDeclaration)
+                        continue;
+                    const beforePath = file.changed.beforePath ?? file.path;
+                    if (scopeFor(beforePath) !== scopeFor(file.path))
+                        continue;
+                    const key = file.pack.name + '|' + nameKey;
+                    const list = index.get(key) ?? [];
+                    list.push({
+                        file: file.path,
+                        line: currentDeclaration.node.startPosition.row + 1,
+                        fingerprint: baseDeclaration.fingerprint,
+                        scope: scopeFor(file.path),
+                    });
+                    index.set(key, list);
+                }
             }
         }
         for (const file of g.foreign) {
             if (TESTISH.test(file.path))
                 continue;
-            for (const [name, decl] of topLevelDeclarations(file.tree.rootNode, file.pack)) {
-                const line = decl.startPosition.row + 1;
-                if (!file.changed.added.has(line))
-                    continue;
-                if (name.length < 6 || GENERIC.has(name.toLowerCase()))
-                    continue;
-                const key = file.pack.name + '|' + name.toLowerCase().replace(/[^a-z0-9]/g, '');
-                const match = (index.get(key) ?? []).find((e) => e.file !== file.path);
-                // report the pair once, from the file that declares it later
-                if (!match || match.file < file.path)
-                    continue;
-                findings.push(finding(file, decl, {
-                    check: 'reinvented',
-                    severity: 'medium',
-                    confidence: 'firm',
-                    title: name + '() duplicates a declaration in ' + match.file,
-                    evidence: { oracle: file.pack.name + ' declarations', detail: 'already declared at ' + match.file + ':' + match.line },
-                    fix: 'Reuse the existing one instead of redeclaring it',
-                }));
+            if (file.changed.beforePath && file.changed.beforePath !== file.path)
+                continue;
+            const fileDeclarations = declarations.get(file.path);
+            for (const [nameKey, currentDeclarations] of fileDeclarations.current) {
+                for (const { name, node: decl, fingerprint } of currentDeclarations) {
+                    const line = decl.startPosition.row + 1;
+                    if (!file.changed.added.has(line))
+                        continue;
+                    if (name.length < 6 || GENERIC.has(name.toLowerCase()))
+                        continue;
+                    const existedHere = (fileDeclarations.base?.get(nameKey) ?? []).some((baseDeclaration) => baseDeclaration.fingerprint === fingerprint);
+                    if (existedHere)
+                        continue;
+                    const key = file.pack.name + '|' + nameKey;
+                    const scope = scopeFor(file.path);
+                    const match = (index.get(key) ?? []).find((candidate) => candidate.file !== file.path &&
+                        candidate.scope === scope &&
+                        candidate.fingerprint === fingerprint);
+                    if (!match)
+                        continue;
+                    findings.push(finding(file, decl, {
+                        check: 'reinvented',
+                        severity: 'medium',
+                        confidence: 'firm',
+                        title: name + ' repeats the implementation at ' + match.file,
+                        evidence: {
+                            oracle: file.pack.name + ' base declaration + token fingerprint',
+                            detail: 'token-identical implementation already present at ' + match.file + ':' + match.line,
+                        },
+                        fix: 'Consider reusing the existing declaration; if the separation is intentional, keep the boundary explicit',
+                    }));
+                }
             }
         }
         return findings;

package/dist/verifiers/foreign-tokens.js

@@ -1,14 +1,28 @@
+import { posix } from 'node:path';
 import { nodesOfType, walk } from '#app/lang/packs.js';
+import { implementationFingerprint } from '#app/reinvention.js';
 /**
- * In tree-sitter-rust and -go a `string_literal` has exactly two children, the quotes,
- * and the text between them belongs to no node — so walking to leaves loses it, and
- * two files differing only in what their strings say tokenize identically. Atomic.
+ * Some wasm grammars leave meaningful text outside child nodes: Rust/Go string
+ * contents and Kotlin's nullable `?` are examples. Keep those enclosing nodes atomic
+ * so a value or contract change cannot disappear from the fingerprint.
  */
-const ATOMIC = /string|char|raw_|heredoc|interpolat/;
+const ATOMIC = /string|char|raw_|heredoc|interpolat|nullable_type/;
 /** The token stream: what a compiler sees, minus layout and comments. */
-export function tokensFor(root, pack) {
+function nodeKey(node) {
+    return [
+        node.type,
+        node.startPosition.row,
+        node.startPosition.column,
+        node.endPosition.row,
+        node.endPosition.column,
+    ].join(':');
+}
+export function tokensFor(root, pack, exclude) {
     const out = [];
+    const excluded = new Set((exclude === undefined ? [] : Array.isArray(exclude) ? exclude : [exclude]).map(nodeKey));
     const visit = (n) => {
+        if (excluded.has(nodeKey(n)))
+            return;
         if (pack.nodes.comment.includes(n.type))
             return;
         if (ATOMIC.test(n.type)) {
@@ -29,6 +43,13 @@ export function tokensFor(root, pack) {
     visit(root);
     return out;
 }
+/** Tokens that affect compilation, including comment-shaped file constraints. */
+export function sourceTokensFor(root, pack, exclude) {
+    return [
+        ...(pack.fileConstraints?.(root) ?? []).map((text) => ({ type: '__file_constraint__', text })),
+        ...tokensFor(root, pack, exclude),
+    ];
+}
 export function commentText(root, pack) {
     const parts = [];
     walk(root, (n) => {
@@ -52,6 +73,16 @@ export function documentsSomething(root, pack) {
 export function same(a, b) {
     return a.length === b.length && a.every((t, i) => t.type === b[i].type && t.text === b[i].text);
 }
+/** Layout-insensitive identity of a file's declared package/module, when it has one. */
+export function fileScopeIdentity(root, pack) {
+    const tokens = root.namedChildren
+        .filter((child) => pack.nodes.fileScope.includes(child.type))
+        .flatMap((child) => tokensFor(child, pack));
+    const constraints = pack.fileConstraints?.(root) ?? [];
+    return tokens.length === 0 && constraints.length === 0
+        ? undefined
+        : 'file:' + JSON.stringify({ tokens, constraints });
+}
 export function finding(file, node, f) {
     return {
         id: '',
@@ -68,27 +99,208 @@ export function finding(file, node, f) {
  */
 export function declaredName(decl, pack) {
     const field = decl.childForFieldName(pack.nodes.declarationName);
+    // tree-sitter-kotlin exposes the declaration identifier as a named child but
+    // assigns no field name to it. Keep the grammar field authoritative when one is
+    // present; otherwise the first identifier inside the declaration is its name.
     if (!field)
-        return undefined;
+        return nodesOfType(decl, pack.nodes.identifier)[0]?.text;
     if (field.childCount === 0)
         return field.text;
     // C and C++ wrap the name in a declarator; look inside that, never wider
     return nodesOfType(field, pack.nodes.identifier)[0]?.text;
 }
-/** Module level only: two classes sharing a method name is polymorphism. */
-export function topLevelDeclarations(root, pack) {
-    const all = nodesOfType(root, pack.nodes.declaration);
-    const out = new Map();
-    for (const decl of all) {
-        const nested = all.some((other) => other !== decl &&
-            other.startPosition.row <= decl.startPosition.row &&
-            other.endPosition.row >= decl.endPosition.row);
-        if (nested)
-            continue;
-        const name = declaredName(decl, pack);
-        if (name)
-            out.set(name, decl);
+export function reusableDeclarations(root, pack, bindingPath = '') {
+    const raw = [];
+    const contexts = [];
+    const bindings = [];
+    const namesIn = (tokens) => [
+        ...new Set(tokens.filter((token) => pack.nodes.bindingIdentifier.includes(token.type)).map((token) => token.text)),
+    ];
+    const addBinding = (scope, node, tokens, indexNames) => {
+        if (indexNames.length > 0) {
+            bindings.push({
+                node,
+                tokens,
+                scope,
+                indexNames,
+                references: namesIn(tokens),
+                fingerprint: implementationFingerprint([
+                    { type: '__binding_scope__', text: JSON.stringify(scope) },
+                    ...tokens,
+                ]),
+            });
+        }
+    };
+    const visit = (container, scope, fingerprintRoot) => {
+        let prefix = [];
+        let blocked = false;
+        for (const child of container.namedChildren) {
+            if (pack.nodes.comment.includes(child.type))
+                continue;
+            if (pack.nodes.reusablePrefix.includes(child.type)) {
+                prefix.push(child);
+                continue;
+            }
+            if (pack.nodes.reusableBlocker.includes(child.type)) {
+                blocked = true;
+                continue;
+            }
+            if (pack.nodes.bindingContext.includes(child.type)) {
+                contexts.push({ scope, node: child, tokens: tokensFor(child, pack) });
+                prefix = [];
+                blocked = false;
+                continue;
+            }
+            if (pack.nodes.reusableDeclaration.includes(child.type)) {
+                if (blocked || (pack.reusableAcrossFiles && !pack.reusableAcrossFiles(child))) {
+                    prefix = [];
+                    blocked = false;
+                    continue;
+                }
+                const name = declaredName(child, pack);
+                if (!name) {
+                    if (pack.nodes.bindingDeclaration.includes(child.type)) {
+                        const bindingTokens = tokensFor(child, pack);
+                        addBinding(scope, child, bindingTokens, namesIn(bindingTokens));
+                    }
+                    prefix = [];
+                    blocked = false;
+                    continue;
+                }
+                const ownTokens = [
+                    ...prefix.flatMap((node) => tokensFor(node, pack)),
+                    ...tokensFor(fingerprintRoot ?? child, pack),
+                ];
+                raw.push({
+                    scope,
+                    name,
+                    node: child,
+                    tokens: ownTokens,
+                });
+                addBinding(scope, child, ownTokens, [name]);
+                prefix = [];
+                blocked = false;
+                continue;
+            }
+            if (pack.nodes.bindingDeclaration.includes(child.type)) {
+                const bindingTokens = tokensFor(child, pack);
+                addBinding(scope, child, bindingTokens, namesIn(bindingTokens));
+                prefix = [];
+                blocked = false;
+                continue;
+            }
+            if (!pack.nodes.reusableContainer.includes(child.type)) {
+                prefix = [];
+                blocked = false;
+                continue;
+            }
+            let nextScope = scope;
+            if (pack.nodes.reusableScope.includes(child.type)) {
+                const name = child.childForFieldName('name')?.text;
+                // An anonymous namespace cannot provide a cross-file reuse candidate.
+                if (!name)
+                    continue;
+                nextScope = [...scope, name];
+            }
+            visit(child, nextScope, fingerprintRoot ?? (pack.nodes.reusableWrapper.includes(child.type) ? child : undefined));
+            prefix = [];
+            blocked = false;
+        }
+    };
+    const fileScope = fileScopeIdentity(root, pack);
+    visit(root, fileScope ? [fileScope] : []);
+    const scopeKey = (scope) => JSON.stringify(scope);
+    const scopePrefixes = (scope) => Array.from({ length: scope.length + 1 }, (_, length) => scopeKey(scope.slice(0, length)));
+    const byName = new Map();
+    for (const binding of bindings) {
+        for (const name of binding.indexNames) {
+            const byScope = byName.get(name) ?? new Map();
+            const scoped = byScope.get(scopeKey(binding.scope)) ?? [];
+            scoped.push(binding);
+            byScope.set(scopeKey(binding.scope), scoped);
+            byName.set(name, byScope);
+        }
     }
-    return out;
+    const needsBindingDirectory = (tokens) => {
+        const text = tokens.map((token) => token.text).join(' ');
+        return /\brequire_relative\b|\b(?:require|include)(?:_once)?\b|\bfrom\s+\.+|["']\.\.?\/|#\s*include\s*"|\buse\s+(?:self|super)\s*::|\bmod\s+[A-Za-z_]\w*\s*;/.test(text);
+    };
+    const contextsByScope = new Map();
+    for (const context of contexts) {
+        const scoped = contextsByScope.get(scopeKey(context.scope)) ?? [];
+        scoped.push(context);
+        contextsByScope.set(scopeKey(context.scope), scoped);
+    }
+    const contextCache = new Map();
+    const contextFor = (scope) => {
+        const key = scopeKey(scope);
+        const known = contextCache.get(key);
+        if (known)
+            return known;
+        const visibleContexts = scopePrefixes(scope)
+            .flatMap((prefix) => contextsByScope.get(prefix) ?? [])
+            .sort((left, right) => left.node.startPosition.row - right.node.startPosition.row ||
+            left.node.startPosition.column - right.node.startPosition.column);
+        const ordered = visibleContexts.flatMap((context) => [
+            { type: '__binding_scope__', text: JSON.stringify(context.scope) },
+            ...context.tokens,
+        ]);
+        const value = {
+            tokens: ordered.length === 0
+                ? []
+                : [{ type: '__binding_context__', text: implementationFingerprint(ordered) }],
+            needsDirectory: visibleContexts.some((context) => needsBindingDirectory(context.tokens)),
+        };
+        contextCache.set(key, value);
+        return value;
+    };
+    const identity = (node) => [
+        node.type,
+        node.startPosition.row,
+        node.startPosition.column,
+        node.endPosition.row,
+        node.endPosition.column,
+    ].join(':');
+    return raw.map((declaration) => {
+        const context = contextFor(declaration.scope);
+        const selected = new Map();
+        const pending = namesIn(declaration.tokens);
+        const visitedNames = new Set();
+        const target = identity(declaration.node);
+        while (pending.length > 0) {
+            const name = pending.pop();
+            if (visitedNames.has(name))
+                continue;
+            visitedNames.add(name);
+            const byScope = byName.get(name);
+            for (const binding of scopePrefixes(declaration.scope).flatMap((prefix) => byScope?.get(prefix) ?? [])) {
+                const key = identity(binding.node);
+                if (key === target || selected.has(key))
+                    continue;
+                selected.set(key, binding);
+                // More than this is a generated binding graph, not a helper a human can
+                // meaningfully reuse. Abstain instead of doing quadratic work on it.
+                if (selected.size > 512)
+                    return [];
+                for (const referenced of binding.references) {
+                    if (!visitedNames.has(referenced))
+                        pending.push(referenced);
+                }
+            }
+        }
+        const bindingTokens = [...selected.values()]
+            .sort((left, right) => left.node.startPosition.row - right.node.startPosition.row ||
+            left.node.startPosition.column - right.node.startPosition.column)
+            .map((binding) => ({ type: '__binding__', text: binding.fingerprint }));
+        const directoryToken = bindingPath !== '' && (context.needsDirectory ||
+            needsBindingDirectory(declaration.tokens) ||
+            [...selected.values()].some((binding) => needsBindingDirectory(binding.tokens)))
+            ? [{ type: '__binding_directory__', text: posix.dirname(bindingPath.replaceAll('\\', '/')) }]
+            : [];
+        return [{
+                ...declaration,
+                tokens: [...directoryToken, ...context.tokens, ...bindingTokens, ...declaration.tokens],
+            }];
+    }).flat();
 }
 //# sourceMappingURL=foreign-tokens.js.map

package/dist/verifiers/guard-diff.js

@@ -0,0 +1,138 @@
+import { packFor } from '#app/lang/packs.js';
+import { implementationFingerprint, typescriptSourceFingerprint } from '#app/reinvention.js';
+import { sourceTokensFor } from './foreign-tokens.js';
+const NATIVE_SOURCE = /\.[cm]?[jt]sx?$/i;
+const EXECUTABLE_CHANGES = new WeakMap();
+function executableChanges(g) {
+    const known = EXECUTABLE_CHANGES.get(g);
+    if (known)
+        return known;
+    const changed = new Set();
+    const represented = new Set();
+    for (const file of g.files) {
+        represented.add(file.changed.path);
+        const after = typescriptSourceFingerprint(file.sf.getFullText());
+        const before = typescriptSourceFingerprint(file.before?.getFullText() ?? '');
+        if (!after || !before || after !== before || file.changed.beforePath !== undefined) {
+            changed.add(file.changed.path);
+        }
+    }
+    for (const file of g.foreign) {
+        represented.add(file.path);
+        const after = implementationFingerprint(sourceTokensFor(file.tree.rootNode, file.pack));
+        const before = implementationFingerprint(file.beforeTree ? sourceTokensFor(file.beforeTree.rootNode, file.pack) : []);
+        if (after !== before || file.changed.beforePath !== undefined)
+            changed.add(file.path);
+    }
+    const supported = (path) => path !== undefined && (NATIVE_SOURCE.test(path) || packFor(path) !== undefined);
+    for (const file of g.inventory ?? g.changed) {
+        if (represented.has(file.path))
+            continue;
+        if (supported(file.path) || supported(file.beforePath))
+            changed.add(file.path);
+    }
+    EXECUTABLE_CHANGES.set(g, changed);
+    return changed;
+}
+/**
+ * A guard transfer into another changed file is outside a local syntax proof. Keep a
+ * HIGH/proven result only when every other supported source file is token-stable.
+ */
+export function hasOtherExecutableChange(g, currentPath) {
+    const changed = executableChanges(g);
+    return changed.size > (changed.has(currentPath) ? 1 : 0);
+}
+/**
+ * Return the guards removed by an otherwise token-identical block rewrite.
+ *
+ * This is deliberately a narrow proof. A helper extraction, inserted validation call,
+ * changed continuation, or moved statement makes the block ambiguous and produces no
+ * deterministic finding. Those changes need semantic judgement; a pre/post syntax
+ * oracle cannot honestly call them lost guards.
+ */
+function guardOnlyDeletion(before, after) {
+    const removed = [];
+    let left = 0;
+    let right = 0;
+    while (left < before.entries.length && right < after.entries.length) {
+        const old = before.entries[left];
+        const current = after.entries[right];
+        if (old.fingerprint === current.fingerprint) {
+            left++;
+            right++;
+            continue;
+        }
+        if (old.guard !== undefined) {
+            // A guard only protects a continuation in its own block. If it is the last
+            // meaningful statement, deleting it is not the failure this check promises.
+            if (before.entries.slice(left + 1).some((entry) => entry.guard === undefined)) {
+                removed.push({ id: old.id, ...old.guard });
+            }
+            left++;
+            continue;
+        }
+        return undefined;
+    }
+    if (right !== after.entries.length)
+        return undefined;
+    while (left < before.entries.length) {
+        const old = before.entries[left];
+        if (old.guard === undefined)
+            return undefined;
+        if (before.entries.slice(left + 1).some((entry) => entry.guard === undefined)) {
+            removed.push({ id: old.id, ...old.guard });
+        }
+        left++;
+    }
+    return removed.length > 0 ? removed : undefined;
+}
+/**
+ * Guards whose removal is the only executable change in a uniquely matched block.
+ * Ambiguous duplicate blocks are skipped rather than paired by traversal order.
+ */
+export function provenGuardRemovals(before, after) {
+    // A name is not a callable contract. Changing a parameter, receiver, owner, or
+    // return type can make a formerly necessary guard obsolete.
+    if (before.identity !== after.identity)
+        return [];
+    const uniqueByPath = (blocks) => {
+        const out = new Map();
+        for (const block of blocks) {
+            if (out.has(block.path))
+                out.set(block.path, undefined);
+            else
+                out.set(block.path, block);
+        }
+        return out;
+    };
+    const current = uniqueByPath(after.blocks);
+    const remainingGuards = new Set(after.blocks.flatMap((block) => block.entries.flatMap((entry) => entry.guard === undefined ? [] : [entry.guard.key])));
+    const structurallyRemoved = [];
+    for (const [path, previous] of uniqueByPath(before.blocks)) {
+        const now = current.get(path);
+        if (!previous || !now)
+            continue;
+        structurallyRemoved.push(...(guardOnlyDeletion(previous, now) ?? []));
+    }
+    if (structurallyRemoved.length === 0)
+        return [];
+    // A block-local diff is not enough: another branch or sibling statement may have
+    // changed the guarantee that made the guard obsolete. Remove the candidate guard
+    // nodes from the old callable and require every remaining compiler-visible token
+    // to equal the new callable. This is the fact behind the `proven` confidence.
+    const omitted = new Set(structurallyRemoved.map((guard) => guard.id));
+    const previousResidual = before.residualFingerprint(omitted);
+    const currentResidual = after.residualFingerprint(new Set());
+    if (!previousResidual || previousResidual !== currentResidual)
+        return [];
+    const reportable = new Map();
+    for (const guard of structurallyRemoved) {
+        // A syntactically identical guard elsewhere in the callable may dominate the
+        // continuation. Without a control-flow graph, abstaining is the only proof-safe
+        // answer; false negatives are preferable to a false HIGH/proven defect.
+        if (!remainingGuards.has(guard.key))
+            reportable.set(guard.key, guard.label);
+    }
+    return [...reportable.values()];
+}
+//# sourceMappingURL=guard-diff.js.map

package/dist/verifiers/reinvented.js

@@ -1,5 +1,6 @@
 import { SyntaxKind } from 'ts-morph';
 import { locate, normalizeName, relPath } from '#app/ground.js';
+import { createReinventionScopeResolver, typescriptImplementationFingerprint } from '#app/reinvention.js';
 /**
  * Names too generic to mean anything across files — two `render`s are usually
  * two different things, not a duplication.
@@ -10,13 +11,15 @@ const GENERIC = new Set([
     'handler', 'handle', 'create', 'update', 'remove', 'delete', 'list', 'find',
     'parse', 'format', 'load', 'save', 'toString', 'default', 'config', 'options',
 ]);
-function declaredNames(sf) {
+function declaredNames(sf, bindingPath) {
     const out = [];
     for (const fn of sf.getFunctions()) {
         const name = fn.getName();
         const id = fn.getNameNode();
-        if (name && id)
-            out.push({ name, line: fn.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span });
+        const fingerprint = typescriptImplementationFingerprint(fn, bindingPath);
+        if (name && id && fingerprint) {
+            out.push({ name, line: fn.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span, fingerprint });
+        }
     }
     for (const v of sf.getVariableDeclarations()) {
         const init = v.getInitializer();
@@ -24,7 +27,10 @@ function declaredNames(sf) {
             continue;
         if (init.isKind(SyntaxKind.ArrowFunction) || init.isKind(SyntaxKind.FunctionExpression)) {
             const id = v.getNameNode();
-            out.push({ name: v.getName(), line: v.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span });
+            const fingerprint = typescriptImplementationFingerprint(v, bindingPath);
+            if (fingerprint) {
+                out.push({ name: v.getName(), line: v.getStartLineNumber(), span: locate(sf, id.getStart(), id.getWidth()).span, fingerprint });
+            }
         }
     }
     return out;
@@ -35,19 +41,30 @@ export const reinvented = {
     needs: ['syntax'],
     run(g) {
         const findings = [];
-        for (const { sf, changed } of g.files) {
+        const scopeFor = createReinventionScopeResolver(g.root);
+        for (const { sf, changed, before } of g.files) {
             const file = relPath(sf, g.root);
+            const scope = scopeFor(file);
             // a fixture builder repeated across test files is a deliberate trade, and two
             // tests describing the same scenario naturally share a name
             if (TEST_FILE.test(file))
                 continue;
-            for (const { name, line, span } of declaredNames(sf)) {
+            const baseDeclarations = before ? declaredNames(before, changed.beforePath ?? file) : [];
+            for (const { name, line, span, fingerprint } of declaredNames(sf, file)) {
                 if (!changed.added.has(line))
                     continue;
+                if (changed.beforePath && changed.beforePath !== changed.path)
+                    continue;
                 if (name.length < 6 || GENERIC.has(name) || GENERIC.has(name.toLowerCase()))
                     continue;
-                const existing = (g.symbolIndex.get(normalizeName(name)) ?? []).filter((s) => s.file !== file);
-                const match = existing[0];
+                const existedHere = baseDeclarations.some((declaration) => normalizeName(declaration.name) === normalizeName(name) &&
+                    declaration.fingerprint === fingerprint);
+                if (existedHere)
+                    continue;
+                const match = (g.symbolIndex.get(normalizeName(name)) ?? []).find((symbol) => symbol.file !== file &&
+                    symbol.existedInBase &&
+                    symbol.scope === scope &&
+                    symbol.fingerprint === fingerprint);
                 if (!match)
                     continue;
                 findings.push({
@@ -59,12 +76,15 @@ export const reinvented = {
                     file,
                     line,
                     span,
-                    title: name + '() duplicates an existing export ' + match.file + ':' + match.name,
-                    evidence: { oracle: 'repo symbol index', detail: 'already exported from ' + match.file + ':' + match.line },
+                    title: name + '() repeats the implementation at ' + match.file + ':' + match.name,
+                    evidence: {
+                        oracle: 'base export + callable token fingerprint',
+                        detail: 'token-identical implementation already exported from ' + match.file + ':' + match.line,
+                    },
                     // Deliberately not an import statement: the correct specifier depends on the
                     // repo's module resolution, and a wrong one would be exactly the kind of
                     // confidently-wrong output this tool exists to catch.
-                    fix: 'Reuse ' + match.name + ' from ' + match.file + ' instead of redeclaring it',
+                    fix: 'Consider reusing ' + match.name + ' from ' + match.file + '; if the separation is intentional, keep the boundary explicit',
                 });
             }
         }