code-auditor-mcp 4.1.1 → 5.0.1

package/dist/phase/localBinding.js

@@ -0,0 +1,208 @@
+/**
+ * Spec 69 R3 — local binding resolution for `.where(and(...conditions))`.
+ *
+ * A `.where(...)` whose predicate spreads a local array binding
+ * (`and(...conditions)`) hides the tenant predicate from the query text: the
+ * `data-access-calls` producer extracts the candidate node's own text, which
+ * mentions `conditions` but not the `eq(orders.organizationId, …)` elements
+ * assembled in prior statements. This module resolves that spread to the
+ * elements — a local `const`/`let` array binding and its `.push(...)` calls —
+ * within the enclosing function body only. Syntactic and repo-local, no type
+ * checker, no cross-function analysis (Spec 69 R3's stated ceiling).
+ *
+ * The result distinguishes all-paths from some-paths: an element present in the
+ * array initializer, or pushed unconditionally, scopes the query on every path;
+ * an element pushed under an `if`/`switch`/ternary/`&&`/`||`/loop scopes it on
+ * only some paths. `missing-org-filter` reads this to go quiet only on an
+ * all-paths tenant predicate — a some-paths predicate still fires (the query
+ * executes unscoped on the branch where the guard is absent).
+ */
+const FUNCTION_NODE_TYPES = new Set([
+    'arrow_function',
+    'function_declaration',
+    'function_expression',
+    'generator_function_declaration',
+    'generator_function',
+    'method_definition',
+]);
+/** Loop kinds whose body runs 0..N times — a push inside is some-paths. */
+const LOOP_TYPES = new Set([
+    'for_statement',
+    'for_in_statement',
+    'while_statement',
+    'do_statement',
+]);
+function textOf(node, sourceCode, adapter) {
+    return adapter.getNodeText(node, sourceCode);
+}
+/** Direct children of a given node type (name/property/condition discovery). */
+function childrenOfType(node, type) {
+    return (node.children ?? []).filter((c) => c.type === type);
+}
+/** Array/argument expression children — filter out the `,` separator (the only
+ *  significant anonymous node inside an array literal or an argument list). */
+function expressionChildren(node) {
+    return (node.children ?? []).filter((c) => c.type !== ',');
+}
+/** Depth-first traversal that never descends into a nested function body — the
+ *  binding resolution is within-function only (Spec 69 R3's ceiling). */
+function collectWithin(node, predicate) {
+    const out = [];
+    const visit = (n, isRoot) => {
+        if (!isRoot && FUNCTION_NODE_TYPES.has(n.type))
+            return;
+        if (predicate(n))
+            out.push(n);
+        for (const c of n.children ?? [])
+            visit(c, false);
+    };
+    visit(node, true);
+    return out;
+}
+/** Plain full-subtree walk (used to find the spread inside the candidate call). */
+function walk(node, fn) {
+    fn(node);
+    for (const c of node.children ?? [])
+        walk(c, fn);
+}
+/** True when `node` is a `<binding>.push(...)` call. */
+function isPushCall(node, bindingName, sourceCode, adapter) {
+    if (node.type !== 'call_expression')
+        return false;
+    const member = (node.children ?? []).find((c) => c.type === 'member_expression');
+    if (!member)
+        return false;
+    const object = (member.children ?? []).find((c) => c.type === 'identifier');
+    const property = (member.children ?? []).find((c) => c.type === 'property_identifier');
+    if (!object || !property)
+        return false;
+    return (textOf(object, sourceCode, adapter) === bindingName &&
+        textOf(property, sourceCode, adapter) === 'push');
+}
+/** First argument of a call (the pushed element), skipping the `,` separator. */
+function firstArgument(callNode, sourceCode, adapter) {
+    const args = (callNode.children ?? []).find((c) => c.type === 'arguments');
+    if (!args)
+        return null;
+    return expressionChildren(args)[0] ?? null;
+}
+/** The `if (...)` condition text with the outer parens stripped. */
+function conditionLabel(ifNode, sourceCode, adapter) {
+    const cond = (ifNode.children ?? []).find((c) => c.type === 'parenthesized_expression');
+    if (cond) {
+        const t = textOf(cond, sourceCode, adapter).trim();
+        return t.replace(/^\((.*)\)$/s, '$1').trim();
+    }
+    return 'if';
+}
+/** Best-effort condition label for a switch-case / ternary gating node. */
+function branchLabel(node, sourceCode, adapter) {
+    if (node.type === 'if_statement')
+        return conditionLabel(node, sourceCode, adapter);
+    if (node.type === 'switch_case' || node.type === 'ternary_expression') {
+        const first = (node.children ?? []).find((c) => c.type !== ':' && c.type !== '?' && c.type !== '{' && c.type !== '}');
+        if (first)
+            return textOf(first, sourceCode, adapter).trim();
+    }
+    return node.type;
+}
+/**
+ * Classify a `.push(...)` call as all-paths or some-paths by walking up from it
+ * to the enclosing function. A push gated by an `if`/`switch`/ternary/`&&`/
+ * `||`/loop is some-paths, with the guard's text as the branch name.
+ */
+function gateInfo(pushNode, fnNode, sourceCode, adapter) {
+    let child = pushNode;
+    let cur = pushNode.parent ?? null;
+    while (cur && cur !== fnNode) {
+        const t = cur.type;
+        if (t === 'if_statement' || t === 'switch_case' || t === 'ternary_expression') {
+            return { gated: true, branch: branchLabel(cur, sourceCode, adapter) };
+        }
+        if (LOOP_TYPES.has(t)) {
+            return { gated: true, branch: t };
+        }
+        if (t === 'binary_expression') {
+            const kids = cur.children ?? [];
+            const opIdx = kids.findIndex((c) => c.type === '&&' || c.type === '||');
+            // A push on the right of `&&`/`||` runs only when the guard short-circuits
+            // it there; a push on the left always runs.
+            if (opIdx >= 0 && kids.indexOf(child) > opIdx) {
+                const left = kids
+                    .slice(0, opIdx)
+                    .map((c) => textOf(c, sourceCode, adapter).trim())
+                    .join(' ');
+                return { gated: true, branch: left || kids[opIdx].type };
+            }
+        }
+        child = cur;
+        cur = cur.parent ?? null;
+    }
+    return { gated: false };
+}
+/**
+ * Resolve a `.where(...)` spread (`and(...conditions)`) to the elements of the
+ * local `conditions` binding, classified all-paths vs some-paths.
+ *
+ * @param callNode The data-access candidate node (the whole query statement).
+ * @param sourceCode The file source for text extraction.
+ * @param adapter The language adapter (text/type/parent navigation).
+ * @returns The resolved elements, or null when there is no spread, no local
+ *          binding, or no elements to resolve (the caller then fires as today).
+ */
+export function resolveWhereBinding(callNode, sourceCode, adapter) {
+    // 1. The spread identifier (`...conditions`) inside the candidate call.
+    let bindingName = null;
+    walk(callNode, (n) => {
+        if (bindingName !== null || n.type !== 'spread_element')
+            return;
+        const id = childrenOfType(n, 'identifier')[0];
+        if (id && /^[A-Za-z_$][\w$]*$/.test(textOf(id, sourceCode, adapter))) {
+            bindingName = textOf(id, sourceCode, adapter);
+        }
+    });
+    if (bindingName === null)
+        return null;
+    // 2. The enclosing function — the resolution ceiling.
+    let fn = callNode.parent ?? null;
+    while (fn && !FUNCTION_NODE_TYPES.has(fn.type))
+        fn = fn.parent ?? null;
+    if (!fn)
+        return null;
+    const name = bindingName;
+    const elements = [];
+    // 3. Array-initializer elements — all-paths by construction.
+    const declarators = collectWithin(fn, (n) => n.type === 'variable_declarator')
+        .filter((d) => d.range[1] <= callNode.range[0]) // declared before use
+        .filter((d) => {
+        const id = childrenOfType(d, 'identifier')[0];
+        return id && textOf(id, sourceCode, adapter) === name;
+    });
+    const declarator = declarators[declarators.length - 1] ?? null;
+    if (declarator) {
+        const value = (declarator.children ?? []).find((c) => c.type === 'array');
+        if (value) {
+            for (const el of expressionChildren(value)) {
+                elements.push({ text: textOf(el, sourceCode, adapter).trim(), allPaths: true });
+            }
+        }
+    }
+    // 4. `.push(...)` elements — all-paths only when not gated.
+    for (const push of collectWithin(fn, (n) => isPushCall(n, name, sourceCode, adapter))) {
+        if (push.range[1] > callNode.range[0])
+            continue; // pushed after the query ran
+        const arg = firstArgument(push, sourceCode, adapter);
+        if (!arg)
+            continue;
+        const gate = gateInfo(push, fn, sourceCode, adapter);
+        elements.push({
+            text: textOf(arg, sourceCode, adapter).trim(),
+            allPaths: !gate.gated,
+            branch: gate.gated ? gate.branch : undefined,
+        });
+    }
+    if (elements.length === 0)
+        return null;
+    return { elements };
+}
+//# sourceMappingURL=localBinding.js.map

