github-router 0.3.71 → 0.3.73

package/README.md

@@ -79,27 +79,28 @@ Then run `claude` as normal.
 
 `github-router claude` auto-wires four peer-model adversarial reviewers plus a coordinator into the spawned Claude Code session. No setup, no prior MCP config, no `.claude/agents/` files needed — they appear as Task `subagent_type` options the session can delegate to. Opt out with `--no-codex-mcp`.
 
-Each persona is exposed both as a Claude Code subagent (callable via the `Task` tool) AND as an MCP tool at `mcp__gh-router-peers__<name>`. Personas are stateless: each invocation runs a fresh request against its model with a baked persona prompt — they have no access to your scrollback or project memory, so the lead must paste the artifact into the brief.
+Each persona is exposed both as a Claude Code subagent (callable via the `Task` tool) AND as an MCP tool at `mcp__peers__<name>`. Personas are stateless: each invocation runs a fresh request against its model with a baked persona prompt — they have no access to your scrollback or project memory, so the lead must paste the artifact into the brief.
 
 | Subagent | Model | Endpoint | Effort tiers (default) |
 |---|---|---|---|
 | `codex-critic` | gpt-5.5 | `/v1/responses` | low \| medium \| high \| xhigh (xhigh) |
 | `codex-reviewer` | gpt-5.3-codex | `/v1/responses` | low \| medium \| high \| xhigh (xhigh) |
+| `gemini-reviewer` | gemini-3.1-pro-preview | `/v1/chat/completions` | low \| medium \| high (high) |
 | `opus-critic` | claude-opus-4-6 | `/v1/messages` | low \| medium \| high (high) |
 | `gemini-critic` | gemini-3.1-pro-preview | `/v1/chat/completions` | low \| medium \| high (high) |
 | `peer-review-coordinator` | (meta) | — | — |
 
-`peer-review-coordinator` is a subagent (not an MCP tool) that fans out to the right combination of the four critics in parallel based on artifact type — plan, diff, single file, or long-context — and aggregates findings.
+`peer-review-coordinator` is a subagent (not an MCP tool) that fans out to the right combination of the critics in parallel based on artifact type — plan, diff, single file, or long-context — and aggregates findings.
 
-**Effort tiers** are exposed via the MCP tool's `effort` argument; subagents pass it through. All four tiers are accepted on every persona. `xhigh` routinely runs 60–90s; the proxy responds to `tools/call` requests with SSE-streamed responses (per MCP 2025-06-18 Streamable HTTP transport spec) so the connection stays open past the standard ~60s MCP per-tool-call ceiling and long calls complete transparently with no user setup.
+**Effort tiers** are exposed via the MCP tool's `effort` argument; subagents pass it through. `xhigh` routinely runs 60–90s; the proxy responds to `tools/call` requests with SSE-streamed responses (per MCP 2025-06-18 Streamable HTTP transport spec) so the connection stays open past the standard ~60s MCP per-tool-call ceiling and long calls complete transparently with no user setup.
 
