@aroman22/codegraph-vba-darwin-arm64 1.15.0 → 1.16.0

package/lib/dist/extraction/index.js

@@ -1502,9 +1502,22 @@ class ExtractionOrchestrator {
         // Issue #152: pull the optional `vba.maxRaiseFanout` knob from the
         // same `codegraph.json` → `vba` block the targets live in. The VBA
         // extractor applies the per-file fanout gate at this threshold.
+        // Issue #243: the knobs travel as ONE structured-cloneable options object
+        // from here to the extractor, on the pool path and the in-process path
+        // alike, so a new knob is a field here instead of a new positional in
+        // five signatures.
         const vbaConfig = (0, project_config_1.loadVbaConfig)(this.rootDir);
-        const vbaTargets = vbaConfig.targets;
-        const maxRaiseFanout = vbaConfig.maxRaiseFanout;
+        const vbaOptions = {
+            targets: vbaConfig.targets,
+            maxRaiseFanout: vbaConfig.maxRaiseFanout,
+            // Issue #244: extra SQL execution-site receivers. Plain strings — the
+            // compiled matcher is built inside the extractor because a RegExp
+            // cannot cross the `structuredClone` worker boundary.
+            sqlWrappers: vbaConfig.sqlWrappers,
+            // Issue #261: the project's error-channel variable names. Plain strings
+            // for the same worker-boundary reason as `sqlWrappers`.
+            errorChannel: vbaConfig.errorChannel,
+        };
         // Issue #154 — gate the 3 Dysflow-specific VBA sub-extractors. `true`
         // (the default) keeps the pre-refactor behavior; `false` opts out so
         // form/report/manifest/sequence files are tracked as just a `file`
@@ -1579,376 +1592,328 @@ class ExtractionOrchestrator {
         const parseWorkerPath = path.join(__dirname, 'parse-worker.js');
         const useWorker = fs.existsSync(parseWorkerPath);
         let pool = null;
-        if (useWorker) {
-            // CODEGRAPH_PARSE_WORKERS: explicit worker count; 1 = the old single-worker
-            // behaviour (the conservative rollback). Unset → clamp(cores-1, 1, 8).
-            const poolSize = (0, parse_pool_1.resolveParsePoolSize)(process.env.CODEGRAPH_PARSE_WORKERS, os.cpus().length);
-            // Read each needed grammar's WASM ONCE here and hand the bytes to every
-            // worker, so spawns/respawns load grammars from memory instead of
-            // re-reading them from disk (#1231: on an HDD, respawn re-reads amplify
-            // the very I/O contention that caused the respawn).
-            const grammarBuffers = await (0, grammars_1.readGrammarWasmBytes)(neededLanguages);
-            pool = new parse_pool_1.ParseWorkerPool({
-                languages: neededLanguages,
-                size: poolSize,
-                workerScriptPath: parseWorkerPath,
-                recycleInterval: WORKER_RECYCLE_INTERVAL,
-                parseTimeoutMs: PARSE_TIMEOUT_MS,
-                log,
-                grammarBuffers,
-            });
-            log(`Parse worker pool: ${poolSize} worker(s)`);
-        }
-        else {
-            // In-process fallback: load grammars locally and parse on the main thread.
-            await (0, grammars_1.loadGrammarsForLanguages)(neededLanguages);
-        }
-        /**
-         * Parse one file: on the pool when available (the promise REJECTS on a worker
-         * crash/timeout — the caller records it and the retry pass re-attempts), or
-         * in-process synchronously as the no-worker fallback. The language is resolved
-         * here on the main thread, where the codegraph.json overrides are loaded.
-         */
-        const parseFile = (filePath, content) => {
-            const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
-            // Issue #152: thread the optional `vba.maxRaiseFanout` knob through
-            // the worker boundary (or the in-process fallback) so every VBA
-            // file sees the same gate.
-            // Issue #154: also thread the optional `vba.dysflowExport` flag.
-            if (!pool)
-                return Promise.resolve((0, tree_sitter_1.extractFromSource)(filePath, content, language, frameworkNames, vbaTargets, maxRaiseFanout, dysflowExport));
-            return pool.requestParse({ filePath, content, language, frameworkNames, vbaTargets, maxRaiseFanout, dysflowExport });
-        };
-        // --- Bounded rolling-window dispatch, ordered commit ---
-        // Reads stay batched/parallel; parses run concurrently across the pool; the
-        // SQLite store stays on the main thread (it isn't thread-safe). Crucially we
-        // COMMIT results in original file order, not parse-completion order: the
-        // resolution phase (run after indexing) resolves an ambiguous reference to one
-        // of several same-named candidates by the nodes' DB insertion order, so a
-        // stable commit order keeps the resulting graph deterministic — byte-identical
-        // to the single-worker path — instead of drifting with parse timing. The
-        // `completed` buffer holds at most ~windowSize out-of-order results, so memory
-        // stays bounded.
-        const windowSize = pool ? Math.max(4, pool.size * 2) : 1;
-        const inFlight = new Set();
-        const completed = new Map();
-        let nextSeq = 0; // file-order sequence assigned at dispatch
-        let nextToStore = 0; // cursor: next sequence to commit
-        let aborted = false;
-        // Yielder for the in-order commit path: a single giant generated file's
-        // store is otherwise one unyielding multi-second transaction span on the
-        // main thread (5–14s single stalls measured on llvm-project), starving
-        // the #850 watchdog heartbeat on slow hardware.
-        const commitYield = (0, cooperative_yield_1.createYielder)();
-        const storeResult = async (filePath, content, stats, result) => {
-            processed++;
-            // WAL hard-cap backstop: between files (never mid-transaction), pause
-            // the store until the off-thread checkpoint catches up. Resolves to
-            // null in the normal case — a single size check, no cost.
-            const bp = walBackpressure?.();
-            if (bp)
-                await bp;
-            // Store in database on main thread (SQLite is not thread-safe)
-            if (result.nodes.length > 0 || result.errors.length === 0) {
-                const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
-                await this.storeExtractionResult(filePath, content, language, stats, result, commitYield);
-            }
-            if (result.errors.length > 0) {
-                for (const err of result.errors) {
-                    if (!err.filePath)
-                        err.filePath = filePath;
-                }
-                errors.push(...result.errors);
-            }
-            if (result.nodes.length > 0) {
-                filesIndexed++;
-                totalNodes += result.nodes.length;
-                totalEdges += result.edges.length;
-            }
-            else if (result.errors.some((e) => e.severity === 'error')) {
-                filesErrored++;
+        try {
+            if (useWorker) {
+                // CODEGRAPH_PARSE_WORKERS: explicit worker count; 1 = the old single-worker
+                // behaviour (the conservative rollback). Unset → clamp(cores-1, 1, 8).
+                const poolSize = (0, parse_pool_1.resolveParsePoolSize)(process.env.CODEGRAPH_PARSE_WORKERS, os.cpus().length);
+                // Read each needed grammar's WASM ONCE here and hand the bytes to every
+                // worker, so spawns/respawns load grammars from memory instead of
+                // re-reading them from disk (#1231: on an HDD, respawn re-reads amplify
+                // the very I/O contention that caused the respawn).
+                const grammarBuffers = await (0, grammars_1.readGrammarWasmBytes)(neededLanguages);
+                pool = new parse_pool_1.ParseWorkerPool({
+                    languages: neededLanguages,
+                    size: poolSize,
+                    workerScriptPath: parseWorkerPath,
+                    recycleInterval: WORKER_RECYCLE_INTERVAL,
+                    parseTimeoutMs: PARSE_TIMEOUT_MS,
+                    log,
+                    grammarBuffers,
+                });
+                log(`Parse worker pool: ${poolSize} worker(s)`);
             }
             else {
-                // Files with no symbols but no errors (yaml, twig, properties) are
-                // tracked at the file level — count them as indexed so the CLI doesn't
-                // misleadingly report "No files found to index".
-                const lang = (0, grammars_1.detectLanguage)(filePath, content, overrides);
-                if ((0, grammars_1.isFileLevelOnlyLanguage)(lang)) {
-                    filesIndexed++;
-                }
-                else {
-                    filesSkipped++;
-                }
+                // In-process fallback: load grammars locally and parse on the main thread.
+                await (0, grammars_1.loadGrammarsForLanguages)(neededLanguages);
             }
-            onProgress?.({ phase: 'parsing', current: processed, total, currentFile: filePath });
-        };
-        const recordParseFailure = (filePath, err) => {
-            processed++;
-            filesErrored++;
-            errors.push({
-                message: err instanceof Error ? err.message : String(err),
-                filePath,
-                severity: 'error',
-                code: 'parse_error',
-            });
-            onProgress?.({ phase: 'parsing', current: processed, total });
-        };
-        // Commit buffered parses to the DB in file order, advancing the cursor over
-        // contiguous completed results. Runs after each parse settles (and once more
-        // after the drain). storeResult is now async (it yields between chunked
-        // inserts), so commits are SERIALIZED on a promise chain — concurrent parse
-        // completions append to the chain instead of interleaving mid-store, which
-        // preserves both the file-order commit invariant (#1015: resolution
-        // disambiguates same-named candidates by insertion order) and the
-        // single-writer discipline for SQLite. Errors are recorded and re-thrown
-        // at the drain, matching the old synchronous propagation.
-        let flushChain = Promise.resolve();
-        let flushError = null;
-        const flushOrdered = () => {
-            flushChain = flushChain.then(async () => {
-                if (aborted || flushError)
-                    return;
-                try {
-                    while (completed.has(nextToStore)) {
-                        const item = completed.get(nextToStore);
-                        completed.delete(nextToStore);
-                        nextToStore++;
-                        if (item.ok)
-                            await storeResult(item.filePath, item.content, item.stats, item.result);
-                        else
-                            recordParseFailure(item.filePath, item.err);
-                    }
+            /**
+             * Parse one file: on the pool when available (the promise REJECTS on a worker
+             * crash/timeout — the caller records it and the retry pass re-attempts), or
+             * in-process synchronously as the no-worker fallback. The language is resolved
+             * here on the main thread, where the codegraph.json overrides are loaded.
+             */
+            const parseFile = (filePath, content) => {
+                const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
+                // Issue #152: thread the optional `vba.maxRaiseFanout` knob through
+                // the worker boundary (or the in-process fallback) so every VBA
+                // file sees the same gate.
+                // Issue #154: also thread the optional `vba.dysflowExport` flag.
+                // Issue #243: both knobs now ride in the `vbaOptions` object.
+                if (!pool)
+                    return Promise.resolve((0, tree_sitter_1.extractFromSource)(filePath, content, language, frameworkNames, undefined, undefined, dysflowExport, vbaOptions));
+                return pool.requestParse({ filePath, content, language, frameworkNames, vbaOptions, dysflowExport });
+            };
+            // --- Bounded rolling-window dispatch, ordered commit ---
+            // Reads stay batched/parallel; parses run concurrently across the pool; the
+            // SQLite store stays on the main thread (it isn't thread-safe). Crucially we
+            // COMMIT results in original file order, not parse-completion order: the
+            // resolution phase (run after indexing) resolves an ambiguous reference to one
+            // of several same-named candidates by the nodes' DB insertion order, so a
+            // stable commit order keeps the resulting graph deterministic — byte-identical
+            // to the single-worker path — instead of drifting with parse timing. The
+            // `completed` buffer holds at most ~windowSize out-of-order results, so memory
+            // stays bounded.
+            const windowSize = pool ? Math.max(4, pool.size * 2) : 1;
+            const inFlight = new Set();
+            const completed = new Map();
+            let nextSeq = 0; // file-order sequence assigned at dispatch
+            let nextToStore = 0; // cursor: next sequence to commit
+            let aborted = false;
+            // Yielder for the in-order commit path: a single giant generated file's
+            // store is otherwise one unyielding multi-second transaction span on the
+            // main thread (5–14s single stalls measured on llvm-project), starving
+            // the #850 watchdog heartbeat on slow hardware.
+            const commitYield = (0, cooperative_yield_1.createYielder)();
+            const storeResult = async (filePath, content, stats, result) => {
+                processed++;
+                // WAL hard-cap backstop: between files (never mid-transaction), pause
+                // the store until the off-thread checkpoint catches up. Resolves to
+                // null in the normal case — a single size check, no cost.
+                const bp = walBackpressure?.();
+                if (bp)
+                    await bp;
+                // Store in database on main thread (SQLite is not thread-safe)
+                if (result.nodes.length > 0 || result.errors.length === 0) {
+                    const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
+                    await this.storeExtractionResult(filePath, content, language, stats, result, commitYield);
                 }
-                catch (err) {
-                    flushError = err;
+                if (result.errors.length > 0) {
+                    for (const err of result.errors) {
+                        if (!err.filePath)
+                            err.filePath = filePath;
+                    }
+                    errors.push(...result.errors);
                 }
-            });
-            return flushChain;
-        };
-        // Dispatch one file's parse (parses run concurrently across the pool), tagged
-        // with its file-order sequence so flushOrdered commits results in order. The
-        // backpressure below bounds how far parsing runs ahead of the in-order commit.
-        const feed = async (filePath, content, stats) => {
-            const seq = nextSeq++;
-            const p = (async () => {
-                try {
-                    const result = await parseFile(filePath, content);
-                    completed.set(seq, { ok: true, filePath, content, stats, result });
+                if (result.nodes.length > 0) {
+                    filesIndexed++;
+                    totalNodes += result.nodes.length;
+                    totalEdges += result.edges.length;
                 }
-                catch (parseErr) {
-                    completed.set(seq, { ok: false, filePath, err: parseErr });
+                else if (result.errors.some((e) => e.severity === 'error')) {
+                    filesErrored++;
                 }
-                flushOrdered();
-            })();
-            const tracked = p.finally(() => { inFlight.delete(tracked); });
-            inFlight.add(tracked);
-            // Backpressure on the dispatched-but-not-yet-committed count (in-flight +
-            // buffered), not just in-flight: a slow file sitting at the commit cursor
-            // lets later parses finish and buffer, which would otherwise grow without
-            // bound. Wait for parses to settle (each may advance the cursor) until the
-            // window has room. When nothing is in flight but the window is still full,
-            // the async commit chain is what's behind — await it so the cursor
-            // advances (buffered items hold whole file contents, so this bound is
-            // load-bearing for memory).
-            while (nextSeq - nextToStore >= windowSize) {
-                if (inFlight.size > 0)
-                    await Promise.race(inFlight);
-                else
-                    await flushOrdered();
-            }
-        };
-        for (let i = 0; i < files.length; i += FILE_IO_BATCH_SIZE) {
-            if (signal?.aborted) {
-                aborted = true;
-                break;
-            }
-            const batch = files.slice(i, i + FILE_IO_BATCH_SIZE);
-            // Read files in parallel (with path validation before any I/O)
-            const fileContents = await Promise.all(batch.map(async (fp) => {
-                try {
-                    // Indexing read: follow in-root symlinks the directory walk already
-                    // descended into (the `../` guard still applies) so files reached
-                    // via an in-root symlink-to-outside still index (#935).
-                    const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, fp, { allowSymlinkEscape: true });
-                    if (!fullPath) {
-                        (0, errors_1.logWarn)('Path traversal blocked in batch reader', { filePath: fp });
-                        return { filePath: fp, content: null, stats: null, error: new Error('Path traversal blocked') };
+                else {
+                    // Files with no symbols but no errors (yaml, twig, properties) are
+                    // tracked at the file level — count them as indexed so the CLI doesn't
+                    // misleadingly report "No files found to index".
+                    const lang = (0, grammars_1.detectLanguage)(filePath, content, overrides);
+                    if ((0, grammars_1.isFileLevelOnlyLanguage)(lang)) {
+                        filesIndexed++;
+                    }
+                    else {
+                        filesSkipped++;
                     }
-                    const content = await readForExtraction(fullPath);
-                    const stats = await fsp.stat(fullPath);
-                    return { filePath: fp, content, stats, error: null };
                 }
-                catch (err) {
-                    return { filePath: fp, content: null, stats: null, error: err };
+                onProgress?.({ phase: 'parsing', current: processed, total, currentFile: filePath });
+            };
+            const recordParseFailure = (filePath, err) => {
+                processed++;
+                filesErrored++;
+                errors.push({
+                    message: err instanceof Error ? err.message : String(err),
+                    filePath,
+                    severity: 'error',
+                    code: 'parse_error',
+                });
+                onProgress?.({ phase: 'parsing', current: processed, total });
+            };
+            // Commit buffered parses to the DB in file order, advancing the cursor over
+            // contiguous completed results. Runs after each parse settles (and once more
+            // after the drain). storeResult is now async (it yields between chunked
+            // inserts), so commits are SERIALIZED on a promise chain — concurrent parse
+            // completions append to the chain instead of interleaving mid-store, which
+            // preserves both the file-order commit invariant (#1015: resolution
+            // disambiguates same-named candidates by insertion order) and the
+            // single-writer discipline for SQLite. Errors are recorded and re-thrown
+            // at the drain, matching the old synchronous propagation.
+            let flushChain = Promise.resolve();
+            let flushError = null;
+            const flushOrdered = () => {
+                flushChain = flushChain.then(async () => {
+                    if (aborted || flushError)
+                        return;
+                    try {
+                        while (completed.has(nextToStore)) {
+                            const item = completed.get(nextToStore);
+                            completed.delete(nextToStore);
+                            nextToStore++;
+                            if (item.ok)
+                                await storeResult(item.filePath, item.content, item.stats, item.result);
+                            else
+                                recordParseFailure(item.filePath, item.err);
+                        }
+                    }
+                    catch (err) {
+                        flushError = err;
+                    }
+                });
+                return flushChain;
+            };
+            // Dispatch one file's parse (parses run concurrently across the pool), tagged
+            // with its file-order sequence so flushOrdered commits results in order. The
+            // backpressure below bounds how far parsing runs ahead of the in-order commit.
+            const feed = async (filePath, content, stats) => {
+                const seq = nextSeq++;
+                const p = (async () => {
+                    try {
+                        const result = await parseFile(filePath, content);
+                        completed.set(seq, { ok: true, filePath, content, stats, result });
+                    }
+                    catch (parseErr) {
+                        completed.set(seq, { ok: false, filePath, err: parseErr });
+                    }
+                    flushOrdered();
+                })();
+                const tracked = p.finally(() => { inFlight.delete(tracked); });
+                inFlight.add(tracked);
+                // Backpressure on the dispatched-but-not-yet-committed count (in-flight +
+                // buffered), not just in-flight: a slow file sitting at the commit cursor
+                // lets later parses finish and buffer, which would otherwise grow without
+                // bound. Wait for parses to settle (each may advance the cursor) until the
+                // window has room. When nothing is in flight but the window is still full,
+                // the async commit chain is what's behind — await it so the cursor
+                // advances (buffered items hold whole file contents, so this bound is
+                // load-bearing for memory).
+                while (nextSeq - nextToStore >= windowSize) {
+                    if (inFlight.size > 0)
+                        await Promise.race(inFlight);
+                    else
+                        await flushOrdered();
                 }
-            }));
-            // Dispatch each readable file into the bounded parse window; the window
-            // stores results on the main thread as they arrive.
-            for (const { filePath, content, stats, error } of fileContents) {
+            };
+            for (let i = 0; i < files.length; i += FILE_IO_BATCH_SIZE) {
                 if (signal?.aborted) {
                     aborted = true;
                     break;
                 }
-                if (error || content === null || stats === null) {
-                    processed++;
-                    filesErrored++;
-                    errors.push({
-                        message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-                        filePath,
-                        severity: 'error',
-                        code: 'read_error',
-                    });
-                    onProgress?.({ phase: 'parsing', current: processed, total });
-                    continue;
-                }
-                // Honour MAX_FILE_SIZE. Without this check, vendored generated
-                // headers, minified bundles, and other multi-MB files get indexed,
-                // wasting WASM heap and the worker recycle budget on inputs with no
-                // useful symbols. The single-file extractFile path already enforces
-                // this; the bulk path used to silently skip the check.
-                if (stats.size > MAX_FILE_SIZE) {
-                    processed++;
-                    filesSkipped++;
-                    errors.push({
-                        message: `File exceeds max size (${stats.size} > ${MAX_FILE_SIZE})`,
-                        filePath,
-                        severity: 'warning',
-                        code: 'size_exceeded',
-                    });
-                    onProgress?.({ phase: 'parsing', current: processed, total });
-                    continue;
-                }
-                // Parse on the pool (main thread stays unblocked). Errors/timeouts are
-                // handled inside feed() → recordParseFailure, feeding the retry pass.
-                await feed(filePath, content, stats);
-            }
-            if (aborted)
-                break;
-        }
-        // Drain parses still in flight (skip on abort — we tear down below instead),
-        // then commit any results the cursor hasn't reached yet.
-        if (!aborted) {
-            await Promise.all(inFlight);
-            await flushOrdered();
-            if (flushError)
-                throw flushError;
-        }
-        if (signal?.aborted || aborted) {
-            if (pool)
-                await pool.destroy();
-            return {
-                success: false,
-                filesIndexed,
-                filesSkipped,
-                filesErrored,
-                filesDiscovered: total,
-                nodesCreated: totalNodes,
-                edgesCreated: totalEdges,
-                errors: [{ message: 'Aborted', severity: 'error' }, ...errors],
-                durationMs: Date.now() - startTime,
-            };
-        }
-        // Report 100% so the progress bar doesn't hang at 99%
-        onProgress?.({
-            phase: 'parsing',
-            current: total,
-            total,
-        });
-        // Yield so the shimmer worker's buffered stdout writes can flush.
-        // Worker thread stdout is proxied through the main thread's event loop,
-        // so synchronous work here blocks the animation from rendering.
-        await new Promise(resolve => setImmediate(resolve));
-        // Retry pass: files that failed due to WASM memory corruption may succeed
-        // on a fresh worker with a clean heap. Recycle before each attempt so
-        // every file gets the absolute cleanest WASM state possible. Timeouts are
-        // retried too (#1231): most are main-thread-stall artifacts, not slow
-        // parses, and this pass parses one file at a time with the store strictly
-        // after each parse resolves, so the stall window can't recur here.
-        const retryableErrors = errors.filter((e) => e.code === 'parse_error' && e.filePath &&
-            (e.message.includes('Worker exited') ||
-                e.message.includes('memory access out of bounds') ||
-                e.message.includes('timed out')));
-        if (retryableErrors.length > 0 && pool) {
-            log(`Retrying ${retryableErrors.length} files that failed due to WASM memory errors or timeouts...`);
-            // Fresh WASM heaps for the retry phase. A retry that still crashes its
-            // worker makes the pool respawn it, so later retries keep landing on clean
-            // workers too.
-            pool.recycleAll();
-            const stillFailing = [];
-            for (const errEntry of retryableErrors) {
-                const filePath = errEntry.filePath;
-                if (signal?.aborted)
-                    break;
-                let content;
-                try {
-                    const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, filePath);
-                    if (!fullPath)
+                const batch = files.slice(i, i + FILE_IO_BATCH_SIZE);
+                // Read files in parallel (with path validation before any I/O)
+                const fileContents = await Promise.all(batch.map(async (fp) => {
+                    try {
+                        // Indexing read: follow in-root symlinks the directory walk already
+                        // descended into (the `../` guard still applies) so files reached
+                        // via an in-root symlink-to-outside still index (#935).
+                        const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, fp, { allowSymlinkEscape: true });
+                        if (!fullPath) {
+                            (0, errors_1.logWarn)('Path traversal blocked in batch reader', { filePath: fp });
+                            return { filePath: fp, content: null, stats: null, error: new Error('Path traversal blocked') };
+                        }
+                        const content = await readForExtraction(fullPath);
+                        const stats = await fsp.stat(fullPath);
+                        return { filePath: fp, content, stats, error: null };
+                    }
+                    catch (err) {
+                        return { filePath: fp, content: null, stats: null, error: err };
+                    }
+                }));
+                // Dispatch each readable file into the bounded parse window; the window
+                // stores results on the main thread as they arrive.
+                for (const { filePath, content, stats, error } of fileContents) {
+                    if (signal?.aborted) {
+                        aborted = true;
+                        break;
+                    }
+                    if (error || content === null || stats === null) {
+                        processed++;
+                        filesErrored++;
+                        errors.push({
+                            message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+                            filePath,
+                            severity: 'error',
+                            code: 'read_error',
+                        });
+                        onProgress?.({ phase: 'parsing', current: processed, total });
                         continue;
-                    content = await readForExtraction(fullPath);
-                }
-                catch {
-                    continue;
-                }
-                let result;
-                try {
-                    result = await parseFile(filePath, content);
-                }
-                catch {
-                    stillFailing.push(errEntry);
-                    continue;
-                }
-                if (result.nodes.length > 0 || result.errors.length === 0) {
-                    const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
-                    const stats = await fsp.stat(path.join(this.rootDir, filePath));
-                    await this.storeExtractionResult(filePath, content, language, stats, result, commitYield);
-                    const idx = errors.indexOf(errEntry);
-                    if (idx >= 0)
-                        errors.splice(idx, 1);
-                    filesErrored--;
-                    filesIndexed++;
-                    totalNodes += result.nodes.length;
-                    totalEdges += result.edges.length;
-                    log(`Retry OK: ${filePath} (${result.nodes.length} nodes)`);
+                    }
+                    // Honour MAX_FILE_SIZE. Without this check, vendored generated
+                    // headers, minified bundles, and other multi-MB files get indexed,
+                    // wasting WASM heap and the worker recycle budget on inputs with no
+                    // useful symbols. The single-file extractFile path already enforces
+                    // this; the bulk path used to silently skip the check.
+                    if (stats.size > MAX_FILE_SIZE) {
+                        processed++;
+                        filesSkipped++;
+                        errors.push({
+                            message: `File exceeds max size (${stats.size} > ${MAX_FILE_SIZE})`,
+                            filePath,
+                            severity: 'warning',
+                            code: 'size_exceeded',
+                        });
+                        onProgress?.({ phase: 'parsing', current: processed, total });
+                        continue;
+                    }
+                    // Parse on the pool (main thread stays unblocked). Errors/timeouts are
+                    // handled inside feed() → recordParseFailure, feeding the retry pass.
+                    await feed(filePath, content, stats);
                 }
+                if (aborted)
+                    break;
             }
-            // Last resort: for files that still crash on a clean worker, strip
-            // comment-only lines to reduce WASM memory pressure. Many compiler
-            // test files are 90%+ comments (CHECK directives) that don't contribute
-            // code nodes but consume parser memory.
-            if (stillFailing.length > 0) {
-                log(`${stillFailing.length} files still failing — retrying with comments stripped...`);
+            // Drain parses still in flight (skip on abort — we tear down below instead),
+            // then commit any results the cursor hasn't reached yet.
+            if (!aborted) {
+                await Promise.all(inFlight);
+                await flushOrdered();
+                if (flushError)
+                    throw flushError;
+            }
+            if (signal?.aborted || aborted) {
+                return {
+                    success: false,
+                    filesIndexed,
+                    filesSkipped,
+                    filesErrored,
+                    filesDiscovered: total,
+                    nodesCreated: totalNodes,
+                    edgesCreated: totalEdges,
+                    errors: [{ message: 'Aborted', severity: 'error' }, ...errors],
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            // Report 100% so the progress bar doesn't hang at 99%
+            onProgress?.({
+                phase: 'parsing',
+                current: total,
+                total,
+            });
+            // Yield so the shimmer worker's buffered stdout writes can flush.
+            // Worker thread stdout is proxied through the main thread's event loop,
+            // so synchronous work here blocks the animation from rendering.
+            await new Promise(resolve => setImmediate(resolve));
+            // Retry pass: files that failed due to WASM memory corruption may succeed
+            // on a fresh worker with a clean heap. Recycle before each attempt so
+            // every file gets the absolute cleanest WASM state possible. Timeouts are
+            // retried too (#1231): most are main-thread-stall artifacts, not slow
+            // parses, and this pass parses one file at a time with the store strictly
+            // after each parse resolves, so the stall window can't recur here.
+            const retryableErrors = errors.filter((e) => e.code === 'parse_error' && e.filePath &&
+                (e.message.includes('Worker exited') ||
+                    e.message.includes('memory access out of bounds') ||
+                    e.message.includes('timed out')));
+            if (retryableErrors.length > 0 && pool) {
+                log(`Retrying ${retryableErrors.length} files that failed due to WASM memory errors or timeouts...`);
+                // Fresh WASM heaps for the retry phase. A retry that still crashes its
+                // worker makes the pool respawn it, so later retries keep landing on clean
+                // workers too.
                 pool.recycleAll();
-                for (const errEntry of stillFailing) {
+                const stillFailing = [];
+                for (const errEntry of retryableErrors) {
                     const filePath = errEntry.filePath;
                     if (signal?.aborted)
                         break;
-                    let fullContent;
+                    let content;
                     try {
                         const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, filePath);
                         if (!fullPath)
                             continue;
-                        fullContent = await readForExtraction(fullPath);
+                        content = await readForExtraction(fullPath);
                     }
                     catch {
                         continue;
                     }
-                    // Strip lines that are entirely comments (preserving line numbers
-                    // by replacing with empty lines so node positions stay correct)
-                    const stripped = fullContent
-                        .split('\n')
-                        .map(line => /^\s*\/\//.test(line) ? '' : line)
-                        .join('\n');
                     let result;
                     try {
-                        result = await parseFile(filePath, stripped);
+                        result = await parseFile(filePath, content);
                     }
                     catch {
+                        stillFailing.push(errEntry);
                         continue;
                     }
                     if (result.nodes.length > 0 || result.errors.length === 0) {
-                        const language = (0, grammars_1.detectLanguage)(filePath, fullContent, overrides);
+                        const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
                         const stats = await fsp.stat(path.join(this.rootDir, filePath));
-                        await this.storeExtractionResult(filePath, fullContent, language, stats, result, commitYield);
+                        await this.storeExtractionResult(filePath, content, language, stats, result, commitYield);
                         const idx = errors.indexOf(errEntry);
                         if (idx >= 0)
                             errors.splice(idx, 1);
@@ -1956,25 +1921,75 @@ class ExtractionOrchestrator {
                         filesIndexed++;
                         totalNodes += result.nodes.length;
                         totalEdges += result.edges.length;
-                        log(`Retry (stripped) OK: ${filePath} (${result.nodes.length} nodes)`);
+                        log(`Retry OK: ${filePath} (${result.nodes.length} nodes)`);
+                    }
+                }
+                // Last resort: for files that still crash on a clean worker, strip
+                // comment-only lines to reduce WASM memory pressure. Many compiler
+                // test files are 90%+ comments (CHECK directives) that don't contribute
+                // code nodes but consume parser memory.
+                if (stillFailing.length > 0) {
+                    log(`${stillFailing.length} files still failing — retrying with comments stripped...`);
+                    pool.recycleAll();
+                    for (const errEntry of stillFailing) {
+                        const filePath = errEntry.filePath;
+                        if (signal?.aborted)
+                            break;
+                        let fullContent;
+                        try {
+                            const fullPath = (0, utils_1.validatePathWithinRoot)(this.rootDir, filePath);
+                            if (!fullPath)
+                                continue;
+                            fullContent = await readForExtraction(fullPath);
+                        }
+                        catch {
+                            continue;
+                        }
+                        // Strip lines that are entirely comments (preserving line numbers
+                        // by replacing with empty lines so node positions stay correct)
+                        const stripped = fullContent
+                            .split('\n')
+                            .map(line => /^\s*\/\//.test(line) ? '' : line)
+                            .join('\n');
+                        let result;
+                        try {
+                            result = await parseFile(filePath, stripped);
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (result.nodes.length > 0 || result.errors.length === 0) {
+                            const language = (0, grammars_1.detectLanguage)(filePath, fullContent, overrides);
+                            const stats = await fsp.stat(path.join(this.rootDir, filePath));
+                            await this.storeExtractionResult(filePath, fullContent, language, stats, result, commitYield);
+                            const idx = errors.indexOf(errEntry);
+                            if (idx >= 0)
+                                errors.splice(idx, 1);
+                            filesErrored--;
+                            filesIndexed++;
+                            totalNodes += result.nodes.length;
+                            totalEdges += result.edges.length;
+                            log(`Retry (stripped) OK: ${filePath} (${result.nodes.length} nodes)`);
+                        }
                     }
                 }
             }
+            return {
+                success: filesIndexed > 0 || errors.filter((e) => e.severity === 'error').length === 0,
+                filesIndexed,
+                filesSkipped,
+                filesErrored,
+                filesDiscovered: total,
+                nodesCreated: totalNodes,
+                edgesCreated: totalEdges,
+                errors,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        finally {
+            if (pool)
+                await pool.destroy();
         }
-        // Shut down the parse worker pool.
-        if (pool)
-            await pool.destroy();
-        return {
-            success: filesIndexed > 0 || errors.filter((e) => e.severity === 'error').length === 0,
-            filesIndexed,
-            filesSkipped,
-            filesErrored,
-            filesDiscovered: total,
-            nodesCreated: totalNodes,
-            edgesCreated: totalEdges,
-            errors,
-            durationMs: Date.now() - startTime,
-        };
     }
     /**
      * Index specific files
@@ -2116,7 +2131,12 @@ class ExtractionOrchestrator {
         // Issue #154: also thread the `vba.dysflowExport` flag so the
         // single-file re-index path honours the same opt-out the full scan does.
         const dysflowExport = (0, project_config_1.loadDysflowExportConfig)(this.rootDir);
-        const result = (0, tree_sitter_1.extractFromSource)(relativePath, content, language, frameworkNames, vbaReindexConfig.targets, vbaReindexConfig.maxRaiseFanout, dysflowExport);
+        const result = (0, tree_sitter_1.extractFromSource)(relativePath, content, language, frameworkNames, undefined, undefined, dysflowExport, {
+            targets: vbaReindexConfig.targets,
+            maxRaiseFanout: vbaReindexConfig.maxRaiseFanout,
+            sqlWrappers: vbaReindexConfig.sqlWrappers,
+            errorChannel: vbaReindexConfig.errorChannel,
+        });
         // Store in database
         if (result.nodes.length > 0 || result.errors.length === 0) {
             await this.storeExtractionResult(relativePath, content, language, stats, result, (0, cooperative_yield_1.createYielder)());