code-auditor-mcp 4.1.1 → 5.0.1

package/dist/phase/goImports.js

@@ -0,0 +1,68 @@
+/**
+ * Spec 68 §9 — the Go `imports` producer.
+ *
+ * Re-homes the Go binary's import extraction (`runImportAnalysis` in
+ * `analyzer-src/analyzer.go`) as a plain-data fact. It walks the tree-sitter Go
+ * AST for `import_spec` nodes and projects each one's source path and local
+ * name:
+ *
+ *   - `source` is the unquoted `path` field (`interpreted_string_literal`), the
+ *     same `strconv.Unquote` the Go binary applied;
+ *   - `alias` is the import's local name — `dot` → `.` (dot import),
+ *     `package_identifier` → the named alias (`f`), `blank_identifier` → `_`,
+ *     and `null` for an unnamed `"fmt"` import — mirroring `importSpec.Name`;
+ *   - `line`/`column` are the `import_spec`'s 1-based start position.
+ *
+ * The order of `import_spec` nodes is source order, so `import-organization`
+ * can reconstruct the grouping sequence from `(file, source, line)` and
+ * `import-style` reads `alias === '.'`. The tree dies with the file; the two
+ * rules read only this data (never the AST, never the Go subprocess).
+ */
+import { walkAST, getNodeText, getFieldNode } from '../languages/adapterBridge.js';
+import { isTestFile } from '../languages/testConventions.js';
+/**
+ * Extract every import spec from one parsed Go file.
+ *
+ * @param file - The parsed Go file whose import specs are projected.
+ * @returns One `ImportFact` per `import_spec` (source, alias, position).
+ */
+export function extractGoImports(file) {
+    // `go test` compiles only `*_test.go` — test files are not production API, so
+    // the Go facts (and every rule reading them) must exempt them, matching the
+    // deleted Go subprocess's `filePatterns`.
+    if (isTestFile('go', file.file))
+        return [];
+    const out = [];
+    walkAST(file.ast.root, (node) => {
+        if (node.type !== 'import_spec')
+            return;
+        const path = getFieldNode(node, 'path');
+        if (!path)
+            return;
+        const source = getNodeText(path, file.source).replace(/^['"]|['"]$/g, '');
+        let alias = null;
+        for (const child of node.children ?? []) {
+            if (child.type === 'dot') {
+                alias = '.';
+                break;
+            }
+            if (child.type === 'package_identifier') {
+                alias = getNodeText(child, file.source);
+                break;
+            }
+            if (child.type === 'blank_identifier') {
+                alias = '_';
+                break;
+            }
+        }
+        out.push({
+            file: file.file,
+            source,
+            line: node.location.start.line,
+            column: node.location.start.column,
+            alias,
+        });
+    });
+    return out;
+}
+//# sourceMappingURL=goImports.js.map

package/dist/phase/goImports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"goImports.js","sourceRoot":"","sources":["../../src/phase/goImports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAa;IAC5C,8EAA8E;IAC9E,4EAA4E;IAC5E,0CAA0C;IAC1C,IAAI,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3C,MAAM,GAAG,GAAiB,EAAE,CAAC;IAC7B,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;QAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa;YAAE,OAAO;QACxC,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;QAE1E,IAAI,KAAK,GAAkB,IAAI,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,IAAI,EAAE,EAAE,CAAC;YACxC,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;gBACzB,KAAK,GAAG,GAAG,CAAC;gBACZ,MAAM;YACR,CAAC;YACD,IAAI,KAAK,CAAC,IAAI,KAAK,oBAAoB,EAAE,CAAC;gBACxC,KAAK,GAAG,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;gBACxC,MAAM;YACR,CAAC;YACD,IAAI,KAAK,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;gBACtC,KAAK,GAAG,GAAG,CAAC;gBACZ,MAAM;YACR,CAAC;QACH,CAAC;QAED,GAAG,CAAC,IAAI,CAAC;YACP,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM;YACN,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI;YAC9B,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM;YAClC,KAAK;SACN,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/phase/goPackageBindings.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Spec 70 Item 4 (2a) — the per-file `go-package-bindings` producer.
+ *
+ * Projects `buildGoFileBindings` (goResolution.ts) — the exact per-file half of
+ * the legacy `buildGoPackageBindings` — onto the serializable package-scope
+ * symbol set the cross-file receiver-provenance fixed point groups by directory
+ * and merges first-wins. Using the exact legacy extractor (not a
+ * re-implementation) makes the per-file binding set byte-identical by
+ * construction, so the parity assertion in step 2.5 is a diff of the wiring, not
+ * of the extraction.
+ */
+import type { AstFile, GoPackageBindingFact } from './types.js';
+/**
+ * One Go file's package-scope declarations as a single `GoPackageBindingFact`.
+ *
+ * @param file - The parsed Go file whose package-scope bindings are projected.
+ * @returns A one-element array carrying the file's `{name, binding}` pairs, or
+ *   `[]` for a non-Go or `*_test.go` file (the Go producers exempt test files,
+ *   matching the deleted Go subprocess's `filePatterns`).
+ */
+export declare function extractGoPackageBindings(file: AstFile): GoPackageBindingFact[];
+//# sourceMappingURL=goPackageBindings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"goPackageBindings.d.ts","sourceRoot":"","sources":["../../src/phase/goPackageBindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAoB,MAAM,YAAY,CAAC;AAIlF;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,oBAAoB,EAAE,CAQ9E"}

package/dist/phase/goPackageBindings.js

@@ -0,0 +1,30 @@
+/**
+ * Spec 70 Item 4 (2a) — the per-file `go-package-bindings` producer.
+ *
+ * Projects `buildGoFileBindings` (goResolution.ts) — the exact per-file half of
+ * the legacy `buildGoPackageBindings` — onto the serializable package-scope
+ * symbol set the cross-file receiver-provenance fixed point groups by directory
+ * and merges first-wins. Using the exact legacy extractor (not a
+ * re-implementation) makes the per-file binding set byte-identical by
+ * construction, so the parity assertion in step 2.5 is a diff of the wiring, not
+ * of the extraction.
+ */
+import { buildGoFileBindings } from '../languages/go/goResolution.js';
+import { isTestFile } from '../languages/testConventions.js';
+/**
+ * One Go file's package-scope declarations as a single `GoPackageBindingFact`.
+ *
+ * @param file - The parsed Go file whose package-scope bindings are projected.
+ * @returns A one-element array carrying the file's `{name, binding}` pairs, or
+ *   `[]` for a non-Go or `*_test.go` file (the Go producers exempt test files,
+ *   matching the deleted Go subprocess's `filePatterns`).
+ */
+export function extractGoPackageBindings(file) {
+    if (file.adapter.name !== 'go')
+        return [];
+    if (isTestFile('go', file.file))
+        return [];
+    const bindings = [...buildGoFileBindings(file.ast).entries()].map(([name, binding]) => ({ name, binding }));
+    return [{ file: file.file, bindings }];
+}
+//# sourceMappingURL=goPackageBindings.js.map

package/dist/phase/goPackageBindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"goPackageBindings.js","sourceRoot":"","sources":["../../src/phase/goPackageBindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAa;IACpD,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,IAAI;QAAE,OAAO,EAAE,CAAC;IAC1C,IAAI,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAE3C,MAAM,QAAQ,GAAuB,CAAC,GAAG,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CACnF,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CACzC,CAAC;IACF,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;AACzC,CAAC"}

package/dist/phase/goSwitches.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Spec 68 §9 — the `go-switches` producer.
+ *
+ * Re-homes the Go binary's switch-size extraction (the `analyzeSwitchSize` walk
+ * in `analyzer-src/solid.go`) as a plain-data fact. It walks the tree-sitter Go
+ * AST for `expression_switch_statement` / `type_switch_statement` nodes and
+ * projects each one's case-clause count:
+ *
+ *   - `caseCount` counts `expression_case` + `default_case` (expression switch)
+ *     or `type_case` + `default_case` (type switch) — the Go binary iterates
+ *     `Body.List`, where a `default:` clause is a `*ast.CaseClause` too, so the
+ *     `default` arm is included in the count;
+ *   - `line` is the `switch` keyword's 1-based line (`node.Pos().Line`);
+ *   - `kind` distinguishes the two messages (`switch` vs `type-switch`).
+ *
+ * The walk is whole-file (nested switches are each inspected independently,
+ * matching the Go binary's `ast.Inspect`). The tree dies with the file;
+ * `switch-size` reads only this data.
+ */
+import type { AstFile, GoSwitchFact } from './types.js';
+/**
+ * Extract every switch/type-switch statement from one parsed Go file.
+ *
+ * @param file - The parsed Go file whose switches are projected.
+ * @returns One `GoSwitchFact` per switch (case count, kind, line).
+ */
+export declare function extractGoSwitches(file: AstFile): GoSwitchFact[];
+//# sourceMappingURL=goSwitches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"goSwitches.d.ts","sourceRoot":"","sources":["../../src/phase/goSwitches.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAIxD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,EAAE,CAmB/D"}

package/dist/phase/goSwitches.js

@@ -0,0 +1,52 @@
+/**
+ * Spec 68 §9 — the `go-switches` producer.
+ *
+ * Re-homes the Go binary's switch-size extraction (the `analyzeSwitchSize` walk
+ * in `analyzer-src/solid.go`) as a plain-data fact. It walks the tree-sitter Go
+ * AST for `expression_switch_statement` / `type_switch_statement` nodes and
+ * projects each one's case-clause count:
+ *
+ *   - `caseCount` counts `expression_case` + `default_case` (expression switch)
+ *     or `type_case` + `default_case` (type switch) — the Go binary iterates
+ *     `Body.List`, where a `default:` clause is a `*ast.CaseClause` too, so the
+ *     `default` arm is included in the count;
+ *   - `line` is the `switch` keyword's 1-based line (`node.Pos().Line`);
+ *   - `kind` distinguishes the two messages (`switch` vs `type-switch`).
+ *
+ * The walk is whole-file (nested switches are each inspected independently,
+ * matching the Go binary's `ast.Inspect`). The tree dies with the file;
+ * `switch-size` reads only this data.
+ */
+import { walkAST } from '../languages/adapterBridge.js';
+import { isTestFile } from '../languages/testConventions.js';
+/**
+ * Extract every switch/type-switch statement from one parsed Go file.
+ *
+ * @param file - The parsed Go file whose switches are projected.
+ * @returns One `GoSwitchFact` per switch (case count, kind, line).
+ */
+export function extractGoSwitches(file) {
+    if (isTestFile('go', file.file))
+        return [];
+    const out = [];
+    walkAST(file.ast.root, (node) => {
+        let kind;
+        if (node.type === 'expression_switch_statement')
+            kind = 'switch';
+        else if (node.type === 'type_switch_statement')
+            kind = 'type-switch';
+        else
+            return;
+        const clauses = node.type === 'expression_switch_statement'
+            ? ['expression_case', 'default_case']
+            : ['type_case', 'default_case'];
+        let caseCount = 0;
+        for (const child of node.children ?? []) {
+            if (child.type === clauses[0] || child.type === clauses[1])
+                caseCount++;
+        }
+        out.push({ file: file.file, line: node.location.start.line, caseCount, kind });
+    });
+    return out;
+}
+//# sourceMappingURL=goSwitches.js.map

package/dist/phase/goSwitches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"goSwitches.js","sourceRoot":"","sources":["../../src/phase/goSwitches.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAa;IAC7C,IAAI,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3C,MAAM,GAAG,GAAmB,EAAE,CAAC;IAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;QAC9B,IAAI,IAA0B,CAAC;QAC/B,IAAI,IAAI,CAAC,IAAI,KAAK,6BAA6B;YAAE,IAAI,GAAG,QAAQ,CAAC;aAC5D,IAAI,IAAI,CAAC,IAAI,KAAK,uBAAuB;YAAE,IAAI,GAAG,aAAa,CAAC;;YAChE,OAAO;QAEZ,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,KAAK,6BAA6B;YACzD,CAAC,CAAC,CAAC,iBAAiB,EAAE,cAAc,CAAC;YACrC,CAAC,CAAC,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QAClC,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,IAAI,EAAE,EAAE,CAAC;YACxC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC;gBAAE,SAAS,EAAE,CAAC;QAC1E,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACjF,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/phase/importForm.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Spec 68 §3.2 — the per-file `import-form` producer.
+ *
+ * Projects `parseFileImports` (conventionMiner.ts) onto the serializable
+ * `ImportFormFact`: the module source plus the classified import form, and the
+ * 1-based line the `conventions/import-form` finding anchors to. The producer
+ * re-runs the same regex the legacy miner/detector ran over raw source text —
+ * NOT the AST `imports` fact — because the legacy path classified forms the AST
+ * extractor does not (`default`-plus-`named`, `require` destructuring,
+ * `side-effect`). It reads `file.source` alone, so it never narrows to `AstFile`.
+ */
+import type { ImportFormFact, ParsedFile } from './types.js';
+/**
+ * One file's imports as `ImportFormFact[]` (form + source + anchor line).
+ *
+ * @param file - The parsed file whose imports are classified.
+ * @returns The file's imports with their classified form and anchor line.
+ */
+export declare function extractImportForm(file: ParsedFile): ImportFormFact[];
+//# sourceMappingURL=importForm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"importForm.d.ts","sourceRoot":"","sources":["../../src/phase/importForm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,CAOpE"}

package/dist/phase/importForm.js

@@ -0,0 +1,27 @@
+/**
+ * Spec 68 §3.2 — the per-file `import-form` producer.
+ *
+ * Projects `parseFileImports` (conventionMiner.ts) onto the serializable
+ * `ImportFormFact`: the module source plus the classified import form, and the
+ * 1-based line the `conventions/import-form` finding anchors to. The producer
+ * re-runs the same regex the legacy miner/detector ran over raw source text —
+ * NOT the AST `imports` fact — because the legacy path classified forms the AST
+ * extractor does not (`default`-plus-`named`, `require` destructuring,
+ * `side-effect`). It reads `file.source` alone, so it never narrows to `AstFile`.
+ */
+import { parseFileImports } from '../conventions/conventionMiner.js';
+/**
+ * One file's imports as `ImportFormFact[]` (form + source + anchor line).
+ *
+ * @param file - The parsed file whose imports are classified.
+ * @returns The file's imports with their classified form and anchor line.
+ */
+export function extractImportForm(file) {
+    return parseFileImports(file.source).map((imp) => ({
+        file: file.file,
+        source: imp.source,
+        form: imp.form,
+        line: imp.line,
+    }));
+}
+//# sourceMappingURL=importForm.js.map

package/dist/phase/importForm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"importForm.js","sourceRoot":"","sources":["../../src/phase/importForm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAgB;IAChD,OAAO,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACjD,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,IAAI,EAAE,GAAG,CAAC,IAAI;KACf,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/phase/importSpecifiers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Spec 70 Item 4 (2a) — the per-file `import-specifiers` producer.
+ *
+ * Projects the adapter's `extractImports` (`ImportInfo[]`) onto the full
+ * serializable specifier detail the cross-file receiver-provenance fixed point
+ * reads: `source` plus every `ImportSpecifier` (name / alias / isDefault /
+ * isNamespace). This is a deliberate *addition* to, not a replacement of, the
+ * `imports` fact — `imports` keeps one row per statement with a position for
+ * `duplicate-import`, while this fact keeps the full specifier list the fixed
+ * point needs to resolve namespace/default/named re-export bindings.
+ */
+import type { AstFile, ImportSpecifiersFact } from './types.js';
+/**
+ * One file's import statements as `ImportSpecifiersFact[]`.
+ *
+ * @param file - The parsed file whose imports are projected.
+ * @returns The file's imports with their full specifier detail.
+ */
+export declare function extractImportSpecifiers(file: AstFile): ImportSpecifiersFact[];
+//# sourceMappingURL=importSpecifiers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"importSpecifiers.d.ts","sourceRoot":"","sources":["../../src/phase/importSpecifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,oBAAoB,EAAE,CAW7E"}

package/dist/phase/importSpecifiers.js

@@ -0,0 +1,30 @@
+/**
+ * Spec 70 Item 4 (2a) — the per-file `import-specifiers` producer.
+ *
+ * Projects the adapter's `extractImports` (`ImportInfo[]`) onto the full
+ * serializable specifier detail the cross-file receiver-provenance fixed point
+ * reads: `source` plus every `ImportSpecifier` (name / alias / isDefault /
+ * isNamespace). This is a deliberate *addition* to, not a replacement of, the
+ * `imports` fact — `imports` keeps one row per statement with a position for
+ * `duplicate-import`, while this fact keeps the full specifier list the fixed
+ * point needs to resolve namespace/default/named re-export bindings.
+ */
+/**
+ * One file's import statements as `ImportSpecifiersFact[]`.
+ *
+ * @param file - The parsed file whose imports are projected.
+ * @returns The file's imports with their full specifier detail.
+ */
+export function extractImportSpecifiers(file) {
+    return file.adapter.extractImports(file.ast).map((imp) => ({
+        file: file.file,
+        source: imp.source,
+        specifiers: imp.specifiers.map((s) => ({
+            name: s.name,
+            alias: s.alias,
+            isDefault: s.isDefault,
+            isNamespace: s.isNamespace,
+        })),
+    }));
+}
+//# sourceMappingURL=importSpecifiers.js.map

package/dist/phase/importSpecifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"importSpecifiers.js","sourceRoot":"","sources":["../../src/phase/importSpecifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAa;IACnD,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACzD,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACrC,IAAI,EAAE,CAAC,CAAC,IAAI;YACZ,KAAK,EAAE,CAAC,CAAC,KAAK;YACd,SAAS,EAAE,CAAC,CAAC,SAAS;YACtB,WAAW,EAAE,CAAC,CAAC,WAAW;SAC3B,CAAC,CAAC;KACJ,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/phase/imports.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Spec 68 §3.2 — the per-file `imports` producer.
+ *
+ * Projects the adapter's `extractImports` (`ImportInfo[]`) onto the serializable
+ * `ImportFact`: `source` plus the 1-based start position. The `duplicate-import`
+ * rule groups by `(file, source)`, so the fact keeps `file` on every element and
+ * the rule re-does the per-file grouping the legacy analyzer did implicitly by
+ * running `checkDuplicateImports` once per AST.
+ */
+import type { AstFile, ImportFact } from './types.js';
+/**
+ * One file's import statements as `ImportFact[]`.
+ *
+ * @param file - The parsed file whose imports are projected.
+ * @returns The file's imports with their 1-based start position.
+ */
+export declare function extractImports(file: AstFile): ImportFact[];
+//# sourceMappingURL=imports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/phase/imports.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,EAAE,CAQ1D"}

package/dist/phase/imports.js

@@ -0,0 +1,25 @@
+/**
+ * Spec 68 §3.2 — the per-file `imports` producer.
+ *
+ * Projects the adapter's `extractImports` (`ImportInfo[]`) onto the serializable
+ * `ImportFact`: `source` plus the 1-based start position. The `duplicate-import`
+ * rule groups by `(file, source)`, so the fact keeps `file` on every element and
+ * the rule re-does the per-file grouping the legacy analyzer did implicitly by
+ * running `checkDuplicateImports` once per AST.
+ */
+/**
+ * One file's import statements as `ImportFact[]`.
+ *
+ * @param file - The parsed file whose imports are projected.
+ * @returns The file's imports with their 1-based start position.
+ */
+export function extractImports(file) {
+    const infos = file.adapter.extractImports(file.ast);
+    return infos.map((imp) => ({
+        file: file.file,
+        source: imp.source,
+        line: imp.location.start.line,
+        column: imp.location.start.column,
+    }));
+}
+//# sourceMappingURL=imports.js.map

package/dist/phase/imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../src/phase/imports.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,IAAa;IAC1C,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACzB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI;QAC7B,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM;KAClC,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/phase/jsonDocument.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Spec 68 §3.2 — the `json-document` producer.
+ *
+ * A `.json` file is parsed like any other format (Amendment 1): the
+ * `JsonAdapter` produces a position-preserving value tree so later slices
+ * (§13) can anchor findings to the real offending token. This slice does not
+ * need that tree — the legacy `analyzeJsonSchemas` anchored every finding at
+ * `line:1, column:1` and the parity test pins that anchor — so the producer
+ * re-parses `.source` with `JSON.parse`, byte-identical to the legacy schema
+ * reducer's `readJson` (`JSON.parse(raw)` with `null` on error).
+ *
+ * The parsed value is deliberately NOT the adapter's positioned AST: a
+ * `JSON.parse` result is a plain-data tree (§4-serializable), which the corpus
+ * `schema-validations` processor can hand straight back into the legacy
+ * validation free functions without a tree-sitter node crossing the phase
+ * boundary.
+ */
+import type { ParsedFile, JsonDocumentFact } from './types.js';
+/**
+ * Parse one `.json` file into its `json-document` fact (one element).
+ *
+ * @param file - The parsed JSON file whose source is parsed.
+ * @returns A single-element fact holding the `JSON.parse` value (or `null`).
+ */
+export declare function extractJsonDocument(file: ParsedFile): JsonDocumentFact[];
+//# sourceMappingURL=jsonDocument.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonDocument.d.ts","sourceRoot":"","sources":["../../src/phase/jsonDocument.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAa,MAAM,YAAY,CAAC;AAE1E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAUxE"}

package/dist/phase/jsonDocument.js

@@ -0,0 +1,36 @@
+/**
+ * Spec 68 §3.2 — the `json-document` producer.
+ *
+ * A `.json` file is parsed like any other format (Amendment 1): the
+ * `JsonAdapter` produces a position-preserving value tree so later slices
+ * (§13) can anchor findings to the real offending token. This slice does not
+ * need that tree — the legacy `analyzeJsonSchemas` anchored every finding at
+ * `line:1, column:1` and the parity test pins that anchor — so the producer
+ * re-parses `.source` with `JSON.parse`, byte-identical to the legacy schema
+ * reducer's `readJson` (`JSON.parse(raw)` with `null` on error).
+ *
+ * The parsed value is deliberately NOT the adapter's positioned AST: a
+ * `JSON.parse` result is a plain-data tree (§4-serializable), which the corpus
+ * `schema-validations` processor can hand straight back into the legacy
+ * validation free functions without a tree-sitter node crossing the phase
+ * boundary.
+ */
+/**
+ * Parse one `.json` file into its `json-document` fact (one element).
+ *
+ * @param file - The parsed JSON file whose source is parsed.
+ * @returns A single-element fact holding the `JSON.parse` value (or `null`).
+ */
+export function extractJsonDocument(file) {
+    let json = null;
+    try {
+        json = JSON.parse(file.source);
+    }
+    catch {
+        // Invalid JSON — the legacy `readJson` returned null here too, and the
+        // corpus processor surfaces it as an `invalid-json` finding.
+        json = null;
+    }
+    return [{ file: file.file, json }];
+}
+//# sourceMappingURL=jsonDocument.js.map

package/dist/phase/jsonDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonDocument.js","sourceRoot":"","sources":["../../src/phase/jsonDocument.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAgB;IAClD,IAAI,IAAI,GAAqB,IAAI,CAAC;IAClC,IAAI,CAAC;QACH,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAc,CAAC;IAC9C,CAAC;IAAC,MAAM,CAAC;QACP,uEAAuE;QACvE,6DAA6D;QAC7D,IAAI,GAAG,IAAI,CAAC;IACd,CAAC;IACD,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AACrC,CAAC"}

package/dist/phase/localBinding.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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).
+ */
+import type { ASTNode, LanguageAdapter } from '../languages/types.js';
+import type { ResolvedWhere } from './types.js';
+/**
+ * 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 declare function resolveWhereBinding(callNode: ASTNode, sourceCode: string, adapter: LanguageAdapter): ResolvedWhere | null;
+//# sourceMappingURL=localBinding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localBinding.d.ts","sourceRoot":"","sources":["../../src/phase/localBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAA4B,aAAa,EAAE,MAAM,YAAY,CAAC;AAyJ1E;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,aAAa,GAAG,IAAI,CAoDtB"}