package/dist/phase/localBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localBinding.js","sourceRoot":"","sources":["../../src/phase/localBinding.ts"],"names":[],"mappings":"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"}

package/dist/phase/loopQueries.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Spec 68 §3.2 — the per-file `loop-queries` producer.
+ *
+ * Re-homes the "find loops whose body issues a DB call" half of
+ * `UniversalDataAccessAnalyzer.checkLoopQueries` as a pure per-file processor.
+ * The analyzer did two jobs: collect the loop→query candidates and derive
+ * violations from them. The producer keeps only the collection — the candidates
+ * the `loop-query` rule reads. The analyzer's `extractLoopQueries` export is the
+ * synchronous extraction, run on {@link DEFAULT_DATA_ACCESS_CONFIG} (config is
+ * the §10 tuning surface and is not available to a `process(file)` call).
+ *
+ * `LoopQueryCandidate` is structurally identical to the `LoopQueryFact` fact, so
+ * the mapping is the identity — this module owns only the `AstFile` → fact
+ * unwrapping, and the fact shape is pinned in `phase/types.ts`.
+ */
+import type { AstFile, LoopQueryFact } from './types.js';
+/** Extract the per-file loop-query candidates from one parsed file.
+ *
+ *  Spec 69 §10 S5a — mirror `dataAccessCalls.ts`: when the legacy pipeline's
+ *  cross-file resolution pre-pass seeded this file's provenanced identifiers
+ *  (`file.receiverProvenance`), thread them as the extraction's provenance seed.
+ *  Without it, a `const db = getDB()` whose `getDB` is declared in another file
+ *  reads as unprovenanced and the loop-query rule under-fires on exactly the
+ *  same shape the data-access rules fire on. Absent a seed (slice tests), the
+ *  extraction runs on the default config exactly as before.
+ *
+ * @param file the parsed file to extract loop-query candidates from
+ * @returns the file's loop-query candidates
+ */
+export declare function extractLoopQueries(file: AstFile): LoopQueryFact[];
+//# sourceMappingURL=loopQueries.d.ts.map

