@0xcraft/powershot 1.1.3 → 1.1.5

package/dist/selftest.js

@@ -22,7 +22,7 @@ import { stripControl } from './text.js';
 import { review } from './review.js';
 import { withTargetTree } from './snapshot.js';
 import { loadConfig } from './config.js';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { insideRepo, repoPath } from './fspolicy.js';
 import { Budget, parseLimits } from './budget.js';
 import { SelectionPlan, capabilitiesOf } from './plan.js';
@@ -52,6 +52,7 @@ import { summarizeRun } from './report/summary.js';
 import { wrap } from './report/terminal.js';
 import { highlight, isJsx } from './report/highlight.js';
 import { buildGround, normalizeName, readEnvManifest, relPath } from './ground.js';
+import { exportedDeclarations, implementationFingerprint, reinventionScope, typescriptImplementationFingerprint, } from './reinvention.js';
 import { incompleteReasons } from './bench.js';
 import { PACKAGE_NAME, PACKAGE_VERSION } from './package-meta.js';
 import { addedLinesFromPatch, inlineMarker, parseReviewFindings, reconcileInlineComments, selectInlineComments, syncInlineComments, } from './github/inline-comments.js';
@@ -69,6 +70,7 @@ function ground(files, deps = []) {
         const lineCount = f.after.split('\n').length;
         const c = {
             path: f.path,
+            beforePath: f.beforePath,
             added: new Set(Array.from({ length: lineCount }, (_, i) => i + 1)),
             before: f.before,
         };
@@ -76,20 +78,36 @@ function ground(files, deps = []) {
         entries.push({
             sf,
             changed: c,
-            before: f.before === undefined ? undefined : beforeProject.createSourceFile('/before/' + f.path, f.before, { overwrite: true }),
+            before: f.before === undefined
+                ? undefined
+                : beforeProject.createSourceFile('/before/' + (f.beforePath ?? f.path), f.before, { overwrite: true }),
             typed: true,
         });
     }
     const symbolIndex = new Map();
     for (const sf of project.getSourceFiles()) {
         const rel = sf.getFilePath().slice(root.length + 1);
-        for (const [name, decls] of sf.getExportedDeclarations()) {
-            const decl = decls[0];
-            if (!decl)
+        const input = files.find((file) => file.path === rel);
+        for (const { name, node: decl } of exportedDeclarations(sf)) {
+            const fingerprint = typescriptImplementationFingerprint(decl, rel);
+            if (!fingerprint)
                 continue;
             const key = normalizeName(name);
             const list = symbolIndex.get(key) ?? [];
-            list.push({ file: rel, name, line: decl.getStartLineNumber() });
+            const beforePath = input?.beforePath ?? rel;
+            const before = input?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + beforePath);
+            const existedInBase = before && reinventionScope(root, beforePath) === reinventionScope(root, rel)
+                ? exportedDeclarations(before).some((baseDeclaration) => baseDeclaration.name === name &&
+                    typescriptImplementationFingerprint(baseDeclaration.node, beforePath) === fingerprint)
+                : false;
+            list.push({
+                file: rel,
+                name,
+                line: decl.getStartLineNumber(),
+                fingerprint,
+                existedInBase,
+                scope: reinventionScope(root, rel),
+            });
             symbolIndex.set(key, list);
         }
     }
@@ -120,6 +138,22 @@ async function checkAsync(name, fn) {
 function fires(v, g) {
     return v.run(g).length > 0;
 }
+async function javascriptReinvention(candidate) {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-javascript-reinvention-')));
+    try {
+        mkdirSync(join(dir, 'lib'), { recursive: true });
+        mkdirSync(join(dir, 'utils'), { recursive: true });
+        writeFileSync(join(dir, 'package.json'), '{"name":"fixture","private":true}');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"compilerOptions":{"allowJs":true},"include":["lib/**/*.mjs","utils/**/*.mjs"]}');
+        writeFileSync(join(dir, 'lib/normalize.mjs'), 'export function normalizePayload(value) { return value.trim() }\n');
+        writeFileSync(join(dir, 'utils/normalize.mjs'), candidate);
+        const g = await buildGround(dir, [{ path: 'utils/normalize.mjs', added: new Set([1]) }]);
+        return fires(reinvented, g);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
 console.log('\nphantom-dep');
 check('fires on an import that is not a declared dependency', () => {
     const g = ground([{ path: 'a.ts', after: "import ky from 'ky'\nexport const x = ky\n" }], ['zod']);
@@ -145,15 +179,115 @@ check('resolves a scoped subpath to its package', () => {
     assert.equal(fires(phantomDep, g), false);
 });
 console.log('\nreinvented');
+check('keeps every public alias for one exported declaration', () => {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const source = project.createSourceFile('/aliases.mjs', 'function helper(value) { return value }\nexport { helper, helper as normalizePayload }\n');
+    assert.deepEqual(exportedDeclarations(source).map((declaration) => declaration.name).sort(), ['helper', 'normalizePayload']);
+});
 check('fires when a helper already exists elsewhere', () => {
+    const existing = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
     const g = ground([
-        { path: 'lib/currency.ts', after: 'export function formatMinorUnits(n: number) { return n / 100 }\n' },
-        { path: 'utils/money.ts', after: 'export function formatMinorUnits(n: number) { return n / 100 }\n' },
+        { path: 'lib/currency.ts', before: existing, after: existing },
+        { path: 'utils/money.ts', after: existing },
     ]);
     const found = reinvented.run(g);
     assert.ok(found.length >= 1, 'expected a duplication finding');
     assert.equal(found[0].confidence, 'firm'); // heuristic, never claims `proven`
 });
+await checkAsync('fires on an exact JavaScript helper already present in the base', async () => {
+    assert.equal(await javascriptReinvention('export function normalizePayload(value) { return value.trim() }\n'), true);
+});
+await checkAsync('silent on a same-name JavaScript helper with different behavior', async () => {
+    assert.equal(await javascriptReinvention('export function normalizePayload(value) { return JSON.stringify(value) }\n'), false);
+});
+check('binds an implementation fingerprint to its import source', () => {
+    const existing = [
+        "import { transform } from './alpha.js'",
+        'export function normalizePayload(value: string) { return transform(value) }',
+        '',
+    ].join('\n');
+    const same = ground([
+        { path: 'lib/existing.ts', before: existing, after: existing },
+        { path: 'lib/added.ts', after: existing },
+    ]);
+    const different = ground([
+        { path: 'lib/existing.ts', before: existing, after: existing },
+        { path: 'lib/added.ts', after: existing.replace("'./alpha.js'", "'./beta.js'") },
+    ]);
+    assert.equal(fires(reinvented, same), true);
+    assert.equal(fires(reinvented, different), false);
+});
+check('binds an implementation fingerprint to referenced module locals', () => {
+    const source = (factor) => [
+        'const FACTOR = ' + factor,
+        'export function scalePayload(value: number) { return value * FACTOR }',
+        '',
+    ].join('\n');
+    const same = ground([
+        { path: 'lib/existing.ts', before: source(2), after: source(2) },
+        { path: 'lib/added.ts', after: source(2) },
+    ]);
+    const different = ground([
+        { path: 'lib/existing.ts', before: source(2), after: source(2) },
+        { path: 'lib/added.ts', after: source(3) },
+    ]);
+    assert.equal(fires(reinvented, same), true);
+    assert.equal(fires(reinvented, different), false);
+});
+check('qualifies relative imports by their source directory', () => {
+    const source = [
+        "import { transform } from './transform.js'",
+        'export function normalizePayload(value: string) { return transform(value) }',
+        '',
+    ].join('\n');
+    const sameDirectory = ground([
+        { path: 'lib/existing.ts', before: source, after: source },
+        { path: 'lib/added.ts', after: source },
+    ]);
+    const differentDirectory = ground([
+        { path: 'alpha/existing.ts', before: source, after: source },
+        { path: 'beta/added.ts', after: source },
+    ]);
+    assert.equal(fires(reinvented, sameDirectory), true);
+    assert.equal(fires(reinvented, differentDirectory), false);
+});
+check('binds an implementation fingerprint to TypeScript reference directives', () => {
+    const source = (target) => [
+        '/// <reference path="' + target + '" />',
+        'export function normalizePayload(value: Payload) { return value }',
+        '',
+    ].join('\n');
+    const g = ground([
+        { path: 'lib/existing.ts', before: source('./alpha.d.ts'), after: source('./alpha.d.ts') },
+        { path: 'lib/added.ts', after: source('./beta.d.ts') },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+check('silent when matching helpers are both new in the change', () => {
+    const added = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
+    const g = ground([
+        { path: 'lib/currency.ts', after: added },
+        { path: 'utils/money.ts', after: added },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+check('silent when the matching implementation already existed in the changed file', () => {
+    const existing = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
+    const g = ground([
+        { path: 'lib/currency.ts', before: existing, after: existing },
+        { path: 'utils/money.ts', before: existing, after: existing },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+check('silent when the candidate only became equivalent in this change', () => {
+    const before = 'export function formatMinorUnits(n: number) { return n / 10 }\n';
+    const after = 'export function formatMinorUnits(n: number) { return n / 100 }\n';
+    const g = ground([
+        { path: 'lib/currency.ts', before, after },
+        { path: 'utils/money.ts', after },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
 check('silent on a genuinely new name', () => {
     const g = ground([
         { path: 'lib/currency.ts', after: 'export function formatMinorUnits(n: number) { return n / 100 }\n' },
@@ -168,6 +302,125 @@ check('silent on short and generic names', () => {
     ]);
     assert.equal(fires(reinvented, g), false);
 });
+check('silent when only the helper name matches', () => {
+    const existing = 'export function runCheck(currentVersion: string, availableVersion: string) { return currentVersion !== availableVersion }\n';
+    const g = ground([
+        { path: 'web/use-app-updater.ts', before: existing, after: existing },
+        {
+            path: 'scripts/check-import-boundaries.mjs',
+            after: 'function runCheck({ srcRoot, allowlist }) { return allowlist.filter((entry) => !entry.startsWith(srcRoot)) }\n',
+        },
+    ]);
+    assert.equal(fires(reinvented, g), false);
+});
+await checkAsync('silent across package boundaries', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-scope-')));
+    try {
+        mkdirSync(join(dir, 'apps/web/src'), { recursive: true });
+        mkdirSync(join(dir, 'tools/scripts'), { recursive: true });
+        writeFileSync(join(dir, 'apps/web/package.json'), '{"name":"web","private":true}');
+        writeFileSync(join(dir, 'tools/scripts/package.json'), '{"name":"scripts","private":true}');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"compilerOptions":{"allowJs":true},"include":["apps/**/*.mjs","tools/**/*.mjs"]}');
+        writeFileSync(join(dir, 'apps/web/src/normalize.mjs'), 'export function normalizePayload(value) { return value.trim() }\n');
+        writeFileSync(join(dir, 'tools/scripts/normalize.mjs'), 'function normalizePayload(value) { return value.trim() }\n');
+        const g = await buildGround(dir, [
+            { path: 'tools/scripts/normalize.mjs', added: new Set([1]) },
+        ]);
+        assert.equal(fires(reinvented, g), false);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+await checkAsync('silent when only a new barrel alias gives the candidate a matching name', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-alias-')));
+    try {
+        mkdirSync(join(dir, 'lib'), { recursive: true });
+        mkdirSync(join(dir, 'scripts'), { recursive: true });
+        writeFileSync(join(dir, 'package.json'), '{"name":"fixture","private":true}');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"include":["lib/**/*.ts","scripts/**/*.ts"]}');
+        writeFileSync(join(dir, 'lib/base.ts'), 'export function calculateVersion(current: string, available: string) { return current !== available }\n');
+        writeFileSync(join(dir, 'lib/index.ts'), "export { calculateVersion as runCheck } from './base.js'\n");
+        writeFileSync(join(dir, 'scripts/run-check.ts'), 'function runCheck(current: string, available: string) { return current !== available }\n');
+        const g = await buildGround(dir, [
+            { path: 'lib/index.ts', added: new Set([1]), before: '' },
+            { path: 'scripts/run-check.ts', added: new Set([1]) },
+        ]);
+        assert.equal(fires(reinvented, g), false);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+check('recognizes package boundaries for every declared language family', () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-markers-')));
+    try {
+        const packages = [
+            ['typescript', 'package.json'],
+            ['python', 'pyproject.toml'],
+            ['rust', 'Cargo.toml'],
+            ['go', 'go.mod'],
+            ['jvm', 'build.gradle.kts'],
+            ['c-cpp', 'CMakeLists.txt'],
+            ['csharp', 'App.csproj'],
+            ['php', 'composer.json'],
+            ['ruby', 'Gemfile'],
+            ['solidity', 'foundry.toml'],
+        ];
+        for (const [name, marker] of packages) {
+            mkdirSync(join(dir, name, 'src'), { recursive: true });
+            writeFileSync(join(dir, name, marker), '');
+            assert.equal(reinventionScope(dir, name + '/src/file.txt'), name);
+        }
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+check('implementation fingerprints cannot confuse token boundaries with token text', () => {
+    const oneToken = implementationFingerprint([{ type: '1', text: 'x\u00002\u0000y' }]);
+    const twoTokens = implementationFingerprint([{ type: '1', text: 'x' }, { type: '2', text: 'y' }]);
+    assert.notEqual(oneToken, twoTokens);
+});
+check('public CLI rejects the name-only repro and keeps an exact-match control', () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-reinvented-cli-')));
+    const cli = join(process.cwd(), 'dist', 'cli.js');
+    const git = (...args) => {
+        execFileSync('git', args, { cwd: dir, stdio: ['ignore', 'ignore', 'pipe'] });
+    };
+    const run = () => {
+        const result = spawnSync(process.execPath, [cli, 'review', '--verify-only', '--checks', 'reinvented', '--from', 'HEAD~1', '--to', 'HEAD', '--format', 'compact'], { cwd: dir, env: { ...process.env, CI: 'true' }, encoding: 'utf8' });
+        return { status: result.status, stdout: result.stdout, stderr: result.stderr };
+    };
+    try {
+        git('init', '-q', '.');
+        git('config', 'user.name', 'PowerShot Tests');
+        git('config', 'user.email', 'tests@powershot.invalid');
+        mkdirSync(join(dir, 'src'), { recursive: true });
+        mkdirSync(join(dir, 'scripts'), { recursive: true });
+        writeFileSync(join(dir, 'package.json'), '{"name":"fixture","private":true}\n');
+        writeFileSync(join(dir, 'tsconfig.json'), '{"compilerOptions":{"allowJs":true},"include":["src/**/*.ts","scripts/**/*"]}\n');
+        const existing = 'export function runCheck(currentVersion: string, availableVersion: string) { return currentVersion !== availableVersion }\n';
+        writeFileSync(join(dir, 'src/use-app-updater.ts'), existing);
+        git('add', '.');
+        git('commit', '-q', '-m', 'base');
+        writeFileSync(join(dir, 'scripts/check-import-boundaries.mjs'), 'function runCheck({ srcRoot, allowlist }) { return allowlist.filter((entry) => !entry.startsWith(srcRoot)) }\n');
+        git('add', '.');
+        git('commit', '-q', '-m', 'different helper with same name');
+        const nameOnly = run();
+        assert.equal(nameOnly.status, 0, nameOnly.stderr || nameOnly.stdout);
+        assert.doesNotMatch(nameOnly.stdout, /\[reinvented\]/);
+        writeFileSync(join(dir, 'scripts/duplicate.ts'), existing);
+        git('add', '.');
+        git('commit', '-q', '-m', 'exact duplicate');
+        const exact = run();
+        assert.equal(exact.status, 1, exact.stderr || exact.stdout);
+        assert.match(exact.stdout, /\[reinvented\]/);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 console.log('\ndropped-guard');
 check('fires when an early-return guard disappears', () => {
     const before = 'export function close(inv: any) {\n  if (!inv.customer) return null\n  return inv.total\n}\n';
@@ -177,11 +430,33 @@ check('fires when an early-return guard disappears', () => {
     assert.equal(found.length, 1);
     assert.match(found[0].title, /!inv\.customer/);
 });
+check('fires when a JavaScript early-return guard disappears', () => {
+    const before = 'export function release(slot) {\n  if (!slot.ready()) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.mjs', after, before }])), true);
+});
+check('silent when JavaScript moves the guarded operation into a helper', () => {
+    const before = 'export function release(slot) {\n  if (!slot.ready()) return false\n  return slot.close()\n}\n';
+    const after = [
+        'export function release(slot) { return closeIfReady(slot) }',
+        'function closeIfReady(slot) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.mjs', after, before }])), false);
+});
 check('fires when a throwing guard disappears', () => {
     const before = 'export function pay(a: any) {\n  if (a <= 0) { throw new Error("bad") }\n  return a\n}\n';
     const after = 'export function pay(a: any) {\n  return a\n}\n';
     assert.equal(fires(droppedGuard, ground([{ path: 'pay.ts', after, before }])), true);
 });
+check('fires inside an arrow function', () => {
+    const before = 'export const release = (slot: any) => {\n  if (!slot.ready()) return false\n  return slot.close()\n}\n';
+    const after = 'export const release = (slot: any) => {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), true);
+});
 check('silent when the guard is kept, even if reformatted', () => {
     const before = 'export function close(inv: any) {\n  if (!inv.customer) return null\n  return inv.total\n}\n';
     const after = 'export function close(inv: any) {\n  if (!inv.customer)\n    return null\n  return inv.total * 2\n}\n';
@@ -194,6 +469,258 @@ check('silent when a rewrite respells the same guard for a new type', () => {
     const after = 'export function check(pool: number) {\n  if (pool === 0) return null\n  return pool\n}\n';
     assert.equal(fires(droppedGuard, ground([{ path: 'c.ts', after, before }])), false);
 });
+check('silent when the callable contract narrows with the removed guard', () => {
+    const before = [
+        'export function release(slot: { close(): boolean } | null) {',
+        '  if (!slot) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'export function release(slot: { close(): boolean }) {',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the callable owner contract narrows with the removed guard', () => {
+    const before = [
+        'export class Batch<T extends { close(): boolean } | null> {',
+        '  release(slot: T) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'export class Batch<T extends { close(): boolean }> {',
+        '  release(slot: T) {',
+        '    return slot.close()',
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('fires when an unchanged outer branch still contains the guard-only deletion', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before.replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), true);
+});
+check('silent when an outer branch is strengthened as the inner guard is removed', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace('if (enabled)', 'if (enabled && slot)')
+        .replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a sibling statement changes as a nested guard is removed', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  observe(slot)',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace('observe(slot)', 'ensureSlot(slot)')
+        .replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when an import binding changes as its guard is removed', () => {
+    const before = [
+        "import type { Slot } from './alpha.js'",
+        'export function release(slot: Slot | null) {',
+        '  if (!slot) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace("'./alpha.js'", "'./beta.js'")
+        .replace('  if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a module type changes as its guard is removed', () => {
+    const before = [
+        'type Slot = { close(): boolean } | null',
+        'export function release(slot: Slot) {',
+        '  if (!slot) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace(' | null', '')
+        .replace('  if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the same guard still protects the callable', () => {
+    const before = [
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  if (slot.shouldClose()) {',
+        '    if (!slot.ready()) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before.replace('    if (!slot.ready()) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('matches remaining guards by tokens rather than comments', () => {
+    const before = [
+        'export function release(slot: any, enabled: boolean) {',
+        '  if (!slot /* already checked */) return false',
+        '  if (enabled) {',
+        '    if (!slot) return false',
+        '    return slot.close()',
+        '  }',
+        '  return true',
+        '}',
+        '',
+    ].join('\n');
+    const after = before.replace('    if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the guarded operation moves behind a helper', () => {
+    const before = [
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'export function release(slot: any) {',
+        '  return closeIfReady(slot)',
+        '}',
+        'function closeIfReady(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when an already-called helper absorbs the guard', () => {
+    const before = [
+        'function closeSlot(slot: any) { return slot.close() }',
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return closeSlot(slot)',
+        '}',
+        '',
+    ].join('\n');
+    const after = [
+        'function closeSlot(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  return slot.close()',
+        '}',
+        'export function release(slot: any) {',
+        '  return closeSlot(slot)',
+        '}',
+        '',
+    ].join('\n');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a nested callable binding changes with the guard deletion', () => {
+    const before = [
+        'export function release(slot: any, fallback: any) {',
+        '  function closeSlot(value = slot) { return value.close() }',
+        '  if (!slot) return false',
+        '  return closeSlot()',
+        '}',
+        '',
+    ].join('\n');
+    const after = before
+        .replace('value = slot', 'value = fallback')
+        .replace('  if (!slot) return false\n', '');
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when a guarded file is renamed as the guard is deleted', () => {
+    const before = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'new/release.ts', beforePath: 'old/release.ts', after, before }])), false);
+});
+check('silent when another source is renamed to an unsupported suffix', () => {
+    const before = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    const g = ground([{ path: 'release.ts', after, before }]);
+    g.inventory = [
+        ...g.changed,
+        {
+            path: 'notes/helper.txt',
+            beforePath: 'src/helper.ts',
+            added: new Set(),
+            before: 'export function closeSlot(slot: any) { return slot.close() }\n',
+        },
+    ];
+    assert.equal(fires(droppedGuard, g), false);
+});
+check('silent when a TypeScript reference directive changes with the guard deletion', () => {
+    const before = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    const refs = (target) => '/// <reference path="' + target + '" />\nexport const stable = true\n';
+    const g = ground([
+        { path: 'release.ts', after, before },
+        { path: 'bindings.ts', after: refs('./beta.d.ts'), before: refs('./alpha.d.ts') },
+    ]);
+    assert.equal(fires(droppedGuard, g), false);
+});
+check('silent when a branch only conditionally returns', () => {
+    const before = [
+        'export function release(slot: any, force: boolean) {',
+        '  if (!slot.ready()) {',
+        '    if (force) return false',
+        '    slot.recordMiss()',
+        '  }',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = 'export function release(slot: any, force: boolean) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
+check('silent when the removed conditional had an else branch', () => {
+    const before = [
+        'export function release(slot: any) {',
+        '  if (!slot.ready()) return false',
+        '  else slot.recordReady()',
+        '  return slot.close()',
+        '}',
+        '',
+    ].join('\n');
+    const after = 'export function release(slot: any) {\n  return slot.close()\n}\n';
+    assert.equal(fires(droppedGuard, ground([{ path: 'release.ts', after, before }])), false);
+});
 check('silent when the guard became obsolete with the code it protected', () => {
     // found by bench: formatWeight moved from ounces to grams, so the old guards
     // referenced locals the rewritten function no longer has
@@ -550,6 +1077,7 @@ check('Git paths are read as NUL-delimited data and passed back literally', () =
         const changes = collectChanges(dir, {});
         const moved = changes.find((change) => change.path === renamed);
         assert.ok(moved?.before?.includes('before9'));
+        assert.equal(moved?.beforePath, tracked);
         assert.deepEqual([...moved.added], [10]);
         assert.ok(changes.some((change) => change.path === untracked));
     }
@@ -557,6 +1085,45 @@ check('Git paths are read as NUL-delimited data and passed back literally', () =
         rmSync(dir, { recursive: true, force: true });
     }
 });
+await checkAsync('deleted and policy-waived source stays in guard proof inventory', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'psh-deleted-proof-')));
+    const run = (...args) => {
+        execFileSync('git', args, { cwd: dir, stdio: ['ignore', 'ignore', 'pipe'] });
+    };
+    try {
+        run('init', '-q', '.');
+        run('config', 'user.email', 'tests@powershot.invalid');
+        run('config', 'user.name', 'PowerShot Tests');
+        mkdirSync(join(dir, 'src'), { recursive: true });
+        mkdirSync(join(dir, 'ignored'), { recursive: true });
+        const guarded = 'export function release(slot: any) {\n  if (!slot) return false\n  return slot.close()\n}\n';
+        const helper = 'export function closeSlot(slot: any) { return slot.close() }\n';
+        writeFileSync(join(dir, 'src/release.ts'), guarded);
+        writeFileSync(join(dir, 'ignored/helper.ts'), helper);
+        run('add', '.');
+        run('commit', '-qm', 'base');
+        writeFileSync(join(dir, 'src/release.ts'), 'export function release(slot: any) {\n  return slot.close()\n}\n');
+        rmSync(join(dir, 'ignored/helper.ts'));
+        const changes = collectChanges(dir, {});
+        const deleted = changes.find((change) => change.path === 'ignored/helper.ts');
+        assert.equal(deleted?.deleted, true);
+        assert.equal(deleted?.before, helper);
+        assert.equal(deleted?.added.size, 0);
+        const result = await review({
+            root: dir,
+            range: {},
+            config: { ...loadConfig(dir), ignore: ['ignored/**'] },
+            verifyOnly: true,
+            checks: ['dropped-guard'],
+        });
+        assert.equal(result.findings.some((finding) => finding.check === 'dropped-guard'), false);
+        const deletedPlan = result.plan?.items().find((item) => item.path === 'ignored/helper.ts');
+        assert.equal(deletedPlan?.disposition, 'waived');
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 check('lines split on either ending', () => {
     assert.deepEqual(splitLines('a\r\nb\nc'), ['a', 'b', 'c']);
     assert.equal(stripCR('a\r'), 'a');