@0xcraft/powershot 1.0.0

package/dist/verifiers/foreign-reinvented.js

@@ -0,0 +1,65 @@
+import { finding, topLevelDeclarations } 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',
+    'process', 'execute', 'convert', 'default', 'discover', 'initialize', 'configure',
+    'validate', 'serialize', 'deserialize', 'to_string', 'from_str', 'builder', 'build',
+]);
+/**
+ * Test modules are excluded on purpose.
+ *
+ * A fixture builder repeated in two test files is a deliberate trade — a test that
+ * reads on its own beats one coupled to a shared helper — and two test functions
+ * describing the same scenario naturally carry the same name. Measured on a real
+ * repository this was the single largest source of noise.
+ */
+const TESTISH = /(^|\/)(tests?|spec|__tests__)\/|(^|\/)(test_[^/]+|[^/]+_test|[^/]+\.(test|spec))\.[a-z]+$/;
+export const foreignReinvented = {
+    name: 'reinvented',
+    needs: ['syntax'],
+    run(g) {
+        const findings = [];
+        if (g.foreign.length < 2)
+            return findings;
+        // 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 index = new Map();
+        for (const file of g.foreign) {
+            if (TESTISH.test(file.path))
+                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);
+            }
+        }
+        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',
+                }));
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=foreign-reinvented.js.map

package/dist/verifiers/foreign-scope-creep.js