package/dist/phase/loopQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopQueries.d.ts","sourceRoot":"","sources":["../../src/phase/loopQueries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,EAAE,CAajE"}

package/dist/phase/loopQueries.js

@@ -0,0 +1,44 @@
+/**
+ * Spec 68 §3.2 — the per-file `loop-queries` producer.
+ *
+ * Re-homes the "find loops whose body issues a DB call" half of
+ * `UniversalDataAccessAnalyzer.checkLoopQueries` as a pure per-file processor.
+ * The analyzer did two jobs: collect the loop→query candidates and derive
+ * violations from them. The producer keeps only the collection — the candidates
+ * the `loop-query` rule reads. The analyzer's `extractLoopQueries` export is the
+ * synchronous extraction, run on {@link DEFAULT_DATA_ACCESS_CONFIG} (config is
+ * the §10 tuning surface and is not available to a `process(file)` call).
+ *
+ * `LoopQueryCandidate` is structurally identical to the `LoopQueryFact` fact, so
+ * the mapping is the identity — this module owns only the `AstFile` → fact
+ * unwrapping, and the fact shape is pinned in `phase/types.ts`.
+ */
+import { extractLoopQueries as extractAnalyzerLoopQueries, } from '../analyzers/universal/UniversalDataAccessAnalyzer.js';
+/** Extract the per-file loop-query candidates from one parsed file.
+ *
+ *  Spec 69 §10 S5a — mirror `dataAccessCalls.ts`: when the legacy pipeline's
+ *  cross-file resolution pre-pass seeded this file's provenanced identifiers
+ *  (`file.receiverProvenance`), thread them as the extraction's provenance seed.
+ *  Without it, a `const db = getDB()` whose `getDB` is declared in another file
+ *  reads as unprovenanced and the loop-query rule under-fires on exactly the
+ *  same shape the data-access rules fire on. Absent a seed (slice tests), the
+ *  extraction runs on the default config exactly as before.
+ *
+ * @param file the parsed file to extract loop-query candidates from
+ * @returns the file's loop-query candidates
+ */
+export function extractLoopQueries(file) {
+    const seed = file.receiverProvenance;
+    // Spec 70 R1 — thread the corpus dialect (when the runner named one) so the
+    // producer's SQL-content facts parse; absent a dialect they `cannot-fire`.
+    // Without this, R3's sql-argument handle inference is skipped and a helper
+    // whose body queries via a SQL literal (`fetchUser` → `db.prepare(\`SELECT…\`)`)
+    // is not learned as a DB wrapper, so `fetchUser(db, id)` inside a loop under-fires
+    // on exactly the shape the data-access-calls producer fires on.
+    const dialect = file.sqlDialect ?? null;
+    const config = (seed || dialect)
+        ? { _receiverProvenance: seed, dialect }
+        : undefined;
+    return extractAnalyzerLoopQueries(file.ast, file.adapter, file.source, config);
+}
+//# sourceMappingURL=loopQueries.js.map

