@0xcraft/powershot 1.1.0 → 1.1.2

package/dist/ground.js

@@ -1,33 +1,174 @@
 import { Project, SyntaxKind } from 'ts-morph';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { decode } from './text.js';
-import { join, dirname } from 'node:path';
-import { packFor, parse } from './lang/packs.js';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { PACKS, packFor, parseIsolated } from './lang/packs.js';
 import { insideRepo, isSymlink, repoPath } from './fspolicy.js';
 const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const TS_CONFIG = /^tsconfig(?:\..+)?\.json$/i;
+const MISSING_TYPE_PREFIXES = [
+    'Cannot find global type',
+    'Cannot find global value',
+    'Cannot find module',
+    'Cannot find name',
+    'Cannot find type definition file',
+    'Could not find a declaration file for module',
+];
+/**
+ * A property diagnostic is only exact when the file's ambient types resolved.
+ * Missing modules, globals, or declaration files can remove interface
+ * augmentations and manufacture downstream errors such as `ImportMeta.url`.
+ */
+function hasTypeEnvironmentGap(sf) {
+    return sf.getPreEmitDiagnostics().some((diagnostic) => {
+        const message = diagnostic.getMessageText();
+        const head = typeof message === 'string' ? message : message.getMessageText();
+        return MISSING_TYPE_PREFIXES.some((prefix) => head.startsWith(prefix)) || /^File .+ not found/.test(head);
+    });
+}
 export function normalizeName(n) {
     return n.toLowerCase().replace(/[^a-z0-9]/g, '');
 }