@@ -0,0 +1,42 @@
+import { commentText, documentsSomething, finding, same, tokensFor } from './foreign-tokens.js';
+/**
+ * Token-only, so it is the same check in every language: git says the file changed,
+ * the token stream says the program did not.
+ */
+export const foreignScopeCreep = {
+    name: 'scope-creep',
+    needs: ['syntax', 'base'],
+    run(g) {
+        const findings = [];
+        for (const file of g.foreign) {
+            if (!file.beforeTree)
+                continue;
+            const after = file.tree.rootNode;
+            const before = file.beforeTree.rootNode;
+            if (after.text === before.text)
+                continue;
+            if (!same(tokensFor(before, file.pack), tokensFor(after, file.pack)))
+                continue;
+            // Documentation is content. A change to `///` in Rust, a docstring in Python or
+            // a doc block anywhere is published API documentation someone meant to write,
+            // and telling them to revert it is wrong advice — so only pure layout churn is
+            // reported as something to undo.
+            const commentsChanged = commentText(before, file.pack) !== commentText(after, file.pack);
+            if (commentsChanged && documentsSomething(after, file.pack))
+                continue;
+            findings.push(finding(file, after, {
+                check: 'scope-creep',
+                severity: 'low',
+                confidence: 'proven',
+                title: 'This file changes only ' + (commentsChanged ? 'comments' : 'formatting') +
+                    ' — the program it produces is identical',
+                evidence: { oracle: file.pack.name + ' token stream', detail: 'before and after tokenize identically' },
+                fix: commentsChanged
+                    ? 'Keep it if the comments are the point; otherwise drop the file from the change'
+                    : 'Revert the reformatting so the diff shows the actual change',
+            }));
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=foreign-scope-creep.js.map

package/dist/verifiers/foreign-swallowed-error.js

@@ -0,0 +1,36 @@
+/**
+ * Error handling that defends nothing, in languages the TypeScript compiler cannot
+ * read. The rule is per-language because the idiom is: Python discards a failure with
+ * `except: pass`, Go with an `if err != nil` whose body does nothing. Each pack knows
+ * its own spelling; this verifier only asks.
+ */
+export const foreignSwallowedError = {
+    name: 'swallowed-error',
+    needs: ['syntax'],
+    supports: (file) => file.pack.swallowedError !== undefined,
+    run(g) {
+        const findings = [];
+        for (const file of g.foreign) {
+            for (const hit of file.pack.swallowedError?.(file.tree.rootNode) ?? []) {
+                const line = hit.node.startPosition.row + 1;
+                if (!file.changed.added.has(line))
+                    continue;
+                findings.push({
+                    id: '',
+                    class: 'verified',
+                    check: 'swallowed-error',
+                    severity: hit.what.includes('only logs') ? 'medium' : 'high',
+                    confidence: hit.what.includes('only logs') ? 'firm' : 'proven',
+                    file: file.path,
+                    line,
+                    span: { column: hit.node.startPosition.column + 1, length: Math.min(hit.node.text.split('\n')[0]?.length ?? 1, 80) },
+                    title: hit.what.charAt(0).toUpperCase() + hit.what.slice(1) + ' — the failure is discarded',
+                    evidence: { oracle: file.pack.name + ' AST', detail: 'parsed by tree-sitter; no type information required' },
+                    fix: 'Handle it, return it, or say in a comment why ignoring it is safe',
+                });
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=foreign-swallowed-error.js.map

package/dist/verifiers/foreign-tests.js

@@ -0,0 +1,143 @@
+const TEST_FILE = /(^|\/)(test_[^/]+|[^/]+_test)\.[a-z]+$|(^|\/)tests?\//;
+function at(file, node, f) {
+    return {
+        id: '',
+        class: 'verified',
+        file: file.path,
+        line: node.startPosition.row + 1,
+        span: { column: node.startPosition.column + 1, length: Math.min(node.text.split('\n')[0]?.length ?? 1, 80) },
+        ...f,
+    };
+}
+/** A test that runs code and proves nothing. */
+export const foreignVacuousTest = {
+    name: 'vacuous-test',
+    needs: ['syntax'],
+    supports: (file) => file.pack.tests !== undefined && TEST_FILE.test(file.path),
+    run(g) {
+        const findings = [];
+        for (const file of g.foreign) {
+            if (!file.pack.tests || !TEST_FILE.test(file.path))
+                continue;
+            for (const test of file.pack.tests(file.tree.rootNode)) {
+                const line = test.node.startPosition.row + 1;
+                if (!file.changed.added.has(line) || !test.provesNothing)
+                    continue;
+                findings.push(at(file, test.node, {
+                    check: 'vacuous-test',
+                    severity: 'high',
+                    confidence: 'proven',
+                    title: test.name + ' runs code but asserts nothing',
+                    evidence: {
+                        oracle: file.pack.name + ' test AST',
+                        detail: 'no assert, no assertion method, and no raises block anywhere in the body',
+                    },
+                }));
+            }
+        }
+        return findings;
+    },
+};
+/** The enclosing test with the expected value blanked out. */
+function contextOf(test, expectedNode) {
+    const text = test.text;
+    const offset = expectedNode.startPosition.row - test.startPosition.row;
+    const lines = text.split('\n');
+    const line = lines[offset];
+    if (line === undefined)
+        return text.replace(/\s+/g, ' ').trim();
+    const column = expectedNode.startPosition.row === test.startPosition.row
+        ? expectedNode.startPosition.column - test.startPosition.column
+        : expectedNode.startPosition.column;
+    lines[offset] = line.slice(0, column) + '\u0000' + line.slice(column + expectedNode.text.length);
+    return lines.join('\n').replace(/\s+/g, ' ').trim();
+}
+/** An expected value edited to match new output. */
+export const foreignAssertionDrift = {
+    name: 'assertion-drift',
+    needs: ['syntax', 'base'],
+    supports: (file) => file.pack.tests !== undefined && TEST_FILE.test(file.path),
+    run(g) {
+        const changedModules = new Set(g.changed
+            .map((f) => f.path)
+            .filter((p) => !TEST_FILE.test(p))
+            .map((p) => (p.split('/').pop() ?? '').replace(/\.[a-z]+$/, '')));
+        const findings = [];
+        for (const file of g.foreign) {
+            if (!file.pack.tests || !file.beforeTree || !TEST_FILE.test(file.path))
+                continue;
+            const subject = (file.path.split('/').pop() ?? '')
+                .replace(/\.[a-z]+$/, '')
+                .replace(/^test_/, '')
+                .replace(/_test$/, '');
+            if (changedModules.has(subject))
+                continue;
+            const now = new Map();
+            for (const t of file.pack.tests(file.tree.rootNode)) {
+                for (const a of t.assertions) {
+                    now.set(t.name + '|' + a.subject, { expected: a.expected, node: a.node, expectedNode: a.expectedNode, test: t.node });
+                }
+            }
+            for (const t of file.pack.tests(file.beforeTree.rootNode)) {
+                for (const a of t.assertions) {
+                    const is = now.get(t.name + '|' + a.subject);
+                    if (!is || is.expected === a.expected)
+                        continue;
+                    if (contextOf(is.test, is.expectedNode) !== contextOf(t.node, a.expectedNode))
+                        continue;
+                    findings.push(at(file, is.node, {
+                        check: 'assertion-drift',
+                        severity: 'high',
+                        confidence: 'firm',
+                        title: 'Expected value for `' + a.subject + '` changed from ' + a.expected + ' to ' + is.expected,
+                        evidence: {
+                            oracle: file.pack.name + ' pre/post test AST',
+                            detail: 'the module this test covers did not change — the expectation moved with nothing it measures',
+                        },
+                        fix: 'Confirm the new value is correct behaviour, not the test being bent to fit the code',
+                    }));
+                }
+            }
+        }
+        return findings;
+    },
+};
+/** Documentation that contradicts the signature it sits on. */
+export const foreignLyingComment = {
+    name: 'lying-comment',
+    needs: ['syntax'],
+    supports: (file) => file.pack.documentedParams !== undefined,
+    run(g) {
+        const findings = [];
+        for (const file of g.foreign) {
+            if (!file.pack.documentedParams)
+                continue;
+            for (const doc of file.pack.documentedParams(file.tree.rootNode)) {
+                for (const documented of doc.documented) {
+                    const line = documented.node.startPosition.row + 1;
+                    if (!file.changed.added.has(line))
+                        continue;
+                    if (doc.declared.includes(documented.name))
+                        continue;
+                    findings.push(at(file, documented.node, {
+                        check: 'lying-comment',
+                        severity: 'medium',
+                        confidence: 'proven',
+                        title: 'The docstring documents `' +
+                            documented.name +
+                            '`, which ' +
+                            doc.fn +
+                            '() does not take (' +
+                            (doc.declared.length > 0 ? 'it takes ' + doc.declared.join(', ') : 'it takes none') +
+                            ')',
+                        evidence: { oracle: 'signature', detail: 'the documented name is not in the parameter list' },
+                        fix: 'Update the docstring to the real parameters, or restore the argument it describes',
+                    }));
+                }
+            }
+        }
+        return findings;
+    },
+};
+export const FOREIGN_TEST_VERIFIERS = [foreignVacuousTest, foreignAssertionDrift, foreignLyingComment];
+//# sourceMappingURL=foreign-tests.js.map

package/dist/verifiers/foreign-tokens.js

@@ -0,0 +1,94 @@
+import { nodesOfType, walk } from '#app/lang/packs.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.
+ */
+const ATOMIC = /string|char|raw_|heredoc|interpolat/;
+/** The token stream: what a compiler sees, minus layout and comments. */
+export function tokensFor(root, pack) {
+    const out = [];
+    const visit = (n) => {
+        if (pack.nodes.comment.includes(n.type))
+            return;
+        if (ATOMIC.test(n.type)) {
+            out.push({ type: n.type, text: n.text });
+            return; // atomic: never descend, so the content is compared whole
+        }
+        if (n.childCount === 0) {
+            if (n.text.trim() !== '')
+                out.push({ type: n.type, text: n.text });
+            return;
+        }
+        for (let i = 0; i < n.childCount; i++) {
+            const child = n.child(i);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(root);
+    return out;
+}
+export function commentText(root, pack) {
+    const parts = [];
+    walk(root, (n) => {
+        if (pack.nodes.comment.includes(n.type))
+            parts.push(n.text.trim());
+    });
+    return parts.join('\n');
+}
+/** Doc comments — `///`, `//!`, JSDoc-style blocks — are documentation, not an aside. */
+export function documentsSomething(root, pack) {
+    let found = false;
+    walk(root, (n) => {
+        if (!pack.nodes.comment.includes(n.type))
+            return;
+        const t = n.text.trimStart();
+        if (t.startsWith('///') || t.startsWith('//!') || t.startsWith('/**') || t.startsWith('#:'))
+            found = true;
+    });
+    return found;
+}
+export function same(a, b) {
+    return a.length === b.length && a.every((t, i) => t.type === b[i].type && t.text === b[i].text);
+}
+export function finding(file, node, f) {
+    return {
+        id: '',
+        class: 'verified',
+        file: file.path,
+        line: node.startPosition.row + 1,
+        span: { column: node.startPosition.column + 1, length: Math.min(node.text.split('\n')[0]?.length ?? 1, 90) },
+        ...f,
+    };
+}
+/**
+ * The grammar's name field is authoritative whatever node type it is — Rust names a
+ * struct `type_identifier`. Second-guessing it by node type once returned `static`.
+ */
+export function declaredName(decl, pack) {
+    const field = decl.childForFieldName(pack.nodes.declarationName);
+    if (!field)
+        return undefined;
+    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);
+    }
+    return out;
+}
+//# sourceMappingURL=foreign-tokens.js.map

package/dist/verifiers/foreign.js

@@ -0,0 +1,16 @@
+import { foreignScopeCreep } from './foreign-scope-creep.js';
+import { foreignCopyPasteDrift } from './foreign-copy-paste-drift.js';
+import { foreignDroppedGuard } from './foreign-dropped-guard.js';
+import { foreignReinvented } from './foreign-reinvented.js';
+import { foreignPhantomConfig } from './foreign-phantom-config.js';
+export { foreignScopeCreep, foreignCopyPasteDrift, foreignDroppedGuard, foreignReinvented, foreignPhantomConfig };
+export { tokensFor } from './foreign-tokens.js';
+/** The checks that read a tree-sitter parse rather than a TypeScript program. */
+export const FOREIGN_VERIFIERS = [
+    foreignScopeCreep,
+    foreignCopyPasteDrift,
+    foreignDroppedGuard,
+    foreignReinvented,
+    foreignPhantomConfig,
+];
+//# sourceMappingURL=foreign.js.map

package/dist/verifiers/index.js

@@ -0,0 +1,38 @@
+import { phantomApi } from './phantom-api.js';
+import { phantomDep } from './phantom-dep.js';
+import { reinvented } from './reinvented.js';
+import { droppedGuard } from './dropped-guard.js';
+import { vacuousTest } from './vacuous-test.js';
+import { swallowedError } from './swallowed-error.js';
+import { assertionDrift } from './assertion-drift.js';
+import { contractDrift } from './contract-drift.js';
+import { scopeCreep } from './scope-creep.js';
+import { phantomConfig } from './phantom-config.js';
+import { copyPasteDrift } from './copy-paste-drift.js';
+import { deadOnArrival } from './dead-on-arrival.js';
+import { lyingComment } from './lying-comment.js';
+import { foreignSwallowedError } from './foreign-swallowed-error.js';
+import { FOREIGN_VERIFIERS } from './foreign.js';
+import { foreignPhantomDep } from './foreign-phantom-dep.js';
+import { foreignPhantomApi } from './foreign-phantom-api.js';
+import { foreignContractDrift } from './foreign-contract-drift.js';
+import { FOREIGN_TEST_VERIFIERS } from './foreign-tests.js';
+/** The tree-sitter half shares its names with the TypeScript half; the ids differ. */
+const tagged = (list) => list.map((v) => ({ ...v, id: 'foreign-' + v.name, domain: v.domain ?? 'foreign' }));
+export const VERIFIERS = [
+    ...[
+        phantomApi, phantomDep, reinvented, droppedGuard, swallowedError, vacuousTest,
+        assertionDrift, contractDrift, scopeCreep, phantomConfig, copyPasteDrift,
+        deadOnArrival, lyingComment,
+    ].map((v) => ({ ...v, domain: 'typescript' })),
+    ...tagged([
+        foreignSwallowedError,
+        ...FOREIGN_VERIFIERS,
+        foreignPhantomDep,
+        { ...foreignPhantomApi, domain: 'python' },
+        { ...foreignContractDrift, domain: 'python' },
+        ...FOREIGN_TEST_VERIFIERS,
+    ]),
+].map((v) => ({ ...v, id: v.id ?? v.name }));
+export { phantomApi, phantomDep, reinvented, droppedGuard, swallowedError, vacuousTest, assertionDrift, contractDrift, scopeCreep, phantomConfig, copyPasteDrift, deadOnArrival, lyingComment, };
+//# sourceMappingURL=index.js.map

package/dist/verifiers/lying-comment.js

@@ -0,0 +1,90 @@
+import { Node } from 'ts-morph';
+import { locate, relPath } from '#app/ground.js';
+function documentedFunctions(sf) {
+    const out = [];
+    const collect = (node, name) => {
+        if (!Node.isJSDocable(node))
+            return;
+        if (node.getJsDocs().length === 0)
+            return;
+        if (!Node.isFunctionDeclaration(node) && !Node.isMethodDeclaration(node))
+            return;
+        const params = node.getParameters();
+        out.push({
+            node,
+            name,
+            params: params.map((p) => p.getName()),
+            paramsReliable: params.every((p) => Node.isIdentifier(p.getNameNode())),
+            returns: node.getReturnTypeNode()?.getText() ?? '',
+        });
+    };
+    for (const fn of sf.getFunctions())
+        collect(fn, fn.getName() ?? 'function');
+    for (const cls of sf.getClasses()) {
+        for (const m of cls.getMethods())
+            collect(m, (cls.getName() ?? '') + '.' + m.getName());
+    }
+    return out;
+}
+const VOID_RETURN = new Set(['void', 'Promise<void>', 'never']);
+/** Documentation that contradicts the code it sits on. */
+export const lyingComment = {
+    name: 'lying-comment',
+    needs: ['syntax'],
+    run(g) {
+        const findings = [];
+        for (const { sf, changed } of g.files) {
+            const file = relPath(sf, g.root);
+            for (const fn of documentedFunctions(sf)) {
+                for (const doc of fn.node.getJsDocs()) {
+                    for (const tag of doc.getTags()) {
+                        const line = tag.getStartLineNumber();
+                        if (!changed.added.has(line))
+                            continue;
+                        const tagName = tag.getTagName();
+                        if (fn.paramsReliable && Node.isJSDocParameterTag(tag)) {
+                            // `@param options.retries` documents a property of a real parameter
+                            const root = tag.getName().split('.')[0] ?? '';
+                            if (root !== '' && !fn.params.includes(root)) {
+                                findings.push({
+                                    id: '',
+                                    class: 'verified',
+                                    check: 'lying-comment',
+                                    severity: 'medium',
+                                    confidence: 'proven',
+                                    file,
+                                    line,
+                                    span: locate(sf, tag.getStart(), tag.getWidth()).span,
+                                    title: '@param `' + root + '` documents an argument ' + fn.name + '() does not take (' +
+                                        (fn.params.length > 0 ? 'it takes ' + fn.params.join(', ') : 'it takes none') + ')',
+                                    evidence: { oracle: 'signature', detail: 'the documented name is not in the parameter list' },
+                                    fix: 'Update the doc to the real parameters, or restore the argument it describes',
+                                });
+                            }
+                        }
+                        if ((tagName === 'returns' || tagName === 'return') && VOID_RETURN.has(fn.returns)) {
+                            const text = tag.getCommentText()?.trim() ?? '';
+                            if (text !== '') {
+                                findings.push({
+                                    id: '',
+                                    class: 'verified',
+                                    check: 'lying-comment',
+                                    severity: 'medium',
+                                    confidence: 'proven',
+                                    file,
+                                    line,
+                                    span: locate(sf, tag.getStart(), tag.getWidth()).span,
+                                    title: '@returns describes a value, but ' + fn.name + '() is declared to return ' + fn.returns,
+                                    evidence: { oracle: 'signature', detail: 'the declared return type yields nothing to return' },
+                                    fix: 'Drop the @returns, or return the value the doc promises',
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=lying-comment.js.map

package/dist/verifiers/phantom-api.js

@@ -0,0 +1,88 @@
+import { locate, relPath } from '#app/ground.js';
+/**
+ * Compiler diagnostics that mean "the code refers to something that does not exist".
+ * Deliberately excludes 2307 (cannot find module) — phantom-dep owns that, so the
+ * same defect is never reported twice.
+ */
+const HALLUCINATION_CODES = new Map([
+    [2339, 'property does not exist on type'],
+    [2551, 'property does not exist on type (close match suggested)'],
+    [2554, 'wrong number of arguments'],
+    [2555, 'wrong number of arguments'],
+    [2724, 'module has no exported member'],
+    [2694, 'namespace has no exported member'],
+]);
+/**
+ * The checker often knows the right answer: "did you mean 'toUpperCase'?". Where it
+ * does, the finding carries an exact replacement rather than advice, which a review
+ * host can render as a one-click suggestion.
+ */
+function suggestedName(message) {
+    return /Did you mean '([^']+)'\?/.exec(message)?.[1];
+}
+/*
+ * "Cannot find name" (TS2304/2552) is deliberately absent. Bench showed it firing on
+ * `chrome` in a browser-extension package and on test-runner globals — it reports an
+ * incompletely resolved project, not an invented API, and in a monorepo that is the
+ * normal state when one root project spans many packages. The codes that really do
+ * mean "this does not exist" are the property and arity ones kept above.
+ */
+/** A diagnostic message is either a string or a nested chain — flatten it to one line. */
+function flatten(message) {
+    if (typeof message === 'string')
+        return message;
+    let text = message.getMessageText();
+    for (const next of message.getNext() ?? [])
+        text += ' ' + flatten(next);
+    return text;
+}
+/**
+ * The flagship check: an API the generated code invented. The TS checker answers
+ * exactly, so a hit here is proven — but only report hits on changed lines,
+ * otherwise this is just `tsc` output rather than a review.
+ */
+export const phantomApi = {
+    name: 'phantom-api',
+    needs: ['types'],
+    run(g) {
+        // Without a tsconfig the checker has no lib or path resolution, and every
+        // global would look invented. Refusing to run beats reporting garbage.
+        if (!g.typed)
+            return [];
+        const findings = [];
+        for (const { sf, changed, typed } of g.files) {
+            // a file the tsconfig does not include has no bound program; the checker
+            // throws rather than answering, and the answer would be garbage anyway
+            if (!typed)
+                continue;
+            const file = relPath(sf, g.root);
+            for (const d of sf.getPreEmitDiagnostics()) {
+                const code = d.getCode();
+                const label = HALLUCINATION_CODES.get(code);
+                if (!label)
+                    continue;
+                const start = d.getStart();
+                const line = d.getLineNumber();
+                if (line === undefined || !changed.added.has(line))
+                    continue;
+                const span = start === undefined ? undefined : locate(sf, start, d.getLength() ?? 1).span;
+                const detail = flatten(d.getMessageText());
+                findings.push({
+                    id: '',
+                    class: 'verified',
+                    check: 'phantom-api',
+                    severity: 'high',
+                    confidence: 'proven',
+                    file,
+                    line,
+                    span,
+                    title: detail,
+                    replacement: suggestedName(detail),
+                    evidence: { oracle: 'typescript', detail: 'TS' + code + ': ' + label },
+                });
+            }
+        }
+        return findings;
+    },
+};
+//# sourceMappingURL=phantom-api.js.map