package/dist/phase/loopQueries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopQueries.js","sourceRoot":"","sources":["../../src/phase/loopQueries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EACL,kBAAkB,IAAI,0BAA0B,GAEjD,MAAM,uDAAuD,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAa;IAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC;IACrC,4EAA4E;IAC5E,2EAA2E;IAC3E,2EAA2E;IAC3E,iFAAiF;IACjF,mFAAmF;IACnF,gEAAgE;IAChE,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC;IACxC,MAAM,MAAM,GAAG,CAAC,IAAI,IAAI,OAAO,CAAC;QAC9B,CAAC,CAAE,EAAE,mBAAmB,EAAE,IAAI,EAAE,OAAO,EAA0C;QACjF,CAAC,CAAC,SAAS,CAAC;IACd,OAAO,0BAA0B,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACjF,CAAC"}

package/dist/phase/loopQueryCandidates.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Spec 70 Item 4 (step 3) — the per-file `loop-query-candidates` producer.
+ *
+ * The extract half of the corpus `loop-queries` reduction. The legacy
+ * `loop-queries` producer did two jobs: find every in-loop DB call (via
+ * `collectLoopQueryCandidates`) and fold the provenance-dependent half — the
+ * strict-handle filter (`isDbCallNode`'s `identifyHandle`), the per-loop dedup,
+ * and the stable symbol — over the cross-file `dbProvenanced` seed. The collapse
+ * splits them: this producer runs only the provenance-free half — the broadened
+ * discovery and every provenance-free discriminator (statement-construction,
+ * for-of-iterable, hoisted-reuse, batch-argument, LLM/queue suppression) — while
+ * the AST lives, projecting the handle identity so the corpus producer re-folds
+ * the strict-handle filter once the `receiver-provenance` fixed point supplies the
+ * seed. No dedup and no symbol happen here: both depend on the re-folded handle
+ * set. The producer runs on the empty-provenance scan (the analyzer's
+ * `buildCandidateScan`).
+ */
+import type { AstFile, LoopQueryRawCandidate } from './types.js';
+/** Extract one file's raw, provenance-free loop-query candidates.
+ *
+ *  @param file the parsed file to project loop-query candidates from
+ *  @returns the file's `LoopQueryRawCandidate[]` (no raw-side dedup or symbol —
+ *    the corpus producer re-folds both after re-folding the handle verdict)
+ */
+export declare function extractLoopQueryRawCandidates(file: AstFile): LoopQueryRawCandidate[];
+//# sourceMappingURL=loopQueryCandidates.d.ts.map

package/dist/phase/loopQueryCandidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopQueryCandidates.d.ts","sourceRoot":"","sources":["../../src/phase/loopQueryCandidates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGjE;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,OAAO,GAAG,qBAAqB,EAAE,CAEpF"}

package/dist/phase/loopQueryCandidates.js

@@ -0,0 +1,28 @@
+/**
+ * Spec 70 Item 4 (step 3) — the per-file `loop-query-candidates` producer.
+ *
+ * The extract half of the corpus `loop-queries` reduction. The legacy
+ * `loop-queries` producer did two jobs: find every in-loop DB call (via
+ * `collectLoopQueryCandidates`) and fold the provenance-dependent half — the
+ * strict-handle filter (`isDbCallNode`'s `identifyHandle`), the per-loop dedup,
+ * and the stable symbol — over the cross-file `dbProvenanced` seed. The collapse
+ * splits them: this producer runs only the provenance-free half — the broadened
+ * discovery and every provenance-free discriminator (statement-construction,
+ * for-of-iterable, hoisted-reuse, batch-argument, LLM/queue suppression) — while
+ * the AST lives, projecting the handle identity so the corpus producer re-folds
+ * the strict-handle filter once the `receiver-provenance` fixed point supplies the
+ * seed. No dedup and no symbol happen here: both depend on the re-folded handle
+ * set. The producer runs on the empty-provenance scan (the analyzer's
+ * `buildCandidateScan`).
+ */
+import { extractLoopQueryRawCandidates as extractAnalyzerCandidates } from '../analyzers/universal/UniversalDataAccessAnalyzer.js';
+/** Extract one file's raw, provenance-free loop-query candidates.
+ *
+ *  @param file the parsed file to project loop-query candidates from
+ *  @returns the file's `LoopQueryRawCandidate[]` (no raw-side dedup or symbol —
+ *    the corpus producer re-folds both after re-folding the handle verdict)
+ */
+export function extractLoopQueryRawCandidates(file) {
+    return extractAnalyzerCandidates(file.ast, file.adapter, file.source);
+}
+//# sourceMappingURL=loopQueryCandidates.js.map

package/dist/phase/loopQueryCandidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopQueryCandidates.js","sourceRoot":"","sources":["../../src/phase/loopQueryCandidates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,6BAA6B,IAAI,yBAAyB,EAAE,MAAM,uDAAuD,CAAC;AAEnI;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,IAAa;IACzD,OAAO,yBAAyB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;AACxE,CAAC"}

package/dist/phase/oracles.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Spec 69 R1 — the completeness oracles a file processor declares.
+ *
+ * Each oracle is one of two arms: a `counted` count of the fragments a file
+ * *should* yield (a cheap, independent upper bound computed from the same input,
+ * written for that processor), or an explicit `none` with the reason no statable
+ * oracle exists. `none` is not an exemption — it is the report that closes the
+ * silent-unprovable failure mode: the run enumerates it, named, with its reason.
+ *
+ * The counts here are deliberately dumber than the producer they shadow. A
+ * producer runs the full extraction (metrics, classification, dedup); the oracle
+ * counts raw tree nodes off the same tree. The gap — a producer emitting fewer
+ * than the oracle expects — is the *residual* the aggregate gate pins (§69 R1,
+ * criterion 4). An oracle is an upper bound, not a promise of equality: e.g.
+ * `countFileSymbols` counts `method_definition` nodes, which the file-symbols
+ * producer folds into their class symbol rather than emitting, so a class with
+ * methods has a positive residual by design. The baseline records what each
+ * number is composed of, so a residual of mostly-non-candidates is not later
+ * read as missing input.
+ *
+ * The `measured` half is the same unit counted *inside* the emitted fragments.
+ * For a per-fragment producer both count and measured count fragments; for an
+ * aggregate producer (one fragment per file) `count` still counts the units, so
+ * `measured` must read them from the fragment's payload — comparing a unit count
+ * against `fragments.length` would be a meaningless 1-against-1.
+ */
+import type { CompletenessOracle, OracleShortfall, ParsedFile } from './types.js';
+/** A counted oracle: `count` returns the units one file should yield; `measured`
+ *  reads the same unit back out of the emitted fragments.
+ *
+ * @param count The expected-unit counter, computed from the same input the
+ *  processor walks.
+ * @param measured Reads the same unit back out of the emitted fragments; defaults
+ *  to the fragment-array length for one-fragment-per-unit producers.
+ * @returns A counted completeness oracle pairing the two.
+ */
+export declare function countOracle(count: (file: ParsedFile) => number, measured?: (fragments: readonly unknown[]) => number): CompletenessOracle;
+/** A no-oracle: there is no statable count, and here is why. */
+export declare function noOracle(reason: string): CompletenessOracle;
+/**
+ * Compare a `counted` oracle against what its processor actually emitted for one
+ * file. Returns the shortfall record when the emitted count fell below the
+ * expected count, else `null`. The actual count is read through the oracle's own
+ * `measured` so aggregate producers compare the unit inside their single
+ * fragment, not the fragment array length. A `none` oracle never produces a
+ * shortfall — its absence is enumerated by `noOracleProcessors`, not measured
+ * here.
+ *
+ * @param oracle The completeness oracle to compare against (only `counted` ones).
+ * @param file The parsed file whose emission is being checked.
+ * @param fragments The fragments the file's processor actually emitted.
+ * @param processorId The id of the processor being checked, recorded on a shortfall.
+ * @returns A shortfall record when the emitted count fell below the expected
+ *  count, otherwise `null`.
+ */
+export declare function oracleShortfall(oracle: CompletenessOracle, file: ParsedFile, fragments: readonly unknown[], processorId: string): OracleShortfall | null;
+/** file-symbols — count function-like, class, and interface declaration nodes
+ *  off the tree. An upper bound: a method is a function-like node that rides on
+ *  its class symbol, so a class with methods emits fewer symbols than the node
+ *  count.
+ *
+ * @param file The parsed file to count over.
+ * @returns The number of function-like, class, and interface declaration nodes.
+ */
+export declare function countFileSymbols(file: ParsedFile): number;
+/** imports (TS/JS) — count `import_statement` nodes off the tree.
+ *
+ * @param file The parsed file to count over.
+ * @returns The number of `import_statement` nodes.
+ */
+export declare function countImports(file: ParsedFile): number;
+/** export-form (TS/JS) — count `export_statement` nodes off the tree.
+ *
+ * @param file The parsed file to count over.
+ * @returns The number of `export_statement` nodes.
+ */
+export declare function countExportForm(file: ParsedFile): number;
+/** export-symbols — count the exported names the producer emits, mirroring
+ *  `collectExports` (one fragment per named / default / star-reexported name).
+ *  A raw `export_statement` count is neither an upper nor a lower bound here: it
+ *  under-counts multi-name `export { a, b, c }` (one statement, three names) and
+ *  over-counts the empty `export {}` (one statement, zero names). So this counts
+ *  the same units the producer does: named `export_specifier`s carrying a leading
+ *  identifier, one declaration-wrapped name, one default identifier, and the
+ *  `export * from '…'` star re-export.
+ *
+ * @param file The parsed file to count over.
+ * @returns The number of exported names `collectExports` would emit.
+ */
+export declare function countExportSymbols(file: ParsedFile): number;
+/** function-index — count `function_declaration` + `arrow_function` nodes. A
+ *  function declaration is emitted one-to-one; an arrow is emitted only when
+ *  bound to a `variable_declarator`, so a bare callback arrow is a residual by
+ *  design (the producer legitimately skips it). Class components and
+ *  `memo`/`forwardRef` wrappers that are not a function/arrow are under-counted
+ *  (a safe bound, never a false shortfall). */
+export declare const countFunctionIndex: (file: ParsedFile) => number;
+/** string-literals — count `string` + `template_string` nodes; the producer
+ *  emits one literal per node, so this is exact, not merely an upper bound. */
+export declare const countStringLiterals: (file: ParsedFile) => number;
+/** cross-language-entities — count the entity-declaring node types the
+ *  cross-language extractor projects: TS/JS function/method/arrow/interface, and
+ *  Go function + type_spec. Go test files are NOT exempted here (the
+ *  cross-language entity extractor does not skip them). */
+export declare const countCrossLanguageEntities: (file: ParsedFile) => number;
+/** code-block — count the block nodes (functions, classes, control-flow) plus the
+ *  fragment nodes (object literals, call expressions) the DRY extractor projects.
+ *  Methods are emitted through both the function walk and the class walk, so the
+ *  single node count under-counts them (safe); object literals outside a
+ *  declarator/assignment value are a residual. */
+export declare const countCodeBlocks: (file: ParsedFile) => number;
+/** file-imports — count the static import nodes (`import_statement` for TS/JS,
+ *  `import_spec` for Go). The producer's `imports` array is a deduped set, so
+ *  duplicate specifiers are a residual; re-exports and dynamic `import()` are
+ *  under-counted (safe). */
+export declare const countFileImports: (file: ParsedFile) => number;
+/** react-component — count `jsx_element` + `jsx_self_closing_element` nodes off
+ *  the tree; the measured side sums each component's `jsxElementDetails` (one per
+ *  JSX element occurrence, nested included), so the residual is JSX that sits
+ *  outside a component. */
+export declare const countJsxElements: (file: ParsedFile) => number;
+/** batch-functions — count the function node types the batch walk recognizes; a
+ *  function whose span holds no `.batch(`/`.transaction(` is a residual. */
+export declare const countBatchFunctions: (file: ParsedFile) => number;
+/** imports (Go) — count `import_spec` nodes, exempting `*_test.go`. */
+export declare const countGoImports: (file: ParsedFile) => number;
+/** go-functions — count Go `function_declaration` + `method_declaration` nodes,
+ *  exempting `*_test.go`. */
+export declare const countGoFunctions: (file: ParsedFile) => number;
+/** go-switches — count Go switch statements, exempting `*_test.go`. */
+export declare const countGoSwitches: (file: ParsedFile) => number;
+/** type-declarations — count Go `type_spec` nodes (one per declared struct /
+ *  interface), exempting `*_test.go`. */
+export declare const countTypeDeclarations: (file: ParsedFile) => number;
+/** go-package-bindings — count the *pre-dedup* package-scope binding
+ *  declarations: top-level `function_declaration`/`method_declaration` with a
+ *  name, plus the named `type_spec`/`var_spec` children of a top-level
+ *  `type_declaration`/`var_declaration`. This is the number of bindings
+ *  `buildGoFileBindings` emits *before* its first-wins dedup — which is a no-op
+ *  within a single valid Go file (package-scope names are unique per file), so it
+ *  bounds the deduped `bindings.length` exactly. A raw node-type count would
+ *  over-count (a `type_spec`/`var_spec` may nest inside a function body), so this
+ *  walks the root's named children exactly as the producer does. Exempts
+ *  `*_test.go`.
+ * @param file - The parsed file to count package-scope bindings for.
+ * @returns The number of package-scope bindings `buildGoFileBindings` would emit. */
+export declare function countGoPackageBindings(file: ParsedFile): number;
+export declare function countSchemaObjects(file: ParsedFile): number;
+export declare function countDdlOps(file: ParsedFile): number;
+/** style-declarations (css/scss) — count `declaration` nodes off the CSS AST.
+ *  An upper bound, not exact: the producer projects only declarations inside a
+ *  `rule_set` (skipping `@keyframes`/`@font-face`/`@page` declarations) and may
+ *  expand a shorthand into several, so a declaration outside a rule_set is a
+ *  positive residual.
+ *
+ * @param file The parsed file to count over.
+ * @returns The number of `declaration` nodes off the CSS AST.
+ */
+export declare function countCssDeclarations(file: ParsedFile): number;
+/** secret-candidates — count `string` + `template_string` nodes. Every candidate
+ *  (a declarator / assignment / pair / call that carries a string in a
+ *  credential position) holds ≥1 string literal, so the string-node count
+ *  upper-bounds the candidate count. Residual = string literals outside a
+ *  credential position (the majority of a file's strings). */
+export declare const countSecretCandidates: (file: ParsedFile) => number;
+/** security-candidates — count `call_expression` + `template_string` nodes.
+ *  Every candidate is either a call (command-injection / dynamic-require) or a
+ *  sink-reaching template (unescaped-html), so this upper-bounds the candidate
+ *  count. Residual = the large majority of calls/templates that are not
+ *  security-relevant. */
+export declare const countSecurityCandidates: (file: ParsedFile) => number;
+/** data-access-calls — count `call_expression` + `template_string` nodes. Every
+ *  resolved DB call is a call (or a tagged-template call), so this upper-bounds
+ *  the resolved-call count. Residual = non-DB calls/templates (the bulk of a
+ *  file's call sites). */
+export declare const countDataAccessCalls: (file: ParsedFile) => number;
+/** loop-queries — count loop nodes. The producer emits one candidate per loop
+ *  whose body issues a DB call; this counts every loop. Residual = loops whose
+ *  body holds no DB call. */
+export declare const countLoopQueries: (file: ParsedFile) => number;
+export declare function countDynamicSql(file: ParsedFile): number;
+export declare function countQuerySites(file: ParsedFile): number;
+/** schema-usage — count `call_expression` + `string` + `template_string` nodes.
+ *  Every table reference is carried in a string literal, a tagged template, or a
+ *  call, so this upper-bounds the reference count. Residual = strings/calls/
+ *  templates that name no table reference (the bulk of the file). */
+export declare const countSchemaUsage: (file: ParsedFile) => number;
+/** ddl-declarations — the DDL op count inside the (single) declaration fragment. */
+export declare function measuredDdlOps(fragments: readonly unknown[]): number;
+/** style-declarations css/scss — the declaration count inside the fragment. */
+export declare function measuredStyleDeclarations(fragments: readonly unknown[]): number;
+/** react-component — the JSX element count across the file's components.
+ *
+ * @param fragments The emitted react-component fragments for one file.
+ * @returns The total JSX element count summed across every component.
+ */
+export declare function measuredJsxElements(fragments: readonly unknown[]): number;
+/** file-imports — the import specifier count inside the fragment. */
+export declare function measuredFileImports(fragments: readonly unknown[]): number;
+/** go-package-bindings — the package-scope binding count inside the (single)
+ *  fragment. */
+export declare function measuredGoPackageBindings(fragments: readonly unknown[]): number;
+/** query-site-candidates — the located-site count across the file's candidate
+ *  fragments. The producer emits one fragment per TS-family file carrying the
+ *  `sites` array, so this sums the site count inside it (the same unit
+ *  `countQuerySites` upper-bounds), not the fragment count. */
+export declare function measuredQuerySites(fragments: readonly unknown[]): number;
+/** schema-usage-candidates — the candidate count across the file's candidate
+ *  fragments. One fragment per TS-family file carries the five candidate arrays
+ *  (`ormRefs`, `queryBuilderRefs`, `collectionAdapterRefs`, `tagged`, `dbCalls`);
+ *  this sums their lengths (the unit `countSchemaUsage` upper-bounds), not the
+ *  fragment count.
+ * @param fragments - The schema-usage-candidates fragments to sum candidate counts across.
+ * @returns The total candidate count across all fragments. */
+export declare function measuredSchemaUsageCandidates(fragments: readonly unknown[]): number;
+//# sourceMappingURL=oracles.d.ts.map

package/dist/phase/oracles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracles.d.ts","sourceRoot":"","sources":["../../src/phase/oracles.ts"],"names":[],"mappings":"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"}