-/**
- * Walks up, but never past `stop`.
- *
- * A tsconfig above the repository is somebody else's, and letting one configure the
- * program that reviews this repository lets a parent directory decide what is
- * type-checked and where paths resolve to.
- */
-function findUp(from, name, stop = from) {
-    let dir = from;
-    for (;;) {
-        const p = join(dir, name);
-        if (existsSync(p))
-            return p;
-        if (dir === stop)
-            return undefined;
+/** A lexical repository containment check for paths that have already been resolved. */
+function isWithin(root, path) {
+    const rel = relative(root, path);
+    return rel === '' || (rel !== '..' && !rel.startsWith('..' + sep) && !isAbsolute(rel));
+}
+/** Directories from a changed file up to the repository root, nearest first. */
+function ancestorDirectories(root, absPath) {
+    const out = [];
+    let dir = dirname(absPath);
+    while (isWithin(root, dir)) {
+        out.push(dir);
+        if (dir === root)
+            break;
         const parent = dirname(dir);
         if (parent === dir)
-            return undefined;
+            break;
         dir = parent;
     }
+    return out;
+}
+/** Only inspect the directory chain of changed files; never crawl the monorepo. */
+function configsInDirectory(dir, cache) {
+    const known = cache.get(dir);
+    if (known)
+        return known;
+    let configs = [];
+    try {
+        configs = readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && TS_CONFIG.test(entry.name))
+            .map((entry) => join(dir, entry.name))
+            .sort();
+    }
+    catch {
+        // An unreadable ancestor contributes no project; the file remains syntax-only.
+    }
+    cache.set(dir, configs);
+    return configs;
+}
+function configuredProject(root, configPath) {
+    try {
+        const project = new Project({ tsConfigFilePath: configPath });
+        const owned = new Set();
+        const sourceAncestors = new Set();
+        for (const sf of project.getSourceFiles()) {
+            const abs = resolve(sf.getFilePath());
+            const safe = insideRepo(root, abs);
+            if (!safe || repoPath(root, abs).split('/').includes('node_modules'))
+                continue;
+            owned.add(repoPath(root, abs));
+            let dir = dirname(abs);
+            while (isWithin(root, dir)) {
+                sourceAncestors.add(dir);
+                if (dir === root)
+                    break;
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break;
+                dir = parent;
+            }
+        }
+        return { configPath, project, owned, sourceAncestors, sourceCount: owned.size };
+    }
+    catch {
+        // A broken candidate beside a usable leaf config must not take down the review.
+        return undefined;
+    }
+}
+function directoryDepth(root, dir) {
+    const rel = repoPath(root, dir);
+    return rel === '' ? 0 : rel.split('/').length;
+}
+function sourceAffinity(root, candidate, absPath) {
+    let dir = dirname(absPath);
+    while (isWithin(root, dir)) {
+        if (candidate.sourceAncestors.has(dir))
+            return directoryDepth(root, dir);
+        if (dir === root)
+            break;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return -1;
+}
+function nameAffinity(root, configPath, absPath) {
+    const base = basename(configPath);
+    const name = base.slice('tsconfig'.length, -'.json'.length).replace(/^\./, '');
+    if (name === '')
+        return 0;
+    const tokens = new Set(repoPath(root, absPath).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+    return name
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean)
+        .filter((token) => tokens.has(token)).length;
+}
+/** Prefer the leaf project whose existing sources live closest to this file. */
+function bestProject(root, candidates, absPath) {
+    return [...candidates].sort((a, b) => sourceAffinity(root, b, absPath) - sourceAffinity(root, a, absPath) ||
+        nameAffinity(root, b.configPath, absPath) - nameAffinity(root, a.configPath, absPath) ||
+        a.sourceCount - b.sourceCount ||
+        a.configPath.localeCompare(b.configPath))[0];
+}
+function looksLikeTest(path) {
+    return /(?:^|[/\\])(?:__tests__|tests?)(?:[/\\]|$)/i.test(path) || /\.(?:test|spec)\.[^.]+$/i.test(path);
+}
+/**
+ * Resolve one changed file at the nearest useful project boundary.
+ *
+ * Solution configs (`files: []`) do not claim a type environment. If a sibling leaf
+ * config owns the file it wins; if every leaf excludes the file (common for tests),
+ * the closest suitable non-empty leaf supplies compiler options and references.
+ * Selecting that local leaf avoids opening a repository-wide parent.
+ */
+function projectForFile(root, absPath, directoryCache, projectCache) {
+    const rel = repoPath(root, absPath);
+    for (const dir of ancestorDirectories(root, absPath)) {
+        const configPaths = [...configsInDirectory(dir, directoryCache)].sort((a, b) => nameAffinity(root, b, absPath) - nameAffinity(root, a, absPath) || a.localeCompare(b));
+        const projects = [];
+        for (const configPath of configPaths) {
+            if (!projectCache.has(configPath)) {
+                projectCache.set(configPath, configuredProject(root, configPath));
+            }
+            const project = projectCache.get(configPath);
+            if (!project)
+                continue;
+            // Config names such as `test`, `app`, and `node` are ranked against the file
+            // path, so the first owner is the most specific without opening every sibling.
+            if (project.owned.has(rel))
+                return project;
+            projects.push(project);
+        }
+        const boundaryDepth = directoryDepth(root, dir);
+        const leaves = projects.filter((project) => project.sourceCount > 0 &&
+            (sourceAffinity(root, project, absPath) > boundaryDepth || looksLikeTest(absPath)));
+        if (leaves.length > 0)
+            return bestProject(root, leaves, absPath);
+    }
+    return undefined;
 }
 function depsIn(pkgPath) {
     const deps = new Set();
@@ -70,36 +211,45 @@ function makeDepsFor(root) {
     };
 }
 /**
- * Build the oracle once per run: a type-checked project over the working tree,
- * a syntax-only project holding the base-ref versions, and a symbol index.
+ * Build the oracle once per run: focused type-checked projects for the changed
+ * packages, a syntax-only project for unconfigured changes and the base-ref trees,
+ * and one deduplicated symbol index over the relevant project closures.
  */
 export async function buildGround(root, changed, signal) {
-    const tsConfigFilePath = findUp(root, 'tsconfig.json');
-    const typed = Boolean(tsConfigFilePath);
-    const project = typed
-        ? new Project({ tsConfigFilePath })
-        : new Project({ compilerOptions: { allowJs: true, checkJs: false } });
-    if (!typed)
-        project.addSourceFilesAtPaths([`${root}/**/*.{ts,tsx,js,jsx,mts,cts}`, `!${root}/**/node_modules/**`]);
-    // What the tsconfig itself owns. A file added past this point is present for
-    // reading, but the checker has no program for it — asking one for diagnostics
-    // throws from inside TypeScript, which took the whole review down with it.
-    const owned = new Set(project.getSourceFiles().map((f) => repoPath(root, String(f.getFilePath()))));
-    // A changed file may be new, or excluded from tsconfig — make sure it is present.
-    // `readable` is the gate for every file that becomes reviewable: the glob above
-    // follows symlinks, so passing this on the way in is not enough on its own.
+    root = resolve(root);
+    const directoryCache = new Map();
+    const projectCache = new Map();
+    const selectedProjects = new Set();
+    const assigned = new Map();
+    const syntaxProject = new Project({ compilerOptions: { allowJs: true, checkJs: false } });
+    // `readable` is the gate for every file that becomes reviewable. A tsconfig glob
+    // can follow symlinks, so selected project closures are checked again below too.
     const readable = (path) => {
         const abs = insideRepo(root, path);
         return abs && !isSymlink(abs) ? abs : undefined;
     };
     for (const c of changed) {
+        if (signal?.aborted)
+            break;
         if (!CODE_EXT.test(c.path))
             continue;
         const abs = readable(c.path);
-        if (!abs)
+        if (!abs || !existsSync(abs))
             continue;
-        if (!project.getSourceFile(abs) && existsSync(abs))
-            project.addSourceFileAtPath(abs);
+        const configured = projectForFile(root, abs, directoryCache, projectCache);
+        if (configured) {
+            selectedProjects.add(configured);
+            assigned.set(c.path, configured);
+            // Tests and tooling files are often excluded from the production build config.
+            // Adding one explicitly keeps the leaf project's compiler options and imports.
+            if (!configured.project.getSourceFile(abs))
+                configured.project.addSourceFileAtPath(abs);
+        }
+        else if (!syntaxProject.getSourceFile(abs)) {
+            // No recursive glob: a configless million-file repository still loads only the
+            // files in the review.
+            syntaxProject.addSourceFileAtPath(abs);
+        }
     }
     const beforeProject = new Project({ useInMemoryFileSystem: true });
     const files = [];
@@ -109,79 +259,78 @@ export async function buildGround(root, changed, signal) {
         const abs = readable(c.path);
         if (!abs)
             continue;
-        const sf = project.getSourceFile(abs);
+        const configured = assigned.get(c.path);
+        const sf = configured?.project.getSourceFile(abs) ?? syntaxProject.getSourceFile(abs);
         if (!sf)
             continue;
         const before = c.before === undefined ? undefined : beforeProject.createSourceFile(`/before/${c.path}`, c.before, { overwrite: true });
-        files.push({ sf, changed: c, before, typed: typed && owned.has(repoPath(root, c.path)) });
+        files.push({
+            sf,
+            changed: c,
+            before,
+            // A bound program with unresolved ambient types is not an exact type oracle.
+            // Keep the file reviewable, but make type-dependent checks explicitly partial.
+            typed: configured !== undefined && !hasTypeEnvironmentGap(sf),
+        });
     }
+    const projects = [...selectedProjects].map((selected) => selected.project);
+    if (syntaxProject.getSourceFiles().length > 0)
+        projects.push(syntaxProject);
+    const sourceFiles = uniqueSourceFiles(root, files.map((file) => file.sf), projects);
+    const configFiles = [...selectedProjects]
+        .map((selected) => repoPath(root, selected.configPath))
+        .sort();
+    const typed = files.some((file) => file.typed);
+    const depsFor = makeDepsFor(root);
     return {
         root,
-        project,
+        sourceFiles,
+        configFiles,
         beforeProject,
         changed,
         files,
-        symbolIndex: buildSymbolIndex(project, root),
-        deps: makeDepsFor(root)(join(root, 'x.ts')),
-        depsFor: makeDepsFor(root),
+        symbolIndex: buildSymbolIndex(sourceFiles, root),
+        deps: depsFor(join(root, 'x.ts')),
+        depsFor,
         typed,
-        internalPrefixes: pathAliasPrefixes(project, root),
+        internalPrefixes: pathAliasPrefixes(projects),
         foreign: await parseForeign(root, changed, signal),
         envManifest: readEnvManifest(root),
     };
 }
+/** Prefer changed-file SourceFiles, then add each relevant project source once. */
+function uniqueSourceFiles(root, preferred, projects) {
+    const byPath = new Map();
+    const add = (sf) => {
+        const abs = resolve(sf.getFilePath());
+        if (!insideRepo(root, abs))
+            return;
+        const rel = repoPath(root, abs);
+        if (rel.split('/').includes('node_modules') || byPath.has(rel))
+            return;
+        byPath.set(rel, sf);
+    };
+    for (const sf of preferred)
+        add(sf);
+    for (const project of projects)
+        for (const sf of project.getSourceFiles())
+            add(sf);
+    return [...byPath.values()];
+}
 /**
  * Prefixes that `compilerOptions.paths` maps back into the repo — `@/*` and friends.
  * They look like package names but resolve to local files, so treating them as
  * dependencies would be wrong.
  */
-function pathAliasPrefixes(project, root) {
+function pathAliasPrefixes(projects) {
     const prefixes = new Set();
-    for (const pattern of Object.keys(project.getCompilerOptions().paths ?? {})) {
-        prefixes.add(pattern.replace(/\*$/, ''));
-    }
-    // a workspace declares its aliases in each package's tsconfig, and the root config
-    // often only `extends` a shared base — so the root's paths are not the whole story
-    for (const file of tsconfigsIn(root)) {
-        try {
-            const raw = readFileSync(file, 'utf8').replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|\s)\/\/.*$/gm, '$1');
-            const parsed = JSON.parse(raw.replace(/,(\s*[}\]])/g, '$1'));
-            for (const pattern of Object.keys(parsed?.compilerOptions?.paths ?? {})) {
-                prefixes.add(String(pattern).replace(/\*$/, ''));
-            }
-        }
-        catch {
-            // an unreadable or non-standard tsconfig simply contributes no aliases
+    for (const project of projects) {
+        for (const pattern of Object.keys(project.getCompilerOptions().paths ?? {})) {
+            prefixes.add(pattern.replace(/\*$/, ''));
         }
     }
     return [...prefixes];
 }
-/** every tsconfig in the repo, capped so a huge monorepo cannot stall the run */
-function tsconfigsIn(root) {
-    const out = [];
-    const walk = (dir, depth) => {
-        if (depth > 4 || out.length > 60)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const e of entries) {
-            if (e.name === 'node_modules' || e.name.startsWith('.'))
-                continue;
-            const full = join(dir, e.name);
-            if (e.isDirectory())
-                walk(full, depth + 1);
-            else if (e.name === 'tsconfig.json')
-                out.push(full);
-        }
-    };
-    walk(root, 0);
-    return out;
-}
 /**
  * Changed files the TypeScript project cannot hold. Nine of the checks need only a
  * parse tree, so a Python or Go file is reviewable the moment its grammar loads —
@@ -211,7 +360,7 @@ export function readEnvManifest(root) {
     return undefined;
 }
 async function parseForeign(root, changed, signal) {
-    const out = [];
+    const byLanguage = new Map();
     for (const c of changed) {
         // parsing thousands of files is where a large scan spends its time, so a signal
         // has to be honoured here rather than only once the checks begin
@@ -227,17 +376,70 @@ async function parseForeign(root, changed, signal) {
         // costs seconds to produce findings nobody acts on
         if ((statSync(abs, { throwIfNoEntry: false })?.size ?? 0) > 512 * 1024)
             continue;
-        const tree = await parse(pack, decode(readFileSync(abs)));
-        if (!tree)
-            continue;
-        const beforeTree = c.before === undefined ? undefined : await parse(pack, c.before);
-        out.push({ path: c.path, pack, tree, beforeTree, changed: c });
+        const list = byLanguage.get(pack.name) ?? [];
+        list.push({
+            changed: c,
+            source: decode(readFileSync(abs)),
+            // A generated base can be arbitrarily larger than the reviewed result. Do not
+            // smuggle it past the current-file limit through the before/after channel.
+            beforeSource: c.before !== undefined && Buffer.byteLength(c.before) <= 512 * 1024
+                ? c.before
+                : undefined,
+        });
+        byLanguage.set(pack.name, list);
     }
-    return out;
+    const parsed = new Map();
+    // A worker holds one grammar and a bounded source batch. This keeps both WASM
+    // compilation and structured-clone payloads independent of monorepo size.
+    const MAX_BATCH_BYTES = 8 * 1024 * 1024;
+    const MAX_BATCH_FILES = 128;
+    for (const pack of PACKS) {
+        const candidates = byLanguage.get(pack.name) ?? [];
+        for (let start = 0; start < candidates.length;) {
+            let end = start;
+            let bytes = 0;
+            while (end < candidates.length && end - start < MAX_BATCH_FILES) {
+                const candidate = candidates[end];
+                const next = Buffer.byteLength(candidate.source) + Buffer.byteLength(candidate.beforeSource ?? '');
+                if (end > start && bytes + next > MAX_BATCH_BYTES)
+                    break;
+                bytes += next;
+                end++;
+            }
+            const batch = candidates.slice(start, end);
+            const sources = batch.flatMap((candidate) => candidate.beforeSource === undefined
+                ? [candidate.source]
+                : [candidate.source, candidate.beforeSource]);
+            const trees = await parseIsolated(pack, sources, signal);
+            let index = 0;
+            for (const candidate of batch) {
+                const tree = trees[index++];
+                const beforeTree = candidate.beforeSource === undefined ? undefined : trees[index++];
+                if (!tree)
+                    continue;
+                parsed.set(candidate.changed.path, {
+                    path: candidate.changed.path,
+                    pack,
+                    tree,
+                    beforeTree,
+                    changed: candidate.changed,
+                });
+            }
+            start = end;
+            if (signal?.aborted)
+                break;
+        }
+        if (signal?.aborted)
+            break;
+    }
+    return changed.flatMap((file) => {
+        const result = parsed.get(file.path);
+        return result ? [result] : [];
+    });
 }
-function buildSymbolIndex(project, root) {
+function buildSymbolIndex(sourceFiles, root) {
     const index = new Map();
-    for (const sf of project.getSourceFiles()) {
+    for (const sf of sourceFiles) {
         const path = String(sf.getFilePath());
         // the project glob follows symlinked directories, so what it loaded is not
         // proof of where the file is

package/dist/judges/tools.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { relPath } from '#app/ground.js';
-import { insideRepo } from '#app/fspolicy.js';
+import { insideRepo, repoPath } from '#app/fspolicy.js';
 const MAX_BYTES = 60_000;
 const MAX_MATCHES = 40;
 export const TOOLS = [
@@ -58,7 +58,7 @@ function readFile(g, input) {
     const abs = insideRepo(g.root, path);
     if (!abs)
         return 'Refused: that path is outside the repository or is not readable for review.';
-    const inProject = g.project.getSourceFile(abs);
+    const inProject = g.sourceFiles.find((file) => relPath(file, g.root) === repoPath(g.root, abs));
     const text = inProject ? inProject.getFullText() : readFileSync(abs, 'utf8');
     const lines = text.split('\n');
     const start = Math.max(1, Number(input.start ?? 1));
@@ -79,7 +79,7 @@ function grep(g, input) {
     }
     const filter = input.path_contains === undefined ? undefined : String(input.path_contains);
     const hits = [];
-    for (const sf of g.project.getSourceFiles()) {
+    for (const sf of g.sourceFiles) {
         const abs = sf.getFilePath();
         // the project glob can pull in a file through a symlinked directory, so the
         // boundary is re-checked here rather than trusted from how the file got loaded
@@ -98,13 +98,13 @@ function grep(g, input) {
                 return hits.join('\n') + '\n… more matches not shown';
         }
     }
-    return hits.length > 0 ? hits.join('\n') : 'No matches.';
+    return hits.length > 0 ? hits.join('\n') : 'No matches in the relevant project files.';
 }
 function references(g, input) {
     const symbol = String(input.symbol ?? '');
     if (!symbol)
         return 'No symbol given.';
-    for (const sf of g.project.getSourceFiles()) {
+    for (const sf of g.sourceFiles) {
         const path = String(sf.getFilePath());
         if (path.includes('/node_modules/') || !insideRepo(g.root, path))
             continue;
@@ -117,9 +117,9 @@ function references(g, input) {
             .map((n) => relPath(n.getSourceFile(), g.root) + ':' + n.getStartLineNumber())
             .filter((r) => !r.includes('node_modules'));
         return refs.length === 0
-            ? symbol + ' is declared in ' + relPath(sf, g.root) + ' and referenced nowhere.'
+            ? symbol + ' is declared in ' + relPath(sf, g.root) + ' and referenced nowhere in its project.'
             : symbol + ' declared in ' + relPath(sf, g.root) + ', referenced at:\n' + [...new Set(refs)].slice(0, MAX_MATCHES).join('\n');
     }
-    return 'No declaration named ' + symbol + ' found in the project.';
+    return 'No declaration named ' + symbol + ' found in the relevant projects.';
 }
 //# sourceMappingURL=tools.js.map

package/dist/lang/packs.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
+import { Worker } from 'node:worker_threads';
 /** Shared defaults; a pack overrides only what its grammar spells differently. */
 const COMMON_NODES = {
     identifier: ['identifier'],
@@ -498,15 +499,6 @@ export function packFor(path) {
 }
 let ready;
 const parsers = new Map();
-/**
- * Measured, not guessed, and the measurement is worth writing down because the naive
- * one is misleading. Loading grammars is cheap — all eleven load for ~143MB. Parsing
- * with them is not: V8 tiers up each wasm module in the background, and RSS climbed
- * 63 → 690MB across eleven before the process died inside that compilation. Six
- * grammars sat at ~131MB and were comfortable.
- */
-const MAX_GRAMMARS = 6;
-export const skippedLanguages = [];
 /**
  * Grammars load lazily and once. A repository with no Python pays nothing for
  * Python, and the wasm runtime is only initialised when a foreign file appears.
@@ -515,11 +507,6 @@ async function parserFor(pack) {
     const cached = parsers.get(pack.name);
     if (cached)
         return cached;
-    if (parsers.size >= MAX_GRAMMARS) {
-        if (!skippedLanguages.includes(pack.name))
-            skippedLanguages.push(pack.name);
-        return undefined;
-    }
     try {
         if (!ready) {
             ready = (async () => {
@@ -554,4 +541,100 @@ export async function parse(pack, source) {
         return undefined;
     }
 }
+/** Turn a native WASM-backed tree into data that can cross a worker boundary. */
+export function serializeTree(tree) {
+    const copy = (raw, field) => {
+        const node = raw;
+        const children = [];
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                children.push(copy(child, node.fieldNameForChild(i) ?? undefined));
+        }
+        return {
+            type: node.type,
+            startIndex: node.startIndex,
+            endIndex: node.endIndex,
+            startPosition: { ...node.startPosition },
+            endPosition: { ...node.endPosition },
+            named: node.isNamed,
+            field,
+            children,
+        };
+    };
+    return { root: copy(tree.rootNode) };
+}
+/** Restore the small Node interface the language-independent verifiers consume. */
+function hydrateTree(source, tree) {
+    const hydrate = (data) => {
+        const children = data.children.map(hydrate);
+        return {
+            type: data.type,
+            get text() { return source.slice(data.startIndex, data.endIndex); },
+            startPosition: { ...data.startPosition },
+            endPosition: { ...data.endPosition },
+            childCount: children.length,
+            child: (index) => children[index] ?? null,
+            namedChildren: children.filter((_, index) => data.children[index]?.named),
+            childForFieldName: (name) => {
+                const index = data.children.findIndex((child) => child.field === name);
+                return index < 0 ? null : (children[index] ?? null);
+            },
+        };
+    };
+    return { rootNode: hydrate(tree.root) };
+}
+/**
+ * Parse one language in a disposable worker.
+ *
+ * V8 keeps compiled WASM grammars alive longer than their JS parsers. Eleven
+ * grammars in one process reached ~690MB and killed real mixed-language runs.
+ * One worker owns one grammar, returns plain trees, and is then terminated, so
+ * compiled-grammar memory is bounded by one language rather than by the monorepo's
+ * language count. Plain trees still scale with the selected diff.
+ */
+export function parseIsolated(pack, sources, signal) {
+    if (sources.length === 0)
+        return Promise.resolve([]);
+    if (signal?.aborted)
+        return Promise.resolve(sources.map(() => undefined));
+    return new Promise((resolve) => {
+        let worker;
+        let settled = false;
+        const empty = () => sources.map(() => undefined);
+        const finish = (trees) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', abort);
+            // Resolve only after V8 has released this worker's WASM grammar. Otherwise a
+            // fast next batch can overlap termination and recreate the memory spike this
+            // isolation boundary exists to prevent.
+            void worker.terminate().then(() => resolve(trees), () => resolve(trees));
+        };
+        const abort = () => finish(empty());
+        try {
+            worker = new Worker(new URL('./parse-worker.js', import.meta.url), {
+                workerData: { language: pack.name, sources },
+            });
+        }
+        catch {
+            resolve(empty());
+            return;
+        }
+        signal?.addEventListener('abort', abort, { once: true });
+        worker.once('message', (raw) => {
+            if (!Array.isArray(raw) || raw.length !== sources.length) {
+                finish(empty());
+                return;
+            }
+            finish(raw.map((tree, index) => tree ? hydrateTree(sources[index], tree) : undefined));
+        });
+        worker.once('error', () => finish(empty()));
+        worker.once('exit', () => finish(empty()));
+        // Close the narrow race between the early check and listener registration.
+        if (signal?.aborted)
+            abort();
+    });
+}
 //# sourceMappingURL=packs.js.map

package/dist/lang/parse-worker.js

@@ -0,0 +1,15 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { PACKS, parse, serializeTree } from './packs.js';
+async function run(input) {
+    const pack = PACKS.find((candidate) => candidate.name === input.language);
+    if (!pack || !Array.isArray(input.sources))
+        return [];
+    const trees = [];
+    for (const source of input.sources) {
+        const tree = await parse(pack, source);
+        trees.push(tree ? serializeTree(tree) : undefined);
+    }
+    return trees;
+}
+void run(workerData).then((trees) => parentPort?.postMessage(trees), () => parentPort?.postMessage([]));
+//# sourceMappingURL=parse-worker.js.map