agentic-qe 3.10.1 → 3.10.3

package/dist/shared/parsers/tree-sitter-wasm-parser.js

@@ -1027,6 +1027,41 @@ export function isWasmAvailable() {
         return false;
     }
 }
+// Cache of loaded grammars keyed by wasm filename, for the generic loader below.
+const loadedGrammarsByFile = new Map();
+/**
+ * Generic grammar loader for callers outside the GRAMMAR_CONFIG set (e.g. the
+ * code-intelligence TS/JS extractor). Reuses the proven WASM init + grammar
+ * path resolution. Returns a `parse(code)` that yields a tree-sitter tree
+ * (caller must call `tree.delete()`), or null if WASM/grammar is unavailable so
+ * the caller can fall back.
+ */
+export async function loadWasmGrammar(wasmFile) {
+    if (!isWasmAvailable())
+        return null;
+    try {
+        await ensureTreeSitterInit();
+        let language = loadedGrammarsByFile.get(wasmFile);
+        if (!language) {
+            language = await treeSitterModule.Language.load(resolveGrammarPath(wasmFile));
+            loadedGrammarsByFile.set(wasmFile, language);
+        }
+        return {
+            parse: (code) => {
+                // New parser per call (cheap) to avoid cross-call setLanguage races.
+                const ParserCtor = treeSitterModule.Parser ?? treeSitterModule;
+                const parser = new ParserCtor();
+                parser.setLanguage(language);
+                const tree = parser.parse(code);
+                parser.delete?.();
+                return tree;
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Reset internal state — for testing only.
  */

package/dist/shared/parsers/treesitter-ts-extractor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tree-sitter TypeScript/JavaScript extractor for code-intelligence.
+ *
+ * Extracts functions, classes (+ methods), interfaces and imports from TS/JS/TSX
+ * source using bundled tree-sitter WASM grammars — so code-intelligence works
+ * WITHOUT the multi-megabyte `typescript` compiler dependency (#511).
+ *
+ * The KnowledgeGraphService uses this as a fallback when the TypeScript compiler
+ * API isn't available. Returns `null` when WASM/grammar can't load so the caller
+ * can degrade gracefully.
+ */
+export interface TsFunction {
+    name: string;
+    startLine: number;
+    isAsync: boolean;
+    visibility: 'public' | 'private' | 'protected';
+}
+export interface TsClass {
+    name: string;
+    startLine: number;
+    methods: TsFunction[];
+}
+export interface TsInterface {
+    name: string;
+    startLine: number;
+}
+export interface TsExtraction {
+    functions: TsFunction[];
+    classes: TsClass[];
+    interfaces: TsInterface[];
+    imports: string[];
+}
+export declare function isTreeSitterTsExtension(ext: string): boolean;
+/**
+ * Extract entities/imports from TS/JS/TSX source. Returns null if the grammar
+ * could not be loaded (WASM unavailable) so callers can fall back.
+ */
+export declare function extractTsJs(content: string, extension: string): Promise<TsExtraction | null>;
+//# sourceMappingURL=treesitter-ts-extractor.d.ts.map

package/dist/shared/parsers/treesitter-ts-extractor.js

@@ -0,0 +1,196 @@
+/**
+ * Tree-sitter TypeScript/JavaScript extractor for code-intelligence.
+ *
+ * Extracts functions, classes (+ methods), interfaces and imports from TS/JS/TSX
+ * source using bundled tree-sitter WASM grammars — so code-intelligence works
+ * WITHOUT the multi-megabyte `typescript` compiler dependency (#511).
+ *
+ * The KnowledgeGraphService uses this as a fallback when the TypeScript compiler
+ * API isn't available. Returns `null` when WASM/grammar can't load so the caller
+ * can degrade gracefully.
+ */
+import { loadWasmGrammar } from './tree-sitter-wasm-parser.js';
+/** Map a file extension to its grammar wasm file. */
+function grammarFor(ext) {
+    switch (ext) {
+        case 'ts':
+        case 'mts':
+        case 'cts':
+            return 'tree-sitter-typescript.wasm';
+        case 'tsx':
+            return 'tree-sitter-tsx.wasm';
+        case 'js':
+        case 'jsx':
+        case 'mjs':
+        case 'cjs':
+            return 'tree-sitter-javascript.wasm';
+        default:
+            return null;
+    }
+}
+export function isTreeSitterTsExtension(ext) {
+    return grammarFor(ext) !== null;
+}
+const line = (n) => n.startPosition.row + 1;
+const fieldText = (n, field) => n.childForFieldName(field)?.text ?? '';
+/** Whether a declaration node begins with the `async` keyword. */
+function isAsync(n) {
+    for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (!c)
+            continue;
+        if (c.type === 'async')
+            return true;
+        // keyword precedes the function/method keyword; stop once we pass it
+        if (c.type === 'function' || c.type === 'function_declaration')
+            break;
+    }
+    return false;
+}
+function methodVisibility(n) {
+    for (let i = 0; i < n.childCount; i++) {
+        const t = n.child(i)?.type;
+        if (t === 'accessibility_modifier') {
+            const text = n.child(i).text;
+            if (text === 'private')
+                return 'private';
+            if (text === 'protected')
+                return 'protected';
+        }
+    }
+    return 'public';
+}
+function extractClass(node) {
+    const name = fieldText(node, 'name') || '(anonymous)';
+    const body = node.childForFieldName('body');
+    const methods = [];
+    if (body) {
+        for (let i = 0; i < body.childCount; i++) {
+            const m = body.child(i);
+            if (m && m.type === 'method_definition') {
+                methods.push({
+                    name: fieldText(m, 'name'),
+                    startLine: line(m),
+                    isAsync: isAsync(m),
+                    visibility: methodVisibility(m),
+                });
+            }
+        }
+    }
+    return { name, startLine: line(node), methods };
+}
+/** Strip surrounding quotes from an import source literal. */
+function unquote(s) {
+    return s.replace(/^['"`]|['"`]$/g, '');
+}
+/**
+ * Extract entities/imports from TS/JS/TSX source. Returns null if the grammar
+ * could not be loaded (WASM unavailable) so callers can fall back.
+ */
+export async function extractTsJs(content, extension) {
+    const wasmFile = grammarFor(extension);
+    if (!wasmFile)
+        return null;
+    const grammar = await loadWasmGrammar(wasmFile);
+    if (!grammar)
+        return null;
+    let tree = null;
+    try {
+        const parsed = grammar.parse(content);
+        tree = parsed;
+        const root = parsed.rootNode;
+        if (!root)
+            return null;
+        const out = { functions: [], classes: [], interfaces: [], imports: [] };
+        // Iterative walk. We do NOT recurse into function/class bodies (entities are
+        // top-level / exported; methods are collected with their class).
+        const stack = [root];
+        while (stack.length) {
+            const node = stack.pop();
+            let recurse = true;
+            switch (node.type) {
+                case 'function_declaration':
+                case 'generator_function_declaration':
+                    out.functions.push({
+                        name: fieldText(node, 'name'),
+                        startLine: line(node),
+                        isAsync: isAsync(node),
+                        visibility: 'public',
+                    });
+                    recurse = false;
+                    break;
+                case 'class_declaration':
+                case 'class':
+                    out.classes.push(extractClass(node));
+                    recurse = false;
+                    break;
+                case 'interface_declaration':
+                    out.interfaces.push({ name: fieldText(node, 'name'), startLine: line(node) });
+                    recurse = false;
+                    break;
+                case 'lexical_declaration':
+                case 'variable_declaration': {
+                    // const/let foo = () => {} | function() {}  → treat as a function
+                    for (let i = 0; i < node.childCount; i++) {
+                        const d = node.child(i);
+                        if (!d || d.type !== 'variable_declarator')
+                            continue;
+                        const value = d.childForFieldName('value');
+                        if (value && (value.type === 'arrow_function' ||
+                            value.type === 'function' ||
+                            value.type === 'function_expression')) {
+                            out.functions.push({
+                                name: fieldText(d, 'name'),
+                                startLine: line(d),
+                                isAsync: isAsync(value),
+                                visibility: 'public',
+                            });
+                        }
+                        else if (value && value.type === 'call_expression' &&
+                            value.child(0)?.text === 'require') {
+                            // const x = require('y')
+                            const arg = value.childForFieldName('arguments')?.child(1);
+                            if (arg && arg.type === 'string')
+                                out.imports.push(unquote(arg.text));
+                        }
+                    }
+                    recurse = false;
+                    break;
+                }
+                case 'import_statement': {
+                    const src = node.childForFieldName('source');
+                    if (src)
+                        out.imports.push(unquote(src.text));
+                    recurse = false;
+                    break;
+                }
+                case 'call_expression': {
+                    // require('x')
+                    const fn = node.child(0);
+                    if (fn && fn.text === 'require') {
+                        const args = node.childForFieldName('arguments');
+                        const arg = args?.child(1); // ( <string> )
+                        if (arg && (arg.type === 'string'))
+                            out.imports.push(unquote(arg.text));
+                    }
+                    break;
+                }
+            }
+            if (recurse) {
+                for (let i = node.childCount - 1; i >= 0; i--) {
+                    const c = node.child(i);
+                    if (c)
+                        stack.push(c);
+                }
+            }
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        tree?.delete?.();
+    }
+}
+//# sourceMappingURL=treesitter-ts-extractor.js.map

package/dist/shared/utils/rabitq.d.ts

@@ -0,0 +1,133 @@
+/**
+ * RaBitQ-style 1-bit sign signatures for fast vector retrieval.
+ *
+ * Ports ruflo's perf-M4 optimization: sign-random-projection + Hamming popcount
+ * as a cheap prefilter ahead of exact cosine reranking.
+ *
+ * ## Why this works
+ *
+ * For unit-normalized embeddings, the sign of each coordinate is a valid
+ * Locality-Sensitive Hash (LSH) for cosine similarity: the probability that two
+ * vectors agree on the sign of a random projection is `1 - theta/pi`, where
+ * `theta` is the angle between them (Charikar 2002, "SimHash"). The AQE
+ * canonical embedding dimension is 384 (patterns.rvf dim=384); the coordinate
+ * basis itself acts as the random projection family, so `bit_i = (vec[i] >= 0)`
+ * yields a Hamming distance that is monotonically related to cosine angle.
+ *
+ * We therefore use Hamming distance over packed 1-bit signatures as a *cheap*
+ * ranking proxy to shrink the candidate pool, then run *exact* cosine on the
+ * survivors. With a large enough rerank pool the final top-k is identical to a
+ * full exact scan — only the work is reduced.
+ *
+ * ## Memory
+ *
+ * A 384-dim Float32 vector costs 1536 bytes. Its sign signature costs 48 bytes
+ * (12 × uint32). That is a 32× index-memory reduction for the prefilter stage.
+ *
+ * Self-contained: no I/O, no side effects, pure functions + one ranking helper.
+ *
+ * @module shared/utils/rabitq
+ */
+/** AQE canonical embedding dimension (patterns.rvf dim=384). */
+export declare const SIGNATURE_DIM = 384;
+/**
+ * Bytes per signature for the canonical 384-dim embedding:
+ * ceil(384 / 32) = 12 words × 4 bytes = 48 bytes.
+ * (vs 384 × 4 = 1536 bytes for the raw Float32 vector → 32× reduction.)
+ */
+export declare const SIGNATURE_BYTES: number;
+/**
+ * Build a 1-bit sign signature from a vector.
+ *
+ * `bit_i = (vec[i] >= 0)`. Bits are packed LSB-first into Uint32 words:
+ * coordinate `i` lives in word `i >> 5` at bit `i & 31`.
+ *
+ * For a 384-dim input this returns 12 words (48 bytes). Inputs of other
+ * dimensions are supported (signature length = ceil(dim / 32) words).
+ *
+ * @param vec Embedding vector (assumed unit-normalized for the LSH guarantee,
+ *            but the function works on any real vector).
+ * @returns Packed sign bits as a Uint32Array.
+ */
+export declare function signSignature(vec: number[] | Float32Array): Uint32Array;
+/**
+ * Hamming distance between two packed signatures: popcount(a XOR b) summed
+ * over all words.
+ *
+ * @throws If the two signatures have different word lengths.
+ */
+export declare function hammingDistance(a: Uint32Array, b: Uint32Array): number;
+/**
+ * Hamming similarity in [0, 1]: `1 - hammingDistance / bits`.
+ *
+ * This is a monotonic proxy for cosine similarity (higher = closer). `bits`
+ * should be the true embedding dimension (e.g. 384), not `words × 32`, so that
+ * trailing padding bits — which are always 0 in both signatures and never
+ * contribute to the distance — don't deflate the normalization.
+ */
+export declare function hammingSimilarity(a: Uint32Array, b: Uint32Array, bits: number): number;
+/** A retrieval candidate. `signature` is optional and lazily built if absent. */
+export interface RaBitQCandidate {
+    id: string;
+    vector: number[] | Float32Array;
+    /** Precomputed sign signature; built on demand from `vector` if omitted. */
+    signature?: Uint32Array;
+}
+/** A scored result. `score` is the exact cosine similarity (or Hamming proxy). */
+export interface RaBitQResult {
+    id: string;
+    score: number;
+}
+/** Tuning knobs for {@link topKBySignature}. */
+export interface TopKOptions {
+    /**
+     * Below this candidate count, skip RaBitQ entirely and do an exact cosine
+     * top-k. RaBitQ's signature-build + Hamming-scan overhead is not worth it for
+     * small N. Default 100 (matches ruflo's gate).
+     */
+    gateN?: number;
+    /**
+     * How many Hamming-ranked candidates to feed into the exact rerank.
+     *
+     * Larger pool → higher recall, more exact-cosine work. **Default is
+     * recall-aware**: `max(4 × k, ceil(0.4 × N))`.
+     *
+     * IMPORTANT — empirically measured tradeoff (384-dim, see
+     * scripts/benchmark-rabitq.ts): a 1-bit sign signature is a *coarse*
+     * quantization, so a small fixed pool (e.g. `4 × k = 40`) does NOT preserve
+     * recall@10 at scale — at N=1000 it captures only ~70-85% of the true top-10,
+     * and worse at N=5000. To keep recall@10 ≥ ~0.95 the pool must be a sizeable
+     * fraction of N (~40% empirically), which limits the achievable speedup.
+     * Callers that can tolerate lower recall may pass a smaller pool for more
+     * speed; callers that need exact output should not use RaBitQ at all.
+     */
+    rerankPool?: number;
+    /**
+     * If true (default), run full cosineSimilarity on the Hamming-top pool and
+     * return the true top-k by cosine. If false, return the Hamming-only ranking
+     * (faster, approximate).
+     */
+    exactRerank?: boolean;
+}
+/**
+ * Retrieve the top-k candidates for a query using a RaBitQ Hamming prefilter
+ * followed by an exact cosine rerank.
+ *
+ * Behavior:
+ * - `candidates.length < gateN` → plain exact cosine top-k (gate; RaBitQ
+ *   overhead not worth it for small N).
+ * - otherwise → build/reuse sign signatures, rank ALL candidates by Hamming
+ *   distance (cheap), take the top `rerankPool`, then:
+ *     - `exactRerank=true` (default): run FULL cosine on just that pool and
+ *       return the true top-k. Output equals an exact scan whenever the true
+ *       top-k all fall within the Hamming top-`rerankPool` — recall is
+ *       preserved by the rerank, only speed changes.
+ *     - `exactRerank=false`: return the Hamming-only top-k (approximate).
+ *
+ * @param query Query vector (same dimension as candidate vectors).
+ * @param candidates Candidate set.
+ * @param k Number of results to return.
+ * @param opts Tuning knobs (see {@link TopKOptions}).
+ */
+export declare function topKBySignature(query: number[] | Float32Array, candidates: RaBitQCandidate[], k: number, opts?: TopKOptions): RaBitQResult[];
+//# sourceMappingURL=rabitq.d.ts.map

package/dist/shared/utils/rabitq.js

@@ -0,0 +1,201 @@
+/**
+ * RaBitQ-style 1-bit sign signatures for fast vector retrieval.
+ *
+ * Ports ruflo's perf-M4 optimization: sign-random-projection + Hamming popcount
+ * as a cheap prefilter ahead of exact cosine reranking.
+ *
+ * ## Why this works
+ *
+ * For unit-normalized embeddings, the sign of each coordinate is a valid
+ * Locality-Sensitive Hash (LSH) for cosine similarity: the probability that two
+ * vectors agree on the sign of a random projection is `1 - theta/pi`, where
+ * `theta` is the angle between them (Charikar 2002, "SimHash"). The AQE
+ * canonical embedding dimension is 384 (patterns.rvf dim=384); the coordinate
+ * basis itself acts as the random projection family, so `bit_i = (vec[i] >= 0)`
+ * yields a Hamming distance that is monotonically related to cosine angle.
+ *
+ * We therefore use Hamming distance over packed 1-bit signatures as a *cheap*
+ * ranking proxy to shrink the candidate pool, then run *exact* cosine on the
+ * survivors. With a large enough rerank pool the final top-k is identical to a
+ * full exact scan — only the work is reduced.
+ *
+ * ## Memory
+ *
+ * A 384-dim Float32 vector costs 1536 bytes. Its sign signature costs 48 bytes
+ * (12 × uint32). That is a 32× index-memory reduction for the prefilter stage.
+ *
+ * Self-contained: no I/O, no side effects, pure functions + one ranking helper.
+ *
+ * @module shared/utils/rabitq
+ */
+import { cosineSimilarity } from './vector-math.js';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Bits packed per Uint32 word. */
+const BITS_PER_WORD = 32;
+/** AQE canonical embedding dimension (patterns.rvf dim=384). */
+export const SIGNATURE_DIM = 384;
+/**
+ * Bytes per signature for the canonical 384-dim embedding:
+ * ceil(384 / 32) = 12 words × 4 bytes = 48 bytes.
+ * (vs 384 × 4 = 1536 bytes for the raw Float32 vector → 32× reduction.)
+ */
+export const SIGNATURE_BYTES = Math.ceil(SIGNATURE_DIM / BITS_PER_WORD) * 4; // 48
+// ============================================================================
+// Popcount (Brian-Kernighan)
+// ============================================================================
+/**
+ * Population count (number of set bits) of a 32-bit word.
+ *
+ * Uses the SWAR (SIMD-within-a-register) bit-twiddle which is branchless and
+ * faster than a per-byte table lookup for 32-bit words. The hdc-fingerprint
+ * module uses a 256-entry per-byte table + Brian-Kernighan for its Uint8Array
+ * vectors; here we operate on Uint32 words, so the SWAR variant is the natural
+ * fit and avoids importing/splitting words into bytes.
+ */
+function popcount32(n) {
+    // Force unsigned 32-bit semantics.
+    n = n >>> 0;
+    n = n - ((n >>> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+    n = (n + (n >>> 4)) & 0x0f0f0f0f;
+    return (Math.imul(n, 0x01010101) >>> 24) & 0xff;
+}
+// ============================================================================
+// Signature construction
+// ============================================================================
+/**
+ * Build a 1-bit sign signature from a vector.
+ *
+ * `bit_i = (vec[i] >= 0)`. Bits are packed LSB-first into Uint32 words:
+ * coordinate `i` lives in word `i >> 5` at bit `i & 31`.
+ *
+ * For a 384-dim input this returns 12 words (48 bytes). Inputs of other
+ * dimensions are supported (signature length = ceil(dim / 32) words).
+ *
+ * @param vec Embedding vector (assumed unit-normalized for the LSH guarantee,
+ *            but the function works on any real vector).
+ * @returns Packed sign bits as a Uint32Array.
+ */
+export function signSignature(vec) {
+    const dim = vec.length;
+    const words = Math.ceil(dim / BITS_PER_WORD);
+    const sig = new Uint32Array(words);
+    for (let i = 0; i < dim; i++) {
+        if (vec[i] >= 0) {
+            sig[i >> 5] |= 1 << (i & 31);
+        }
+    }
+    return sig;
+}
+// ============================================================================
+// Hamming distance / similarity
+// ============================================================================
+/**
+ * Hamming distance between two packed signatures: popcount(a XOR b) summed
+ * over all words.
+ *
+ * @throws If the two signatures have different word lengths.
+ */
+export function hammingDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Signature length mismatch: ${a.length} vs ${b.length} words`);
+    }
+    let dist = 0;
+    for (let i = 0; i < a.length; i++) {
+        dist += popcount32((a[i] ^ b[i]) >>> 0);
+    }
+    return dist;
+}
+/**
+ * Hamming similarity in [0, 1]: `1 - hammingDistance / bits`.
+ *
+ * This is a monotonic proxy for cosine similarity (higher = closer). `bits`
+ * should be the true embedding dimension (e.g. 384), not `words × 32`, so that
+ * trailing padding bits — which are always 0 in both signatures and never
+ * contribute to the distance — don't deflate the normalization.
+ */
+export function hammingSimilarity(a, b, bits) {
+    if (bits <= 0)
+        return 0;
+    return 1 - hammingDistance(a, b) / bits;
+}
+/**
+ * Exact cosine top-k over all candidates. Shared by the small-N gate and the
+ * rerank stage.
+ */
+function exactTopK(query, candidates, k) {
+    const scored = new Array(candidates.length);
+    for (let i = 0; i < candidates.length; i++) {
+        scored[i] = {
+            id: candidates[i].id,
+            score: cosineSimilarity(query, candidates[i].vector),
+        };
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, k);
+}
+/**
+ * Retrieve the top-k candidates for a query using a RaBitQ Hamming prefilter
+ * followed by an exact cosine rerank.
+ *
+ * Behavior:
+ * - `candidates.length < gateN` → plain exact cosine top-k (gate; RaBitQ
+ *   overhead not worth it for small N).
+ * - otherwise → build/reuse sign signatures, rank ALL candidates by Hamming
+ *   distance (cheap), take the top `rerankPool`, then:
+ *     - `exactRerank=true` (default): run FULL cosine on just that pool and
+ *       return the true top-k. Output equals an exact scan whenever the true
+ *       top-k all fall within the Hamming top-`rerankPool` — recall is
+ *       preserved by the rerank, only speed changes.
+ *     - `exactRerank=false`: return the Hamming-only top-k (approximate).
+ *
+ * @param query Query vector (same dimension as candidate vectors).
+ * @param candidates Candidate set.
+ * @param k Number of results to return.
+ * @param opts Tuning knobs (see {@link TopKOptions}).
+ */
+export function topKBySignature(query, candidates, k, opts = {}) {
+    const gateN = opts.gateN ?? 100;
+    const exactRerank = opts.exactRerank ?? true;
+    const n = candidates.length;
+    if (n === 0 || k <= 0)
+        return [];
+    // Recall-aware default pool: a 1-bit signature in high dimensions is coarse,
+    // so the pool must scale with N to keep recall high (see rerankPool docs).
+    const rerankPool = opts.rerankPool ?? Math.max(4 * k, Math.ceil(0.4 * n));
+    // Small-N gate: exact cosine, skip signature machinery entirely.
+    if (n < gateN) {
+        return exactTopK(query, candidates, Math.min(k, n));
+    }
+    const bits = query.length;
+    const querySig = signSignature(query);
+    // Rank ALL candidates by Hamming distance (cheap popcount scan).
+    const hammingRanked = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const cand = candidates[i];
+        const sig = cand.signature ?? signSignature(cand.vector);
+        hammingRanked[i] = { idx: i, dist: hammingDistance(querySig, sig) };
+    }
+    // Ascending distance = descending similarity.
+    hammingRanked.sort((a, b) => a.dist - b.dist);
+    const poolSize = Math.min(rerankPool, n);
+    if (!exactRerank) {
+        // Hamming-only ranking: return the top-k by Hamming proxy similarity.
+        const topK = Math.min(k, n);
+        const out = new Array(topK);
+        for (let i = 0; i < topK; i++) {
+            const { idx, dist } = hammingRanked[i];
+            out[i] = { id: candidates[idx].id, score: 1 - dist / bits };
+        }
+        return out;
+    }
+    // Exact rerank: full cosine over the Hamming-top pool, return true top-k.
+    const pool = new Array(poolSize);
+    for (let i = 0; i < poolSize; i++) {
+        pool[i] = candidates[hammingRanked[i].idx];
+    }
+    return exactTopK(query, pool, Math.min(k, poolSize));
+}
+//# sourceMappingURL=rabitq.js.map

package/dist/shared/utils/safe-expression-evaluator.js

@@ -192,6 +192,7 @@ class Parser {
     }
     parseExpression(minPrecedence) {
         let left = this.parseUnary();
+        // eslint-disable-next-line no-constant-condition -- tokenizer loop; breaks internally
         while (true) {
             const token = this.current();
             if (token.type !== 'OPERATOR' || !BINARY_OPERATORS.has(token.value)) {
@@ -229,17 +230,19 @@ class Parser {
             case 'IDENTIFIER':
                 return this.parseIdentifier();
             case 'LPAREN':
-                this.advance();
-                const result = this.parseExpression(0);
-                this.expect('RPAREN');
-                return result;
+                {
+                    this.advance();
+                    const result = this.parseExpression(0);
+                    this.expect('RPAREN');
+                    return result;
+                }
             default:
                 throw new Error(`Unexpected token: ${token.raw}`);
         }
     }
     parseIdentifier() {
         let value = this.context;
-        let name = this.advance().value;
+        const name = this.advance().value;
         // Get initial value from context
         if (typeof value === 'object' && value !== null && name in value) {
             value = value[name];

package/dist/sync/cloud/postgres-writer.js

@@ -285,6 +285,7 @@ export class PostgresWriter {
             let jsonStr = JSON.stringify(value);
             if (columnName && this.isJsonbColumn(columnName)) {
                 // Remove NUL chars (PostgreSQL JSONB rejects \u0000)
+                // eslint-disable-next-line no-control-regex -- NUL stripping required: PostgreSQL JSONB rejects \u0000
                 jsonStr = jsonStr.replace(/\u0000/g, '');
                 try {
                     JSON.parse(jsonStr);
@@ -316,6 +317,7 @@ export class PostgresWriter {
             }
             // JSONB columns: validate JSON, sanitize NUL chars, wrap if invalid
             if (columnName && this.isJsonbColumn(columnName)) {
+                // eslint-disable-next-line no-control-regex -- NUL stripping required: PostgreSQL JSONB rejects \u0000
                 const sanitized = value.replace(/\u0000/g, '');
                 try {
                     JSON.parse(sanitized);

package/dist/sync/readers/json-reader.js

@@ -50,7 +50,7 @@ export class JSONReader {
             const content = fs.readFileSync(this.filePath, 'utf-8');
             const parsed = secureJsonParse.parse(content);
             // Extract data based on JSON path if specified
-            let records = this.extractRecords(parsed);
+            const records = this.extractRecords(parsed);
             // Transform records
             return records.map(record => this.transformRecord(record));
         }

package/dist/test-scheduling/git-aware/test-selector.js

@@ -191,7 +191,7 @@ export class GitAwareTestSelector {
     async mapChangesToTests(changedFiles) {
         const selectedTests = [];
         const mappings = [];
-        let runAllTests = false;
+        const runAllTests = false;
         let runAllReason;
         // Check for config file changes first - these require full test run
         for (const file of changedFiles) {