-`gemini-critic` only registers when `gemini-3.1-pro-preview` is present in your Copilot model catalog. If absent, the persona is silently dropped from both the MCP `tools/list` and the subagent set, and `peer-review-coordinator` skips it in routing decisions.
+`gemini-critic` and `gemini-reviewer` both register only when `gemini-3.1-pro-preview` (or another `gemini-3.x-pro` model) is present in your Copilot model catalog — `gemini-critic` is the architecture-level critic, `gemini-reviewer` the line-level second-lab code reviewer on the same model at its highest reasoning tier. If absent, both personas are silently dropped from the MCP `tools/list` and the subagent set, and `peer-review-coordinator` skips them in routing decisions.
 
 For codex-side write capability (a `codex-implementer` persona that can mutate files via Codex's tool-use sandbox), pass `--codex-cli`. Requires `codex` CLI 0.129+ on `PATH`; falls back to HTTP-only with a warning if codex is missing or older. Pass `--codex-mcp-only` to also pass `--strict-mcp-config` to Claude Code so only the proxy's MCP servers are loaded (hides any MCP servers in your existing `~/.claude/mcp.json`).
 
-### Code search (`mcp__gh-router-peers__code_search`)
+### Code search (`mcp__search__code`)
 
-Alongside the peer reviewers, the same MCP surface exposes a `code_search` tool — fast structured code search over the workspace, ranked by **BM25F** (Robertson, Zaragoza, Taylor 2004) over four code-aware fields: matched line, surrounding context, file path tokens, and a symbol-definition heuristic. On top of that, the top hits get a tree-sitter pass that promotes true identifier-definition sites over incidental string matches; depth is controlled by the optional `structural` argument (`"full"` parses the top 50 hits, `"topN"` parses the top 10 for tighter latency on big repos). A single `notice` field surfaces in the response on the rare occasions an actionable degradation fires — the structural pass overran its 200ms wall-clock budget, or the response hit the 256KB size cap and was truncated; the message text tells the model what to retry. Defaults to a "ranked" mode with shoulder pruning so models get the few right answers, not a flood of substring matches. `literal` and `regex` modes are also available for exact searches; single-identifier queries in `ranked`/`literal` mode auto-expand across camelCase / snake_case / kebab-case skeletons so `getUserName` also matches `get_user_name`.
+Alongside the peer reviewers, the same MCP surface exposes a `code` tool (under the `search` server — `mcp__search__code`) — fast structured code search over the workspace, ranked by **BM25F** (Robertson, Zaragoza, Taylor 2004) over four code-aware fields: matched line, surrounding context, file path tokens, and a symbol-definition heuristic. On top of that, the top hits get a tree-sitter pass that promotes true identifier-definition sites over incidental string matches; depth is controlled by the optional `structural` argument (`"full"` parses the top 50 hits, `"topN"` parses the top 10 for tighter latency on big repos). A single `notice` field surfaces in the response on the rare occasions an actionable degradation fires — the structural pass overran its 200ms wall-clock budget, or the response hit the 256KB size cap and was truncated; the message text tells the model what to retry. Defaults to a "ranked" mode with shoulder pruning so models get the few right answers, not a flood of substring matches. `literal` and `regex` modes are also available for exact searches; single-identifier queries in `ranked`/`literal` mode auto-expand across camelCase / snake_case / kebab-case skeletons so `getUserName` also matches `get_user_name`.
 
 `workspace` is any absolute path the proxy process can read — typically the project root or a sub-tree you're working in. The model picks it. There's no allow-set or secret-shape file denylist: the threat model is symmetric since Claude Code already has Read / Bash / Edit tools that reach the same paths, so gating one tool would have been inconsistency rather than defense. Paths in results are returned relative to the workspace, never absolute.
 

package/dist/browser-ext/background.js

@@ -859,7 +859,7 @@ function clampNum(v, min, max) {
 // attachment, so two parallel browser_mouse / browser_drag / browser_type
 // calls on the same tab would interleave and corrupt each other (one
 // call's mouseMoved would land mid-drag of another). The global
-// MAX_INFLIGHT_TOOLS_CALL=8 cap doesn't help — it's global, not per-tab.
+// MAX_INFLIGHT_TOOLS_CALL=32 cap doesn't help — it's global, not per-tab.
 // This mutex is per-tab, layered on top.
 const tabInputLockTails = new Map() // tabId → Promise (tail of the lock chain)
 

package/dist/browser-ext/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "github-router browser bridge",
   "short_name": "gh-router-browser",
-  "version": "0.3.71",
+  "version": "0.3.73",
   "description": "Bridge between Claude (via github-router /mcp) and the browser. Implements tab control, navigation, clicks, form fill, downloads, screenshots, devtools eval. Blocks navigation to chrome://settings.",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqJElxuBlonBS3TVW9FJN0mGTtShB3L1hoaYf6k39SOr1ogGYmF90EjRxy1i21k9wQQjPf26bcBu/9X67KrQjQV0uB38CaNukgiSeoLjfptN811u+PJHx6BP+jx3Qa6/3VenNPxHC8WEU0GXql8QSjIHEyCwKb6fMASXOK94JyB5Ywov2x8mt/+9ncqBBBMVzf6r5Sagy4PL1XnryLsuADD/vOEkPet8wXgH/Oj7v5tTsQQZ7U1JT51PoDs2BFnXc5v3TkVgZwd32k3ONh+nkDw1Hof+4zwUGOyJE6eMrlYzRlKM4Qxdf9JpavQvqfieAbTRWcyKeclnHeoIfE7cDBQIDAQAB",
   "background": {

package/dist/lib/tree-sitter-pool/worker.js

@@ -0,0 +1,543 @@
+import { createRequire } from "node:module";
+import { readFileSync, statSync } from "node:fs";
+import { parentPort } from "node:worker_threads";
+import Parser from "web-tree-sitter";
+import * as path from "node:path";
+import consola from "consola";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/lib/tree-sitter-grammars.ts
+/**
+* Cap the per-file size we'll parse. 1MB of source covers all
+* reasonable hand-written files; bigger files are almost always
+* generated code or vendored bundles whose AST signal is worthless
+* for ranking real definitions.
+*/
+const STRUCTURAL_MAX_FILE_BYTES = 1024 * 1024;
+/**
+* Grammar key → wasm filename under `node_modules/tree-sitter-wasms/out/`.
+* Resolved at runtime from `node_modules`; the file paths are stable
+* because `tree-sitter-wasms` ships prebuilt binaries (no per-install
+* codegen).
+*/
+const GRAMMAR_FILES = {
+	typescript: "tree-sitter-typescript.wasm",
+	tsx: "tree-sitter-tsx.wasm",
+	javascript: "tree-sitter-javascript.wasm",
+	python: "tree-sitter-python.wasm",
+	go: "tree-sitter-go.wasm",
+	rust: "tree-sitter-rust.wasm",
+	java: "tree-sitter-java.wasm",
+	c: "tree-sitter-c.wasm",
+	cpp: "tree-sitter-cpp.wasm"
+};
+/**
+* Per-language definition-shape node types. When a matched identifier
+* sits inside one of these nodes AND is at the node's "name" position,
+* we have AST-confirmed evidence the line is an identifier-definition
+* site. The brief's enumeration plus a handful of language-idiomatic
+* extras (e.g., `lexical_declaration` for TS/JS top-level `const`s,
+* `mod_item` for Rust modules).
+*
+* The set lookup is per-language so a node type that means
+* "definition" in one language but "reference" in another won't
+* cross-pollute.
+*/
+const DEFINITION_NODE_TYPES = {
+	typescript: new Set([
+		"function_declaration",
+		"function_signature",
+		"function_expression",
+		"method_definition",
+		"method_signature",
+		"class_declaration",
+		"interface_declaration",
+		"type_alias_declaration",
+		"enum_declaration",
+		"variable_declarator",
+		"generator_function_declaration",
+		"abstract_method_signature",
+		"public_field_definition",
+		"property_signature"
+	]),
+	tsx: new Set([
+		"function_declaration",
+		"function_signature",
+		"function_expression",
+		"method_definition",
+		"method_signature",
+		"class_declaration",
+		"interface_declaration",
+		"type_alias_declaration",
+		"enum_declaration",
+		"variable_declarator",
+		"generator_function_declaration",
+		"abstract_method_signature",
+		"public_field_definition",
+		"property_signature"
+	]),
+	javascript: new Set([
+		"function_declaration",
+		"function_expression",
+		"method_definition",
+		"class_declaration",
+		"variable_declarator",
+		"generator_function_declaration"
+	]),
+	python: new Set([
+		"function_definition",
+		"class_definition",
+		"decorated_definition"
+	]),
+	go: new Set([
+		"function_declaration",
+		"method_declaration",
+		"type_spec",
+		"type_alias",
+		"const_spec",
+		"var_spec"
+	]),
+	rust: new Set([
+		"function_item",
+		"impl_item",
+		"trait_item",
+		"struct_item",
+		"enum_item",
+		"mod_item",
+		"type_item",
+		"const_item",
+		"static_item",
+		"macro_definition"
+	]),
+	java: new Set([
+		"class_declaration",
+		"interface_declaration",
+		"method_declaration",
+		"constructor_declaration",
+		"enum_declaration",
+		"field_declaration",
+		"annotation_type_declaration"
+	]),
+	c: new Set([
+		"function_definition",
+		"declaration",
+		"struct_specifier",
+		"enum_specifier",
+		"union_specifier",
+		"type_definition"
+	]),
+	cpp: new Set([
+		"function_definition",
+		"declaration",
+		"struct_specifier",
+		"class_specifier",
+		"enum_specifier",
+		"union_specifier",
+		"type_definition",
+		"namespace_definition",
+		"template_declaration"
+	])
+};
+/**
+* Node types that the AST exposes as "this token is an identifier".
+* The match-position lookup uses these to filter out parent-node hits
+* before checking the definition-site predicate.
+*/
+const IDENTIFIER_NODE_TYPES = new Set([
+	"identifier",
+	"type_identifier",
+	"field_identifier",
+	"property_identifier",
+	"shorthand_property_identifier_pattern",
+	"shorthand_property_identifier",
+	"scoped_identifier",
+	"name"
+]);
+let _grammarBundle;
+/**
+* Resolve the `tree-sitter-wasms/out/` directory at the package root.
+* `require.resolve` is used through a try/catch — the bundled-only
+* fallback runs in environments where node_modules has been pruned to
+* just runtime deps.
+*/
+function resolveGrammarRoot() {
+	try {
+		const pkgPath = __require.resolve("tree-sitter-wasms/package.json");
+		return path.join(path.dirname(pkgPath), "out");
+	} catch {
+		return null;
+	}
+}
+/**
+* Pre-load all grammars at module-init time so the first search
+* doesn't pay a ~500ms cold-start cost. The Promise is captured at
+* import time and awaited per-call; per-grammar failures are caught
+* individually so one broken grammar can't take the whole tool down.
+*/
+function getGrammarBundle() {
+	if (_grammarBundle) return _grammarBundle;
+	_grammarBundle = { ready: (async () => {
+		const out = /* @__PURE__ */ new Map();
+		try {
+			await Parser.init();
+		} catch (err) {
+			consola.warn(`[code_search] tree-sitter Parser.init failed; structural ranking disabled: ${err.message}`);
+			return out;
+		}
+		const root = resolveGrammarRoot();
+		if (!root) {
+			consola.warn("[code_search] tree-sitter-wasms package not resolvable; structural ranking disabled");
+			return out;
+		}
+		for (const [key, filename] of Object.entries(GRAMMAR_FILES)) {
+			const wasmPath = path.join(root, filename);
+			try {
+				const lang = await Parser.Language.load(wasmPath);
+				out.set(key, lang);
+			} catch (err) {
+				consola.warn(`[code_search] failed to load tree-sitter grammar '${key}' from ${filename}: ${err.message}`);
+			}
+		}
+		return out;
+	})() };
+	return _grammarBundle;
+}
+getGrammarBundle().ready.catch(() => {});
+/**
+* Robustness bound on outline entries per file. Normal source is far
+* under it; generated/pathological files hit it and `outlineFile` then
+* sets a `notice` so the model knows the map was truncated.
+*/
+const MAX_OUTLINE_ENTRIES = 1e3;
+/**
+* First identifier-typed named child found in a pre-order walk. Mirrors
+* the structural-pass helper in `code-search.ts` (kept local here so
+* the grammar module has no dependency back on the ranking layer).
+*/
+function firstIdentifierLeaf(node) {
+	if (IDENTIFIER_NODE_TYPES.has(node.type)) return node;
+	for (const child of node.namedChildren) {
+		const r = firstIdentifierLeaf(child);
+		if (r) return r;
+	}
+	return null;
+}
+/**
+* Derive a human-readable name for a definition node. Tries the
+* grammar's standard `name` field first, then the `declarator` /
+* `type` fields (C/C++/Java declarators, Rust/Go type specs), then any
+* identifier-typed named child as a last resort. Returns `null` when no
+* name can be recovered — the caller skips such nodes.
+*/
+function deriveDefinitionName(node) {
+	const nameField = node.childForFieldName("name");
+	if (nameField && nameField.text.length > 0) return nameField.text;
+	const declarator = node.childForFieldName("declarator");
+	if (declarator) {
+		const leaf = firstIdentifierLeaf(declarator);
+		if (leaf && leaf.text.length > 0) return leaf.text;
+	}
+	const typeField = node.childForFieldName("type");
+	if (typeField) {
+		const leaf = firstIdentifierLeaf(typeField);
+		if (leaf && leaf.text.length > 0) return leaf.text;
+	}
+	const fallback = firstIdentifierLeaf(node);
+	if (fallback && fallback.text.length > 0) return fallback.text;
+	return null;
+}
+/**
+* Collect EVERY definition node from the parse tree — top-level AND
+* nested (class methods, methods' inner functions, nested classes, …) —
+* so the outline is a COMPLETE structural map the model can rely on to
+* decide what to read. Recurses through non-definition wrappers (TS
+* `export_statement`, Python `decorated_definition`, C++
+* `template_declaration`, …) at the same depth, and INTO each definition
+* at depth+1 to surface its members.
+*
+* `defTypes` is the language's definition-node-type set. Each node yields
+* one entry; the `name` is derived per `deriveDefinitionName` (a node
+* with no recoverable name is skipped, but the walk still descends into
+* it so its named members aren't lost). Bounded at `MAX_OUTLINE_ENTRIES`.
+*/
+function collectDefinitions(root, defTypes, signal) {
+	const out = [];
+	const visit = (node, depth) => {
+		if (signal?.aborted || out.length >= MAX_OUTLINE_ENTRIES) return;
+		for (const child of node.namedChildren) {
+			if (signal?.aborted || out.length >= MAX_OUTLINE_ENTRIES) return;
+			if (defTypes.has(child.type)) {
+				const name = deriveDefinitionName(child);
+				if (name !== null) out.push({
+					kind: child.type,
+					name,
+					line: child.startPosition.row + 1,
+					depth
+				});
+				visit(child, depth + 1);
+				continue;
+			}
+			visit(child, depth);
+		}
+	};
+	visit(root, 0);
+	return out;
+}
+/**
+* Build a `FileOutlineResult` from an ALREADY-PARSED tree — walk-only,
+* no read / parse / `delete`. The tree's ownership stays with the caller
+* (e.g. the code-search structural pass's `_treeCache`), so this lets the
+* outline step REUSE a tree the structural pass already parsed instead of
+* re-reading + re-parsing the file. Never throws.
+*/
+function outlineFromTree(tree, language, signal) {
+	if (signal?.aborted) return {
+		outline: [],
+		language
+	};
+	const defTypes = DEFINITION_NODE_TYPES[language];
+	if (!defTypes) return {
+		outline: [],
+		language,
+		notice: "outline unavailable (parse error)"
+	};
+	try {
+		const outline = collectDefinitions(tree.rootNode, defTypes, signal);
+		if (signal?.aborted) return {
+			outline: [],
+			language
+		};
+		outline.sort((a, b) => a.line - b.line);
+		if (outline.length >= MAX_OUTLINE_ENTRIES) return {
+			outline,
+			language,
+			notice: `outline truncated at ${MAX_OUTLINE_ENTRIES} symbols (very large file)`
+		};
+		return {
+			outline,
+			language
+		};
+	} catch {
+		return {
+			outline: [],
+			language,
+			notice: "outline unavailable (parse error)"
+		};
+	}
+}
+/**
+* Compute the absolute byte offset where line `lineNumber1` starts in
+* `source`. Lines are counted by LF; CRLF files have the same line starts as
+* LF files (the \r is part of the previous line's content). 1-indexed to match
+* ripgrep. Returns -1 if the line is past EOF.
+*/
+function lineStartByte(source, lineNumber1) {
+	if (lineNumber1 <= 1) return 0;
+	let line = 1;
+	for (let i = 0; i < source.length; i++) if (source.charCodeAt(i) === 10) {
+		line += 1;
+		if (line === lineNumber1) return i + 1;
+	}
+	return -1;
+}
+function containsByteRange(outer, inner) {
+	return outer.startIndex <= inner.startIndex && outer.endIndex >= inner.endIndex;
+}
+/**
+* Walk up from a matched identifier node looking for the closest
+* definition-shape ancestor (per the language's allowed types). When found,
+* verify the matched identifier is at the definition's "name" slot — NOT inside
+* a parameter type, a body, or a parent's signature. Returns true iff this is a
+* real definition site for the identifier the rg submatch landed on. Depth
+* bound 6 — definition names sit close to their definition node in every
+* supported grammar; deeper walks risk false positives.
+*/
+function isDefiningSite(matchedNode, langKey) {
+	const defTypes = DEFINITION_NODE_TYPES[langKey];
+	if (!defTypes) return false;
+	let cur = matchedNode.parent;
+	let depth = 0;
+	while (cur && depth < 6) {
+		if (defTypes.has(cur.type)) {
+			const nameField = cur.childForFieldName("name");
+			if (nameField && containsByteRange(nameField, matchedNode)) return true;
+			const declarator = cur.childForFieldName("declarator");
+			if (declarator && containsByteRange(declarator, matchedNode)) {
+				const first = firstIdentifierLeaf(declarator);
+				if (first && first.startIndex === matchedNode.startIndex) return true;
+			}
+			const typeField = cur.childForFieldName("type");
+			if (typeField && containsByteRange(typeField, matchedNode)) {
+				const first = firstIdentifierLeaf(typeField);
+				if (first && first.startIndex === matchedNode.startIndex) return true;
+			}
+		}
+		cur = cur.parent;
+		depth += 1;
+	}
+	return false;
+}
+/**
+* Run the AST-confirmation walk over `hits` against an ALREADY-PARSED tree.
+* Returns the subset of input indices whose matched identifier is at a real
+* definition site. Borrowed tree — never deleted. Pure + deterministic: the
+* output set is a function of (tree, source, hits) only, independent of call
+* order, so the in-process path and the worker path return identical sets.
+*
+* Never throws — a per-hit walk failure just omits that index (matches the
+* in-process pass's per-hit try/catch). `signal` short-circuits between hits.
+*/
+function confirmDefinitionSites(tree, source, language, hits, signal) {
+	const confirmed = [];
+	if (!DEFINITION_NODE_TYPES[language]) return confirmed;
+	for (let i = 0; i < hits.length; i++) {
+		if (signal?.aborted) break;
+		const hit = hits[i];
+		const lineStart = lineStartByte(source, hit.line);
+		if (lineStart < 0) continue;
+		const matchByteStart = lineStart + hit.matchStart;
+		const matchByteEnd = lineStart + hit.matchEnd;
+		let node;
+		try {
+			node = tree.rootNode.descendantForIndex(matchByteStart, matchByteEnd);
+		} catch {
+			node = null;
+		}
+		if (!node) continue;
+		if (!IDENTIFIER_NODE_TYPES.has(node.type)) {
+			let cur = node;
+			let depth = 0;
+			while (cur && !IDENTIFIER_NODE_TYPES.has(cur.type) && depth < 3) {
+				const leaf = firstIdentifierLeaf(cur);
+				if (leaf && leaf.startIndex === matchByteStart) {
+					cur = leaf;
+					break;
+				}
+				cur = cur.parent;
+				depth += 1;
+			}
+			node = cur;
+		}
+		if (!node || !IDENTIFIER_NODE_TYPES.has(node.type)) continue;
+		if (isDefiningSite(node, language)) confirmed.push(i);
+	}
+	return confirmed;
+}
+
+//#endregion
+//#region src/lib/tree-sitter-pool/worker.ts
+if (!parentPort) throw new Error("tree-sitter worker must be spawned via worker_threads");
+const port = parentPort;
+let grammars = /* @__PURE__ */ new Map();
+const parsers = /* @__PURE__ */ new Map();
+let cancelled = false;
+function handleJob(job) {
+	if (process.env.GH_ROUTER_TS_WORKER_CRASH === "1") throw new Error("injected worker crash (test)");
+	if (cancelled) return {
+		id: job.id,
+		ok: true,
+		mtimeMs: job.mtimeMs
+	};
+	const lang = grammars.get(job.language);
+	if (!lang) return {
+		id: job.id,
+		ok: false,
+		error: "grammar not loaded"
+	};
+	let mtimeMs;
+	let size;
+	try {
+		const st = statSync(job.absPath);
+		mtimeMs = st.mtimeMs;
+		size = st.size;
+	} catch (err) {
+		return {
+			id: job.id,
+			ok: false,
+			error: `stat failed: ${err.message}`
+		};
+	}
+	if (size > STRUCTURAL_MAX_FILE_BYTES) return {
+		id: job.id,
+		ok: false,
+		error: "file too large"
+	};
+	let source;
+	try {
+		source = readFileSync(job.absPath, "utf8");
+	} catch (err) {
+		return {
+			id: job.id,
+			ok: false,
+			error: `read failed: ${err.message}`
+		};
+	}
+	let parser = parsers.get(job.language);
+	if (!parser) {
+		parser = new Parser();
+		parser.setLanguage(lang);
+		parsers.set(job.language, parser);
+	}
+	let tree = null;
+	try {
+		tree = parser.parse(source);
+	} catch (err) {
+		return {
+			id: job.id,
+			ok: false,
+			error: `parse failed: ${err.message}`
+		};
+	}
+	if (!tree) return {
+		id: job.id,
+		ok: false,
+		error: "parse returned null"
+	};
+	try {
+		const reply = {
+			id: job.id,
+			ok: true,
+			mtimeMs
+		};
+		if (job.want.confirmHits && job.want.confirmHits.length > 0) reply.confirmedHitIndexes = confirmDefinitionSites(tree, source, job.language, job.want.confirmHits);
+		if (job.want.outline) reply.outlineEntries = outlineFromTree(tree, job.language).outline;
+		return reply;
+	} catch (err) {
+		return {
+			id: job.id,
+			ok: false,
+			error: `walk failed: ${err.message}`
+		};
+	} finally {
+		try {
+			tree.delete();
+		} catch {}
+	}
+}
+port.on("message", (msg) => {
+	if ("type" in msg) {
+		if (msg.type === "cancel") cancelled = true;
+		return;
+	}
+	cancelled = false;
+	const reply = handleJob(msg);
+	port.postMessage(reply);
+});
+(async () => {
+	try {
+		grammars = await getGrammarBundle().ready;
+	} catch {
+		grammars = /* @__PURE__ */ new Map();
+	}
+	const ready = {
+		type: "ready",
+		loaded: [...grammars.keys()]
+	};
+	port.postMessage(ready);
+})();
+
+//#endregion
+export {  };

package/dist/lifecycle-BL4rWSrT.js

@@ -0,0 +1,4 @@
+import "./paths-yJ97KlKp.js";
+import { a as trackChild, i as sweepStaleColbertMetaAtBoot, n as registerColbertExitHandlers, r as sweepLiveChildren, t as getColbertInstanceUuid } from "./lifecycle-yaqqtsV1.js";
+
+export { getColbertInstanceUuid, registerColbertExitHandlers, sweepLiveChildren, sweepStaleColbertMetaAtBoot, trackChild };

package/dist/{lifecycle-NQRdfY1u.js → lifecycle-CMPthagV.js}

@@ -1,4 +1,4 @@
-import { l as writeRuntimeFileSecure, t as PATHS } from "./paths-CoFnpNZl.js";
+import { l as writeRuntimeFileSecure, t as PATHS } from "./paths-yJ97KlKp.js";
 import { randomBytes, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -307,4 +307,4 @@ async function sweepStaleWorktreesAtBoot() {
 
 //#endregion
 export { sweepRegistry as a, registerExitHandlers as i, getInstanceUuid as n, sweepStaleWorktreesAtBoot as o, recordWorkerRepo as r, WorktreeRegistry as t };
-//# sourceMappingURL=lifecycle-NQRdfY1u.js.map
+//# sourceMappingURL=lifecycle-CMPthagV.js.map