better-dsh 0.2.5-c → 0.2.5-e

package/lib/url-schemes/index.js

@@ -1,11 +1,13 @@
+import { r as __toESM, t as __commonJS } from "../chunk-DQxbwPpZ.js";
 import { t as Schema } from "../lib-C8_jXvwA.js";
 import { a as PACKAGE_ROOT } from "../kernel-env-BLPZE-I3.js";
 import { n as captureNativeTools } from "../native-capture-BEByDXYM.js";
-import { a as createHttpHandler, c as listDvcDevices, d as UrlResolver, f as UrlSchemesError, h as SCHEME_NAMES, i as HTTP_SCHEMES, l as registerDvcDevice, m as parseUrl, n as wrapFsWithSchemes, o as createDvcHandler, p as applySelector, r as resolveDocsDir, s as dispatchDvcWrite, u as createDshHandler } from "../wrap-0VA0uFx8.js";
-import { a as primaryServerForFile, c as serversForFile, n as findWorkspaceRoot, o as resolveCommandPath, r as installHintFor, s as serverByName } from "../lsp-server-registry-C05QLdw0.js";
+import { a as createDshHandler, c as createDvcHandler, d as registerDvcDevice, f as UrlSchemesError, h as SCHEME_NAMES, i as createHttpHandler, l as dispatchDvcWrite, m as parseUrl, n as wrapFsWithSchemes, o as UrlResolver, p as applySelector, r as HTTP_SCHEMES, s as resolveDocsDir, u as listDvcDevices } from "../wrap-kTohEeis.js";
+import { n as Parser } from "../web-tree-sitter-CPrPD4J2.js";
+import { a as primaryServerForFile, c as serversForFile, n as findWorkspaceRoot, o as resolveCommandPath, r as installHintFor, s as serverByName } from "../lsp-server-registry-D4VLs1Sm.js";
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
-import { accessSync, constants, existsSync, readFileSync, statSync } from "node:fs";
+import { accessSync, constants, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import * as path$1 from "node:path";
 import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { spawn } from "node:child_process";
@@ -14,14 +16,1183 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import * as fsPromises from "node:fs/promises";
 import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { FsError } from "@deepseek-ai/dsh-fs";
-import { ESCALATION_TARGETS, approveEscalation, escalationHintMarker, sandboxDenialMarker, validateEscalationArgs } from "@deepseek-ai/dsh-sandbox";
 import { gunzipSync } from "node:zlib";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 import { DatabaseSync } from "node:sqlite";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { FsError } from "@deepseek-ai/dsh-fs";
+import { ESCALATION_TARGETS, approveEscalation, escalationHintMarker, sandboxDenialMarker, validateEscalationArgs } from "@deepseek-ai/dsh-sandbox";
+
+//#region src/devices/ast/engine/grammar-manifest.mjs
+/**
+* AST 引擎的资产清单 —— 拷贝脚本（scripts/copy-ast-assets.mjs）与运行时注册表
+* （engine/grammars.ts）的单一真相源。三个包都无 install script、无传递依赖。
+* ABI 锁步：@lumis-sh/wasm-* 与 web-tree-sitter 必须同为主版本 0.26（dylink.0）。
+*/
+const ENGINE_ASSETS = [{
+	file: "ast-grep.wasm",
+	subpath: "@ast-grep/wasm/wasm_bg.wasm"
+}, {
+	file: "tree-sitter.wasm",
+	subpath: "web-tree-sitter/web-tree-sitter.wasm"
+}];
+const GRAMMAR_PACKAGES = {
+	python: "@lumis-sh/wasm-python",
+	javascript: "@lumis-sh/wasm-javascript",
+	typescript: "@lumis-sh/wasm-typescript",
+	tsx: "@lumis-sh/wasm-tsx",
+	rust: "@lumis-sh/wasm-rust",
+	go: "@lumis-sh/wasm-go",
+	c: "@lumis-sh/wasm-c",
+	cpp: "@lumis-sh/wasm-cpp",
+	html: "@lumis-sh/wasm-html",
+	css: "@lumis-sh/wasm-css",
+	json: "@lumis-sh/wasm-json",
+	yaml: "@lumis-sh/wasm-yaml",
+	bash: "@lumis-sh/wasm-bash",
+	ruby: "@lumis-sh/wasm-ruby"
+};
+/** lang → { file: 包内资产名, subpath: 可 require.resolve 的完整子路径 } */
+const GRAMMAR_ASSETS = Object.fromEntries(Object.entries(GRAMMAR_PACKAGES).map(([lang, pkg]) => [lang, {
+	file: `tree-sitter-${lang}.wasm`,
+	subpath: `${pkg}/tree-sitter-${lang}.wasm`
+}]));
+
+//#endregion
+//#region src/devices/ast/engine/language-map.ts
+/**
+* 扩展名 → 内置 tree-sitter 语法。AST 语言面的单一真相源：
+* walker 的语言推断与 ast-reminder 的提醒集合都从这里派生，
+* 不再各自维护（也不再"对 shipped 二进制实测"）。
+*/
+const EXTENSION_TO_LANGUAGE = {
+	".py": "python",
+	".pyi": "python",
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".ts": "typescript",
+	".mts": "typescript",
+	".cts": "typescript",
+	".tsx": "tsx",
+	".rs": "rust",
+	".go": "go",
+	".c": "c",
+	".h": "c",
+	".cpp": "cpp",
+	".hpp": "cpp",
+	".html": "html",
+	".css": "css",
+	".json": "json",
+	".yaml": "yaml",
+	".yml": "yaml",
+	".sh": "bash",
+	".rb": "ruby"
+};
+/** 该设备支持的全部语法（去重、稳定序）。 */
+const AST_LANGUAGES = [...new Set(Object.values(EXTENSION_TO_LANGUAGE))];
+/** 小写扩展名 → 语法；未知扩展名返回 undefined。 */
+function languageForPath(filePath) {
+	const dot = filePath.lastIndexOf(".");
+	if (dot <= filePath.lastIndexOf("/")) return void 0;
+	return EXTENSION_TO_LANGUAGE[filePath.slice(dot).toLowerCase()];
+}
+
+//#endregion
+//#region src/devices/ast/engine/wasm.ts
+const ASTGREP_WASM = ENGINE_ASSETS[0];
+const TREE_SITTER_WASM = ENGINE_ASSETS[1];
+/**
+* WebAssembly 运行时全局。本仓 tsconfig 无 DOM lib，@types/node 也未声明该全局值
+* （TS2708：仅存类型命名空间），故经 globalThis 取类型化句柄 —— 运行时是同一全局对象。
+*/
+const WebAssemblyGlobal = globalThis.WebAssembly;
+/**
+* 资产解析的唯一机制，逐文件生效：构建产物 `lib/ast-assets/` 在场 → 用它（发布面）；
+* 否则 dev 下按 manifest subpath 在 node_modules 直解析（不要求先跑过 build）。
+* 14 个语法分属 14 个 `@lumis-sh/wasm-*` 包、tree-sitter.wasm 在 web-tree-sitter ——
+* 不存在装下全部资产的单一 dev 目录，故不做目录级回落。
+*/
+function assetPath(file) {
+	const bundled = join(PACKAGE_ROOT, "lib", "ast-assets");
+	if (existsSync(bundled)) return join(bundled, file);
+	return createRequire(import.meta.url).resolve(subpathOf(file));
+}
+async function readAsset(file) {
+	return readFile(assetPath(file));
+}
+function subpathOf(file) {
+	return ENGINE_ASSETS.find((a) => a.file === file)?.subpath ?? Object.values(GRAMMAR_ASSETS).find((a) => a.file === file).subpath;
+}
+let enginePromise;
+/** Boot the engine once per process; every later call returns the same instance. */
+function astEngine() {
+	enginePromise ??= boot();
+	return enginePromise;
+}
+async function boot() {
+	const bg = await import("../wasm_bg-CNXhHjVg.js");
+	const bytes = await readAsset(ASTGREP_WASM.file);
+	const { instance } = await WebAssemblyGlobal.instantiate(bytes, { "./wasm_bg.js": bg });
+	bg.__wbg_set_wasm(instance.exports);
+	instance.exports.__wbindgen_start();
+	await Parser.init({ locateFile: () => assetPath(TREE_SITTER_WASM.file) });
+	await bg.initializeTreeSitter();
+	return {
+		parse: (lang, source) => bg.parse(lang, source),
+		registerLanguages: (entries) => bg.registerDynamicLanguage(entries)
+	};
+}
+
+//#endregion
+//#region src/devices/ast/engine/grammars.ts
+/** ast-grep 的元变量引导字符；所有语言统一用 µ（实测全语言可用）。 */
+const EXPANDO_CHAR = "µ";
+const broken = /* @__PURE__ */ new Set();
+let registered;
+function ensureLanguages() {
+	registered ??= (async () => {
+		const engine = await astEngine();
+		const entries = {};
+		for (const lang of AST_LANGUAGES) entries[lang] = {
+			libraryPath: assetPath(GRAMMAR_ASSETS[lang].file),
+			expandoChar: EXPANDO_CHAR
+		};
+		await engine.registerLanguages(entries);
+		for (const lang of AST_LANGUAGES) try {
+			engine.parse(lang, "");
+		} catch {
+			broken.add(lang);
+		}
+	})();
+	return registered;
+}
+/** 该语法是否注册成功（失败的语言由 walker 跳过并计入 parseErrors）。 */
+function isLanguageAvailable(lang) {
+	return !broken.has(lang);
+}
+
+//#endregion
+//#region src/devices/ast/engine/edit.ts
+const META_TOKEN = /\$\$\$([A-Z_][A-Z0-9_]*)|\$([A-Z_][A-Z0-9_]*)/g;
+const MULTI_NODE$1 = "Multiple AST nodes are detected";
+/**
+* 把模板里的元变量替换成该次命中的捕获文本（`$_`-匿名 → 空串）。
+* `$$$A` 取整个多捕获区间的**源文本**（首捕获节点起点 → 末捕获节点终点，
+* 空捕获 → 空串）——这才是 native 的实测行为（`greet( 1,2 , 3 )` → `log(1,2 , 3)`、
+* `greet()` → `log()`，A/B 复核 2026-10-03）；对逐节点文本做 naive join 会得到
+* `1, ,, 2, ,, 3`，与 native 的 `1, 2, 3` 不符。
+*/
+function expand(template, source, node) {
+	return template.replace(META_TOKEN, (whole, multi, single) => {
+		if (multi !== void 0) {
+			const parts = node.getMultipleMatches(multi);
+			if (parts.length === 0) return "";
+			const start = parts[0].range().start.index;
+			const end = parts[parts.length - 1].range().end.index;
+			return source.slice(start, end);
+		}
+		if (single === void 0) return whole;
+		if (single.startsWith("_")) return "";
+		return node.getMatch(single)?.text() ?? "";
+	});
+}
+async function editSource(source, lang, rewrites) {
+	await ensureLanguages();
+	if (!isLanguageAvailable(lang) || Object.keys(rewrites).length === 0) return {
+		changes: [],
+		rewritten: source,
+		totalReplacements: 0,
+		parseErrorCount: 0,
+		overlapping: 0
+	};
+	const root = (await astEngine()).parse(lang, source).root();
+	const edits = [];
+	const patternErrors = {};
+	for (const [pattern, template] of Object.entries(rewrites)) {
+		let hits;
+		try {
+			hits = root.findAll(pattern);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes(MULTI_NODE$1)) {
+				patternErrors[pattern] = error.message;
+				continue;
+			}
+			throw error;
+		}
+		for (const node of hits) {
+			const range = node.range();
+			const replacement = expand(template, source, node);
+			const byteStart = Buffer.byteLength(source.slice(0, range.start.index), "utf8");
+			edits.push({
+				edit: {
+					start_pos: range.start.index,
+					end_pos: range.end.index,
+					inserted_text: replacement
+				},
+				change: {
+					path: "",
+					before: node.text(),
+					after: replacement,
+					byteStart,
+					byteEnd: byteStart + Buffer.byteLength(node.text(), "utf8"),
+					deletedLength: Buffer.byteLength(node.text(), "utf8"),
+					startLine: range.start.line + 1,
+					startColumn: range.start.column + 1,
+					endLine: range.end.line + 1,
+					endColumn: range.end.column + 1
+				}
+			});
+		}
+	}
+	edits.sort((a, b) => a.edit.start_pos - b.edit.start_pos);
+	const accepted = [];
+	let overlapping = 0;
+	let lastEnd = -1;
+	for (const candidate of edits) {
+		if (candidate.edit.start_pos < lastEnd) {
+			overlapping += 1;
+			continue;
+		}
+		accepted.push(candidate);
+		lastEnd = Math.max(lastEnd, candidate.edit.end_pos);
+	}
+	accepted.sort((a, b) => b.edit.start_pos - a.edit.start_pos);
+	const rewritten = root.commitEdits(accepted.map((e$1) => e$1.edit));
+	return {
+		changes: accepted.map((e$1) => e$1.change),
+		rewritten,
+		totalReplacements: accepted.length,
+		parseErrorCount: 0,
+		overlapping,
+		...Object.keys(patternErrors).length > 0 ? { patternErrors } : {}
+	};
+}
+
+//#endregion
+//#region src/devices/ast/engine/match.ts
+const MULTI_NODE = "Multiple AST nodes are detected";
+/** 字符偏移 → UTF-8 字节偏移。 */
+function byteOffsetOf(source, charIndex) {
+	return Buffer.byteLength(source.slice(0, charIndex), "utf8");
+}
+function toMatch(source, node, meta) {
+	const range = node.range();
+	const byteStart = byteOffsetOf(source, range.start.index);
+	return {
+		path: "",
+		text: node.text(),
+		byteStart,
+		byteEnd: byteStart + Buffer.byteLength(node.text(), "utf8"),
+		startLine: range.start.line + 1,
+		startColumn: range.start.column + 1,
+		endLine: range.end.line + 1,
+		endColumn: range.end.column + 1,
+		...meta !== void 0 && Object.keys(meta).length > 0 ? { metaVariables: meta } : {}
+	};
+}
+/** 单 metavar → 捕获文本；多 metavar → 复刻 native 的 Rust Debug 数组串。 */
+function collectMeta(node, pattern, includeMeta) {
+	if (!includeMeta) return void 0;
+	const meta = {};
+	for (const raw of pattern.matchAll(/\$+\$?([A-Z_][A-Z0-9_]*)/g)) {
+		const token = raw[0];
+		const name$1 = raw[1];
+		if (token === `$$$${name$1}`) {
+			const parts = node.getMultipleMatches(name$1).map((n) => n.text());
+			if (parts.length > 0) meta[name$1] = `[${parts.join(", ")}]`;
+		} else if (!token.startsWith("$$")) {
+			const bound = node.getMatch(name$1);
+			if (bound !== void 0) meta[name$1] = bound.text();
+		}
+	}
+	return meta;
+}
+async function findInSource(source, lang, pattern, options) {
+	await ensureLanguages();
+	if (!isLanguageAvailable(lang)) return {
+		matches: [],
+		unavailable: true
+	};
+	const root = (await astEngine()).parse(lang, source).root();
+	let hits;
+	try {
+		hits = root.findAll(pattern);
+	} catch (error) {
+		if (error instanceof Error && error.message.includes(MULTI_NODE)) return {
+			matches: [],
+			unavailable: false,
+			patternError: error.message
+		};
+		throw error;
+	}
+	return {
+		matches: hits.map((node) => toMatch(source, node, collectMeta(node, pattern, options.includeMeta === true))),
+		unavailable: false
+	};
+}
+
+//#endregion
+//#region node_modules/ignore/index.js
+var require_ignore = /* @__PURE__ */ __commonJS({ "node_modules/ignore/index.js": ((exports, module) => {
+	function makeArray(subject) {
+		return Array.isArray(subject) ? subject : [subject];
+	}
+	const UNDEFINED = void 0;
+	const EMPTY = "";
+	const SPACE = " ";
+	const ESCAPE = "\\";
+	const REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+	const BOM = "";
+	const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+	const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+	const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+	const REGEX_SPLITALL_CRLF = /\r?\n/g;
+	const DOUBLE_SLASH = "//";
+	const SLASH_CODE = 47;
+	const DOT_CODE = 46;
+	const SLASH = "/";
+	let TMP_KEY_IGNORE = "node-ignore";
+	/* istanbul ignore else */
+	if (typeof Symbol !== "undefined") TMP_KEY_IGNORE = Symbol.for("node-ignore");
+	const KEY_IGNORE = TMP_KEY_IGNORE;
+	const define = (object, key, value) => {
+		Object.defineProperty(object, key, { value });
+		return value;
+	};
+	const RETURN_FALSE = () => false;
+	const cleanRangeBackSlash = (slashes) => {
+		const { length } = slashes;
+		return slashes.slice(0, length - length % 2);
+	};
+	const POSIX_CLASSES = {
+		alnum: "0-9A-Za-z",
+		alpha: "A-Za-z",
+		blank: " \\t",
+		cntrl: "\\x00-\\x1f\\x7f",
+		digit: "0-9",
+		graph: "!-.0-~",
+		lower: "a-z",
+		print: " -.0-~",
+		punct: "!-.:-@\\[-`{-~",
+		space: " \\t\\n\\r",
+		upper: "A-Z",
+		xdigit: "0-9A-Fa-f"
+	};
+	const CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+	const escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
+	const NON_SLASH = "(?!\\/)";
+	const classSource = (negated, body) => {
+		if (negated) return `[^\\/${body}]`;
+		const source = `[${body}]`;
+		return new RegExp(source).test("/") ? NON_SLASH + source : source;
+	};
+	const scanBracket = (pattern, start) => {
+		const { length } = pattern;
+		let index = start + 1;
+		let negated = EMPTY;
+		const lead = pattern[index];
+		if (lead === "!" || lead === "^") {
+			negated = "^";
+			index++;
+		}
+		let body = EMPTY;
+		let prev = EMPTY;
+		for (;;) {
+			const char = pattern[index];
+			if (char === UNDEFINED) return null;
+			if (char === ESCAPE) {
+				const escaped = pattern[index + 1];
+				if (escaped === UNDEFINED) return null;
+				body += escapeMember(escaped);
+				prev = escaped;
+				index++;
+			} else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+				index++;
+				let to = pattern[index];
+				if (to === ESCAPE) to = pattern[index += 1];
+				if (prev <= to) body += `-${escapeMember(to)}`;
+				prev = EMPTY;
+			} else if (char === "[" && pattern[index + 1] === ":") {
+				const nameStart = index + 2;
+				let end = nameStart;
+				while (end < length && pattern[end] !== "]") end++;
+				if (end === length) return null;
+				if (end > nameStart && pattern[end - 1] === ":") {
+					const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+					if (expanded === UNDEFINED) return null;
+					body += expanded;
+					prev = EMPTY;
+					index = end;
+				} else {
+					body += escapeMember("[");
+					prev = "[";
+					index = nameStart - 2;
+				}
+			} else {
+				body += escapeMember(char);
+				prev = char;
+			}
+			index++;
+			if (pattern[index] === "]") return {
+				end: index,
+				source: classSource(negated, body)
+			};
+		}
+	};
+	const NEVER_MATCH = "[]";
+	const PLACEHOLDER = "\0";
+	const REGEX_RESTORE_PLACEHOLDER = new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g");
+	const TRAILING_WILDCARD = "";
+	const TRAILING_DOUBLESTAR = "";
+	const extractBrackets = (pattern) => {
+		const sources = [];
+		const hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`;
+		const { length } = pattern;
+		let out = EMPTY;
+		let index = 0;
+		while (index < length) {
+			const char = pattern[index];
+			if (char === ESCAPE) {
+				const escaped = pattern[index + 1];
+				if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) out += hold(NEVER_MATCH);
+				else if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) out += pattern.slice(index, index + 2);
+				else out += hold(REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped);
+				index += 2;
+			} else if (char === PLACEHOLDER) {
+				out += hold(`[${PLACEHOLDER}]`);
+				index++;
+			} else if (char === "[") {
+				const scanned = scanBracket(pattern, index);
+				if (scanned === null) {
+					out += hold(NEVER_MATCH);
+					index = length;
+				} else {
+					out += hold(scanned.source);
+					index = scanned.end + 1;
+				}
+			} else {
+				out += char;
+				index++;
+			}
+		}
+		return {
+			source: out,
+			sources
+		};
+	};
+	const DIRECT = null;
+	const REGEX_INNER_SLASH = /\/(?!$)/;
+	const REPLACERS = [
+		[
+			/(\\+)( ?)/g,
+			(_, run, space) => space ? run.slice(0, run.length - run.length % 2) + SPACE : run,
+			ESCAPE + SPACE
+		],
+		[/[\\$.|*+(){^]/g, (match) => `\\${match}`],
+		[
+			/(?!\\)\?/g,
+			() => "[^/]",
+			"?"
+		],
+		[
+			/^\//,
+			() => "^",
+			SLASH
+		],
+		[
+			/\//g,
+			() => "\\/",
+			SLASH
+		],
+		[
+			/^\^*(?:\\\*\\\*\\\/)+/,
+			() => "^(?:.*\\/)?",
+			"*"
+		],
+		[DIRECT, (source, pattern) => {
+			if (!source || source[0] === "^") return source;
+			return (!REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^") + source;
+		}],
+		[
+			/\\\/\\\*\\\*(?=\\\/|$)/g,
+			(_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
+			"*"
+		],
+		[
+			/(^|[^\\]+)(\\\*)+(?=.+)/g,
+			(_, p1, p2) => {
+				return p1 + p2.replace(/\\\*/g, "[^\\/]*");
+			},
+			"*"
+		],
+		[
+			/(^|[^\\])((?:\\\\)*)\\\*$/,
+			(match, p1, p2) => p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match,
+			"*"
+		],
+		[
+			/\\\\\\(?=[$.|*+(){^])/g,
+			() => ESCAPE,
+			ESCAPE + ESCAPE
+		],
+		[
+			/\\\\/g,
+			() => ESCAPE,
+			ESCAPE + ESCAPE
+		],
+		[
+			/\\\[([^\]/]*?)(\\*)($|\])/g,
+			(match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+			"["
+		],
+		[DIRECT, (source) => {
+			const last = source[source.length - 1];
+			if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) return source;
+			return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+		}]
+	];
+	const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
+	const MODE_IGNORE = "regex";
+	const MODE_CHECK_IGNORE = "checkRegex";
+	const UNDERSCORE = "_";
+	const replaceTrailingWildcard = (_, p1) => {
+		return `${p1 ? `${p1}[^/]+` : "[^/]*"}(?=$|\\/$)`;
+	};
+	const REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
+	const replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
+	const WILDCARD = "[^\\/]*";
+	const separatorAfter = (run, at) => {
+		let separator = EMPTY;
+		for (let index = at + 1; index < run.length && !run[index].wildcard; index++) separator += run[index].single;
+		return separator;
+	};
+	const pinWildcards = (source) => {
+		if (source.indexOf(WILDCARD) < 0) return source;
+		const tokens = [];
+		const { length } = source;
+		let index = 0;
+		while (index < length) {
+			const char = source[index];
+			if (source.startsWith(WILDCARD, index)) {
+				tokens.push({ wildcard: true });
+				index += 6;
+			} else if (char === "[") {
+				let end = index + 1;
+				if (source[end] === "^") end++;
+				if (source[end] === "]") end++;
+				while (end < length && source[end] !== "]") end += source[end] === ESCAPE ? 2 : 1;
+				end++;
+				tokens.push({ single: source.slice(index, end) });
+				index = end;
+			} else if (char === ESCAPE) {
+				tokens.push({ single: source.slice(index, index + 2) });
+				index += 2;
+			} else if (char === "(") {
+				let depth = 0;
+				let end = index;
+				do {
+					if (source[end] === ESCAPE) end++;
+					else if (source[end] === "(") depth++;
+					else if (source[end] === ")") depth--;
+					end++;
+				} while (end < length && depth > 0);
+				if ("*+?".indexOf(source[end]) >= 0) end++;
+				tokens.push({ boundary: source.slice(index, end) });
+				index = end;
+			} else if (char === "^" || char === "$") {
+				tokens.push({ boundary: char });
+				index++;
+			} else {
+				tokens.push({ single: char });
+				index++;
+			}
+		}
+		let out = EMPTY;
+		let run = [];
+		const flush = () => {
+			let lastWildcard;
+			run.forEach((token, at) => {
+				if (token.wildcard) lastWildcard = at;
+			});
+			run.forEach((token, at) => {
+				if (!token.wildcard) {
+					out += token.single;
+					return;
+				}
+				out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+			});
+			run = [];
+		};
+		tokens.forEach((token) => {
+			if (token.boundary === void 0) {
+				run.push(token);
+				return;
+			}
+			flush();
+			out += token.boundary;
+		});
+		flush();
+		return out;
+	};
+	const makeRegexPrefix = (pattern) => {
+		const { source, sources } = extractBrackets(pattern);
+		const replaced = REPLACERS.reduce((prev, [matcher, replacer, required]) => {
+			if (matcher === DIRECT) return replacer(prev, pattern);
+			if (required !== UNDEFINED && prev.indexOf(required) < 0) return prev;
+			return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+		}, source);
+		return sources.length ? replaced.replace(REGEX_RESTORE_PLACEHOLDER, (match, index) => sources[index]) : replaced;
+	};
+	const checkSourceOf = (body, prefix) => {
+		if (body[body.length - 1] === SLASH) prefix = makeRegexPrefix(body.slice(0, -1));
+		const head = prefix.slice(0, -1);
+		const last = prefix[prefix.length - 1];
+		return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
+	};
+	const matchesBasename = (body) => {
+		const index = body.indexOf(SLASH);
+		return index < 0 || index === body.length - 1;
+	};
+	const basenameOf = (path$2) => {
+		const end = path$2.length - 1;
+		const index = path$2.lastIndexOf(SLASH, path$2[end] === SLASH ? end - 1 : end);
+		return index < 0 ? path$2 : path$2.slice(index + 1);
+	};
+	const parentOf = (path$2) => {
+		if (path$2.charCodeAt(0) === SLASH_CODE || path$2.indexOf(DOUBLE_SLASH) >= 0) {
+			const slices = path$2.split(SLASH).filter(Boolean);
+			slices.pop();
+			return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
+		}
+		const end = path$2.length - 1;
+		const cut = path$2.lastIndexOf(SLASH, path$2.charCodeAt(end) === SLASH_CODE ? end - 1 : end);
+		return cut < 0 ? EMPTY : path$2.slice(0, cut + 1);
+	};
+	const isString = (subject) => typeof subject === "string";
+	const checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern);
+	const splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+	var IgnoreRule = class {
+		constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+			this.pattern = pattern;
+			this.mark = mark;
+			this.negative = negative;
+			define(this, "body", body);
+			define(this, "ignoreCase", ignoreCase);
+			define(this, "regexPrefix", prefix);
+		}
+		get _basenameOnly() {
+			return define(this, "_basenameOnly", matchesBasename(this.body));
+		}
+		get regex() {
+			const key = UNDERSCORE + MODE_IGNORE;
+			if (this[key]) return this[key];
+			return this._make(MODE_IGNORE, key);
+		}
+		get checkRegex() {
+			const key = UNDERSCORE + MODE_CHECK_IGNORE;
+			if (this[key]) return this[key];
+			return this._make(MODE_CHECK_IGNORE, key);
+		}
+		_make(mode, key) {
+			const str = pinWildcards(mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix));
+			const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+			return define(this, key, regex);
+		}
+	};
+	const isLineEnd = (char) => char === "\r" || char === "\n";
+	const trimEnd = (body) => {
+		let end = body.length;
+		while (end && isLineEnd(body[end - 1])) end--;
+		const lineEnd = end;
+		while (end && body[end - 1] === SPACE) end--;
+		if (end === lineEnd) return body.slice(0, end);
+		let backslashes = 0;
+		while (backslashes < end && body[end - backslashes - 1] === ESCAPE) backslashes++;
+		return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+	};
+	const createRule = ({ pattern, mark }, ignoreCase) => {
+		let body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+		if (body[0] === "#") return;
+		let negative = false;
+		if (body[0] === "!") {
+			negative = true;
+			body = body.slice(1);
+		}
+		const last = body[body.length - 1];
+		if (last === SPACE || last === "\r" || last === "\n") body = trimEnd(body);
+		if (!body) return;
+		body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+		const regexPrefix = makeRegexPrefix(body);
+		return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+	};
+	var RuleManager = class {
+		constructor(ignoreCase) {
+			this._ignoreCase = ignoreCase;
+			this._rules = [];
+			this._basenameCount = 0;
+		}
+		_add(pattern) {
+			if (pattern && pattern[KEY_IGNORE]) {
+				this._rules = this._rules.concat(pattern._rules._rules);
+				this._basenameCount += pattern._rules._basenameCount;
+				this._added = true;
+				return;
+			}
+			if (isString(pattern)) pattern = { pattern };
+			const rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+			if (rule) {
+				this._added = true;
+				this._rules.push(rule);
+				if (matchesBasename(rule.body)) this._basenameCount++;
+			}
+		}
+		add(pattern) {
+			this._added = false;
+			makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+			if (this._added) this._literalRules = UNDEFINED;
+			return this._added;
+		}
+		testLiteral(path$2) {
+			const rules = this._literalRules || (this._literalRules = this._rules.filter(({ body }) => body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === "*"));
+			let ignored = false;
+			let unignored = false;
+			let matchedRule;
+			for (let index = rules.length - 1; index >= 0; index--) {
+				const rule = rules[index];
+				if (rule.checkRegex.test(path$2)) {
+					ignored = !rule.negative;
+					unignored = rule.negative;
+					matchedRule = rule.negative ? UNDEFINED : rule;
+					break;
+				}
+			}
+			const ret = {
+				ignored,
+				unignored
+			};
+			if (matchedRule) ret.rule = matchedRule;
+			return ret;
+		}
+		test(path$2, checkUnignored, mode) {
+			let ignored = false;
+			let unignored = false;
+			let matchedRule;
+			const rules = this._rules;
+			const { length } = rules;
+			const shortcut = this._basenameCount * 2 >= length;
+			const basename = shortcut ? basenameOf(path$2) : path$2;
+			for (let index = 0; index < length; index++) {
+				const rule = rules[index];
+				const { negative } = rule;
+				if (!(unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) && rule[mode].test(shortcut && rule._basenameOnly ? basename : path$2)) {
+					ignored = !negative;
+					unignored = negative;
+					matchedRule = negative ? UNDEFINED : rule;
+				}
+			}
+			const ret = {
+				ignored,
+				unignored
+			};
+			if (matchedRule) ret.rule = matchedRule;
+			return ret;
+		}
+	};
+	const throwError = (message, Ctor) => {
+		throw new Ctor(message);
+	};
+	const checkPath = (path$2, originalPath, doThrow) => {
+		if (!isString(path$2)) return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+		if (!path$2) return doThrow(`path must not be empty`, TypeError);
+		if (checkPath.isNotRelative(path$2)) return doThrow(`path should be a \`path.relative()\`d string, but got "${originalPath}"`, RangeError);
+		return true;
+	};
+	const isNotRelative = (path$2) => {
+		const first = path$2.charCodeAt(0);
+		if (first === SLASH_CODE) return true;
+		if (first !== DOT_CODE) return false;
+		if (path$2.length === 1) return true;
+		const second = path$2.charCodeAt(1);
+		if (second === SLASH_CODE) return true;
+		if (second !== DOT_CODE) return false;
+		return path$2.length === 2 || path$2.charCodeAt(2) === SLASH_CODE;
+	};
+	checkPath.isNotRelative = isNotRelative;
+	/* istanbul ignore next */
+	checkPath.convert = (p) => p;
+	var Ignore = class {
+		constructor({ ignorecase = true, ignoreCase = ignorecase, allowRelativePaths = false } = {}) {
+			define(this, KEY_IGNORE, true);
+			this._rules = new RuleManager(ignoreCase);
+			this._strictPathCheck = !allowRelativePaths;
+			this._initCache();
+		}
+		_initCache() {
+			this._ignoreCache = Object.create(null);
+			this._testCache = Object.create(null);
+		}
+		add(pattern) {
+			if (this._rules.add(pattern)) this._initCache();
+			return this;
+		}
+		addPattern(pattern) {
+			return this.add(pattern);
+		}
+		_test(originalPath, cache, checkUnignored) {
+			const path$2 = originalPath && checkPath.convert(originalPath);
+			checkPath(path$2, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+			return this._t(path$2, cache, checkUnignored);
+		}
+		checkIgnore(path$2) {
+			if (path$2.charCodeAt(path$2.length - 1) !== SLASH_CODE) return this.test(path$2);
+			const dir = this._t(path$2, this._testCache, true);
+			if (dir.ignored) return dir;
+			const literal = this._rules.testLiteral(path$2);
+			return literal.ignored || literal.unignored ? literal : dir;
+		}
+		_t(path$2, cache, checkUnignored) {
+			if (path$2 in cache) return cache[path$2];
+			const parentPath = parentOf(path$2);
+			const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+			return cache[path$2] = parent && parent.ignored ? parent : this._rules.test(path$2, checkUnignored, MODE_IGNORE);
+		}
+		ignores(path$2) {
+			return this._test(path$2, this._ignoreCache, false).ignored;
+		}
+		createFilter() {
+			return (path$2) => !this.ignores(path$2);
+		}
+		filter(paths) {
+			return makeArray(paths).filter(this.createFilter());
+		}
+		test(path$2) {
+			return this._test(path$2, this._testCache, true);
+		}
+	};
+	const factory = (options) => new Ignore(options);
+	const isPathValid = (path$2) => checkPath(path$2 && checkPath.convert(path$2), path$2, RETURN_FALSE);
+	/* istanbul ignore next */
+	const setupWindows = () => {
+		const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+		checkPath.convert = makePosix;
+		const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+		checkPath.isNotRelative = (path$2) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path$2) || isNotRelative(path$2);
+	};
+	/* istanbul ignore next */
+	if (typeof process !== "undefined" && process.platform === "win32") setupWindows();
+	module.exports = factory;
+	factory.default = factory;
+	module.exports.isPathValid = isPathValid;
+	define(module.exports, Symbol.for("setupWindows"), setupWindows);
+}) });
 
+//#endregion
+//#region src/devices/ast/walker.ts
+var import_ignore = /* @__PURE__ */ __toESM(require_ignore(), 1);
+const ALWAYS_SKIP = new Set(["node_modules", ".git"]);
+function ignoresFor(root) {
+	const ig = (0, import_ignore.default)();
+	let dir = root;
+	const chain = [];
+	for (;;) {
+		const gitignore = path$1.join(dir, ".gitignore");
+		try {
+			ig.add(readFileSync(gitignore, "utf8"));
+			chain.unshift(path$1.relative(root, dir) || ".");
+		} catch {}
+		const parent = path$1.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return ig;
+}
+function matchesGlob(root, abs, glob) {
+	if (glob === void 0) return true;
+	const rel$1 = path$1.relative(root, abs).split(path$1.sep).join("/");
+	const ig = (0, import_ignore.default)();
+	ig.add(glob.startsWith("!") ? glob : glob);
+	return ig.ignores(rel$1);
+}
+async function walkSources(root, options) {
+	const maxFiles = options.maxFiles ?? 1e3;
+	const ig = ignoresFor(root);
+	const out = [];
+	let limitReached = false;
+	const visit = (dir) => {
+		if (limitReached) return;
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+			if (limitReached) return;
+			if (entry.name.startsWith(".") || ALWAYS_SKIP.has(entry.name)) continue;
+			if (entry.name.startsWith(".")) continue;
+			const abs = path$1.join(dir, entry.name);
+			const relFromRoot = path$1.relative(root, abs);
+			if (relFromRoot && ig.ignores(relFromRoot.split(path$1.sep).join("/"))) continue;
+			if (entry.isDirectory()) {
+				visit(abs);
+				continue;
+			}
+			if (languageForPath(entry.name) === void 0) continue;
+			if (!matchesGlob(root, abs, options.glob)) continue;
+			if (out.length >= maxFiles) {
+				limitReached = true;
+				return;
+			}
+			out.push(abs);
+		}
+	};
+	try {
+		if (statSync(root).isFile()) out.push(root);
+		else visit(root);
+	} catch {}
+	return {
+		files: out.sort(),
+		limitReached
+	};
+}
+
+//#endregion
+//#region src/devices/ast/ast-device.ts
+/** Per-run cap on distinct scanned files (upstream `PI_MAX_AST_FILES` default). */
+const MAX_FILES = 1e3;
+/** Glob metacharacters that mark a path segment as a pattern (upstream `GLOB_PATH_CHARS`). */
+const GLOB_CHARS = /[*?[{]/;
+/** The working directory for relative paths: `ctx.cwd` when threaded through, else `process.cwd()`. */
+function ctxCwd(ctx) {
+	if (ctx !== null && typeof ctx === "object" && typeof ctx.cwd === "string") return ctx.cwd;
+	return process.cwd();
+}
+/** The cwd-relative POSIX display path for an absolute walked file. */
+function rel(file, cwd) {
+	return path$1.relative(cwd, file).split(path$1.sep).join("/");
+}
+/** A validated args object for a device call. */
+function argsRecord(args, device) {
+	if (args === null || typeof args !== "object" || Array.isArray(args)) throw new Error(`${device}: args must be a JSON object`);
+	return args;
+}
+/** A non-empty array of non-empty strings. */
+function stringArray(value, field, device) {
+	if (!Array.isArray(value) || value.length === 0) throw new Error(`${device}: \`${field}\` must be a non-empty array of strings`);
+	for (const entry of value) if (typeof entry !== "string" || entry.length === 0) throw new Error(`${device}: \`${field}\` entries must be non-empty strings`);
+	return value;
+}
+/** An optional boolean field. */
+function optionalBoolean(value, field, device) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "boolean") throw new Error(`${device}: \`${field}\` must be a boolean`);
+	return value;
+}
+/** An optional non-negative integer field. */
+function optionalCount(value, field, device) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new Error(`${device}: \`${field}\` must be a non-negative integer`);
+	return value;
+}
+/**
+* Resolve one `paths` entry against `cwd`. An existing literal file or
+* directory wins as-is (upstream `parseSearchPathPreferringLiteral`);
+* otherwise the entry splits at the first glob-ish segment into
+* `{basePath, glob}` (upstream `parseSearchPath`), so a recursive glob
+* under `src` scans `src` as the root with the double-star pattern as the
+* glob tail.
+*/
+function resolveTarget(entry, cwd) {
+	const absolute = path$1.resolve(cwd, entry);
+	try {
+		statSync(absolute);
+		return { root: absolute };
+	} catch {}
+	const normalized = entry.replace(/\\/g, "/");
+	const segments = normalized.split("/");
+	const globIndex = segments.findIndex((segment$1) => GLOB_CHARS.test(segment$1));
+	if (globIndex === -1) return { root: absolute };
+	const basePath = globIndex === 0 ? "." : segments.slice(0, globIndex).join("/");
+	const glob = globIndex === 0 ? normalized : segments.slice(globIndex).join("/");
+	return {
+		root: path$1.resolve(cwd, basePath),
+		glob
+	};
+}
+/** `ast_edit` — run the validated rewrite across every target, aggregating like upstream's `runAstEditTargets`. */
+async function executeAstEdit(args, ctx) {
+	await ensureLanguages();
+	const cwd = ctxCwd(ctx);
+	const record = argsRecord(args, "ast_edit");
+	const rawOps = record.ops;
+	if (!Array.isArray(rawOps) || rawOps.length === 0) throw new Error("ast_edit: `ops` must be a non-empty array of {pat, out} objects");
+	const rewrites = {};
+	const opIndexOf = /* @__PURE__ */ new Map();
+	rawOps.forEach((rawOp, index) => {
+		if (rawOp === null || typeof rawOp !== "object" || Array.isArray(rawOp)) throw new Error(`ast_edit: ops[${index}] must be a {pat, out} object`);
+		const op = rawOp;
+		if (typeof op.pat !== "string" || op.pat.length === 0) throw new Error(`ast_edit: ops[${index}].pat must be a non-empty pattern`);
+		if (typeof op.out !== "string") throw new Error(`ast_edit: ops[${index}].out must be a string`);
+		rewrites[op.pat] = op.out;
+		opIndexOf.set(op.pat, index);
+	});
+	const targets = stringArray(record.paths, "paths", "ast_edit").map((entry) => resolveTarget(entry, cwd));
+	const dryRun = optionalBoolean(record.dryRun, "dryRun", "ast_edit") ?? true;
+	const pathNotFound = targets.some((target) => !existsSync(target.root));
+	const changes = [];
+	const fileCounts = /* @__PURE__ */ new Map();
+	const parseErrors = [];
+	const patternErrors = [];
+	const patternErrorSeen = /* @__PURE__ */ new Set();
+	let overlapping = 0;
+	let totalReplacements = 0;
+	let filesSearched = 0;
+	let limitReached = false;
+	const applied = !dryRun;
+	for (const target of targets) {
+		const walked = await walkSources(target.root, {
+			glob: target.glob,
+			maxFiles: MAX_FILES
+		});
+		filesSearched += walked.files.length;
+		limitReached = limitReached || walked.limitReached;
+		for (const file of walked.files) {
+			const lang = languageForPath(file);
+			if (lang === void 0) continue;
+			if (!isLanguageAvailable(lang)) {
+				parseErrors.push(`${rel(file, cwd)}: language unavailable`);
+				continue;
+			}
+			let source;
+			try {
+				source = readFileSync(file, "utf8");
+			} catch {
+				continue;
+			}
+			const result = await editSource(source, lang, rewrites);
+			for (const [pattern, message] of Object.entries(result.patternErrors ?? {})) {
+				if (patternErrorSeen.has(pattern)) continue;
+				patternErrorSeen.add(pattern);
+				patternErrors.push(`pattern ${opIndexOf.get(pattern)} ("${pattern}"): ${message}`);
+			}
+			overlapping += result.overlapping;
+			if (result.parseErrorCount > 0) parseErrors.push(`${rel(file, cwd)}: ${result.parseErrorCount} parse error(s)`);
+			if (result.changes.length === 0) continue;
+			const display = rel(file, cwd);
+			changes.push(...result.changes.map((change) => ({
+				...change,
+				path: display
+			})));
+			fileCounts.set(display, (fileCounts.get(display) ?? 0) + result.totalReplacements);
+			totalReplacements += result.totalReplacements;
+			if (!dryRun) writeFileSync(file, result.rewritten, "utf8");
+		}
+	}
+	const fileChanges = [...fileCounts].map(([filePath, count]) => ({
+		path: filePath,
+		count
+	}));
+	return {
+		changes,
+		fileChanges,
+		totalReplacements,
+		filesTouched: fileChanges.length,
+		filesSearched,
+		applied,
+		limitReached,
+		...parseErrors.length > 0 ? { parseErrors } : {},
+		...patternErrors.length > 0 ? { patternErrors } : {},
+		...overlapping > 0 ? { overlapping } : {},
+		...pathNotFound ? { pathNotFound: true } : {}
+	};
+}
+/** `ast_grep` — walk the target, run every pattern per file (OR), merge, then page. */
+async function executeAstGrep(args, ctx) {
+	await ensureLanguages();
+	const cwd = ctxCwd(ctx);
+	const record = argsRecord(args, "ast_grep");
+	const patterns = stringArray(record.patterns, "patterns", "ast_grep");
+	const rawPath = record.path;
+	if (rawPath !== void 0 && typeof rawPath !== "string") throw new Error("ast_grep: `path` must be a string");
+	const target = resolveTarget(rawPath !== void 0 && rawPath.length > 0 ? rawPath : ".", cwd);
+	const pathNotFound = !existsSync(target.root);
+	const offset = optionalCount(record.offset, "offset", "ast_grep");
+	const limit = optionalCount(record.limit, "limit", "ast_grep");
+	const includeMeta = optionalBoolean(record.includeMeta, "includeMeta", "ast_grep");
+	const walked = await walkSources(target.root, {
+		glob: target.glob,
+		maxFiles: MAX_FILES
+	});
+	const matches = [];
+	const parseErrors = [];
+	const patternErrors = [];
+	const patternErrorSeen = /* @__PURE__ */ new Set();
+	let filesWithMatches = 0;
+	for (const file of walked.files) {
+		const lang = languageForPath(file);
+		if (lang === void 0) continue;
+		if (!isLanguageAvailable(lang)) {
+			parseErrors.push(`${rel(file, cwd)}: language unavailable`);
+			continue;
+		}
+		let source;
+		try {
+			source = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		const perFile = [];
+		for (const [index, pattern] of patterns.entries()) {
+			const found = await findInSource(source, lang, pattern, { includeMeta });
+			if (found.patternError !== void 0 && !patternErrorSeen.has(index)) {
+				patternErrorSeen.add(index);
+				patternErrors.push(`pattern ${index} ("${pattern}"): ${found.patternError}`);
+			}
+			perFile.push(...found.matches);
+		}
+		if (perFile.length === 0) continue;
+		filesWithMatches += 1;
+		perFile.sort((a, b) => a.byteStart - b.byteStart || a.byteEnd - b.byteEnd);
+		matches.push(...perFile.map((match) => ({
+			...match,
+			path: rel(file, cwd)
+		})));
+	}
+	const totalMatches = matches.length;
+	const start = offset ?? 0;
+	const paged = matches.slice(start, start + (limit ?? Infinity));
+	return {
+		matches: paged,
+		totalMatches,
+		filesWithMatches,
+		filesSearched: walked.files.length,
+		limitReached: totalMatches > paged.length,
+		...parseErrors.length > 0 ? { parseErrors } : {},
+		...patternErrors.length > 0 ? { patternErrors } : {},
+		...pathNotFound ? { pathNotFound: true } : {}
+	};
+}
+/** Mount both ast devices on the registry (defaults to the real dvc registry). */
+function registerAstDevices(registry = { registerDvcDevice }) {
+	registry.registerDvcDevice("ast_edit", {
+		summary: summaries.ast_edit,
+		execute: executeAstEdit
+	});
+	registry.registerDvcDevice("ast_grep", {
+		summary: summaries.ast_grep,
+		execute: executeAstGrep
+	});
+}
+/** Roster summaries for the device nameplate — one line per device. */
+const summaries = {
+	ast_edit: "AST-aware structural rewrite: {ops: [{pat, out}], paths: string[], dryRun?: boolean} — ast-grep patterns; dryRun defaults true, set false to write files; performs no workspace boundary check (boundary is the approval/policy layer) and writes whatever paths it is given",
+	ast_grep: "AST pattern search: {patterns: string[], path?: string, offset?: number, limit?: number, includeMeta?: boolean} — returns structured matches with optional meta variables; performs no workspace boundary check (boundary is the approval/policy layer)"
+};
+
+//#endregion
 //#region src/vendor.ts
 /**
 * Plugin-owned vendor root: `<packageRoot>/.vendor`, beside the managed kernel
@@ -251,351 +1422,6 @@ function satisfies(version, range) {
 	return version === range;
 }
 
-//#endregion
-//#region src/devices/ast/natives-loader.ts
-/** Platform tags with a published leaf package (mirrors the upstream loader). */
-const SUPPORTED_PLATFORM_TAGS = [
-	"linux-x64",
-	"linux-arm64",
-	"darwin-x64",
-	"darwin-arm64",
-	"win32-x64"
-];
-/** The supported platform tag for the given (or current) platform/arch, or `undefined`. */
-function piNativesPlatformTag(platform = process.platform, arch = process.arch) {
-	const tag = `${platform}-${arch}`;
-	return SUPPORTED_PLATFORM_TAGS.includes(tag) ? tag : void 0;
-}
-/** The npm leaf-package name for the given (or current) platform, or `undefined`. */
-function piNativesPackageName(platform = process.platform, arch = process.arch) {
-	const tag = piNativesPlatformTag(platform, arch);
-	return tag === void 0 ? void 0 : `@oh-my-pi/pi-natives-${tag}`;
-}
-/**
-* Candidate addon filenames inside the leaf package, most-preferred first
-* (mirrors the upstream `getAddonFilenames`): x64 ships modern/baseline CPU
-* variants, other arches a single default binary.
-*/
-function piNativesAddonFilenames(tag, arch, preferModern = true) {
-	const defaultFilename = `pi_natives.${tag}.node`;
-	if (arch !== "x64") return [defaultFilename];
-	const baseline = `pi_natives.${tag}-baseline.node`;
-	const modern = `pi_natives.${tag}-modern.node`;
-	return preferModern ? [
-		modern,
-		baseline,
-		defaultFilename
-	] : [
-		baseline,
-		modern,
-		defaultFilename
-	];
-}
-/**
-* AVX2 probe for the modern/baseline choice on x64. Linux reads
-* `/proc/cpuinfo` (upstream does the same); darwin/win32 x64 assume modern —
-* effectively universal there — and a dlopen failure still falls through to
-* the baseline candidate.
-*/
-function detectAvx2(platform, arch) {
-	if (arch !== "x64") return false;
-	if (platform === "linux") try {
-		return /\bavx2\b/i.test(readFileSync("/proc/cpuinfo", "utf8"));
-	} catch {
-		return false;
-	}
-	return platform === "darwin" || platform === "win32";
-}
-const here = path$1.dirname(fileURLToPath(import.meta.url));
-/** `require` anchored at this module — used to dlopen absolute `.node` paths. */
-const requireHere = createRequire(import.meta.url);
-/**
-* Locate the leaf package directory with an explicit node_modules-walk upward
-* from `fromDir` — the ONLY mechanism. `require.resolve` is deliberately not
-* used here: its fallback through the process global paths (which include the
-* pnpm virtual-store hoist root `.pnpm/node_modules`) can resolve the leaf
-* package from ANY anchor, defeating the anchor-bounded contract this loader
-* guarantees for its degradation tests and unsupported-platform probes.
-* Returns `undefined` when absent.
-*/
-function findPackageDir(packageName, fromDir) {
-	let dir = fromDir;
-	for (;;) {
-		const candidate = path$1.join(dir, "node_modules", packageName);
-		if (existsSync(path$1.join(candidate, "package.json"))) return candidate;
-		const parent = path$1.dirname(dir);
-		if (parent === dir) return void 0;
-		dir = parent;
-	}
-}
-/**
-* Exact vendor-dir lookup. Deliberately NOT `findPackageDir`: that helper
-* walks `node_modules` upward, which from `<packageRoot>/.vendor` would escape
-* into the package's own (or the profile's) tree and defeat the anchor-bounded
-* contract this loader guarantees. The vendor root is flat by construction.
-*/
-function vendoredPackageDir(packageName) {
-	const candidate = path$1.join(VENDOR_ROOT, "node_modules", packageName);
-	return existsSync(path$1.join(candidate, "package.json")) ? candidate : void 0;
-}
-/** Pinned addon release; bumping it is an explicit, tested change. */
-const PI_NATIVES_VERSION = "18.0.6";
-/**
-* Make the platform addon available without touching any package manager:
-* a package already resolvable from `fromDir` (dev checkout, legacy install)
-* wins; otherwise the pinned leaf package is fetched into the plugin's vendor
-* directory. Never throws — failure leaves `loadPiNatives()` reporting the
-* addon as unavailable, which the device layer turns into a structured error.
-* @param options - platform/arch/anchor overrides, as in `loadPiNatives`.
-*/
-async function ensurePiNatives(options = {}) {
-	const packageName = piNativesPackageName(options.platform ?? process.platform, options.arch ?? process.arch);
-	if (packageName === void 0) return;
-	if (findPackageDir(packageName, options.fromDir ?? here) !== void 0) return;
-	if (options.fromDir !== void 0) return;
-	try {
-		await ensureVendored({
-			name: packageName,
-			version: PI_NATIVES_VERSION
-		}, VENDOR_ROOT);
-	} catch {}
-}
-/** Memoized default-args outcome: `undefined` = not attempted, `null` = attempted and unavailable. */
-let cachedDefaultLoad;
-/**
-* Load the pi-natives platform addon. Never throws: a missing package, an
-* unsupported platform, or a failed dlopen all resolve to `undefined` (the
-* next variant is tried first). Only default-args calls are memoized, so
-* option-bearing probes (tests) never pollute the cache.
-*/
-function loadPiNatives(options = {}) {
-	const isDefaultLoad = options.platform === void 0 && options.arch === void 0 && options.fromDir === void 0;
-	if (isDefaultLoad && cachedDefaultLoad !== void 0) return cachedDefaultLoad === null ? void 0 : cachedDefaultLoad;
-	const platform = options.platform ?? process.platform;
-	const arch = options.arch ?? process.arch;
-	const tag = piNativesPlatformTag(platform, arch);
-	if (tag === void 0) {
-		if (isDefaultLoad) cachedDefaultLoad = null;
-		return;
-	}
-	const packageName = `@oh-my-pi/pi-natives-${tag}`;
-	const packageDir = findPackageDir(packageName, options.fromDir ?? here) ?? (options.fromDir === void 0 ? vendoredPackageDir(packageName) : void 0);
-	if (packageDir === void 0) {
-		if (isDefaultLoad) cachedDefaultLoad = null;
-		return;
-	}
-	const preferModern = detectAvx2(platform, arch);
-	for (const filename of piNativesAddonFilenames(tag, arch, preferModern)) {
-		const addonPath = path$1.join(packageDir, filename);
-		if (!existsSync(addonPath)) continue;
-		try {
-			const bindings = requireHere(addonPath);
-			if (typeof bindings.astGrep !== "function" || typeof bindings.astEdit !== "function") continue;
-			const natives = {
-				astGrep: bindings.astGrep.bind(bindings),
-				astEdit: bindings.astEdit.bind(bindings)
-			};
-			if (isDefaultLoad) cachedDefaultLoad = natives;
-			return natives;
-		} catch {}
-	}
-	if (isDefaultLoad) cachedDefaultLoad = null;
-}
-
-//#endregion
-//#region src/devices/ast/ast-device.ts
-/** Per-run cap on distinct rewritten files (upstream `PI_MAX_AST_FILES` default). */
-const MAX_FILES = 1e3;
-/** Glob metacharacters that mark a path segment as a pattern (upstream `GLOB_PATH_CHARS`). */
-const GLOB_CHARS = /[*?[{]/;
-/**
-* Load the native bindings or fail the device call with an actionable
-* message — the dvc dispatcher wraps this into `DVC_DEVICE_ERROR`.
-*/
-async function nativesOrThrow() {
-	await ensurePiNatives();
-	const natives = loadPiNatives();
-	if (natives !== void 0) return natives;
-	const tag = piNativesPlatformTag();
-	throw new Error(tag === void 0 ? `pi-natives addon unavailable: platform ${process.platform}-${process.arch} has no published @oh-my-pi/pi-natives@18.0.6 binary` : `pi-natives addon unavailable: the plugin could not fetch @oh-my-pi/pi-natives-${tag}@18.0.6 into its own vendor dir (registry unreachable or blocked); retry with network access`);
-}
-/** The working directory for relative paths: `ctx.cwd` when threaded through, else `process.cwd()`. */
-function ctxCwd(ctx) {
-	if (ctx !== null && typeof ctx === "object" && typeof ctx.cwd === "string") return ctx.cwd;
-	return process.cwd();
-}
-/** A validated args object for a device call. */
-function argsRecord(args, device) {
-	if (args === null || typeof args !== "object" || Array.isArray(args)) throw new Error(`${device}: args must be a JSON object`);
-	return args;
-}
-/** A non-empty array of non-empty strings. */
-function stringArray(value, field, device) {
-	if (!Array.isArray(value) || value.length === 0) throw new Error(`${device}: \`${field}\` must be a non-empty array of strings`);
-	for (const entry of value) if (typeof entry !== "string" || entry.length === 0) throw new Error(`${device}: \`${field}\` entries must be non-empty strings`);
-	return value;
-}
-/** An optional boolean field. */
-function optionalBoolean(value, field, device) {
-	if (value === void 0) return void 0;
-	if (typeof value !== "boolean") throw new Error(`${device}: \`${field}\` must be a boolean`);
-	return value;
-}
-/** An optional non-negative integer field. */
-function optionalCount(value, field, device) {
-	if (value === void 0) return void 0;
-	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new Error(`${device}: \`${field}\` must be a non-negative integer`);
-	return value;
-}
-/**
-* Resolve one `paths` entry against `cwd`. An existing literal file or
-* directory wins as-is (upstream `parseSearchPathPreferringLiteral`);
-* otherwise the entry splits at the first glob-ish segment into
-* `{basePath, glob}` (upstream `parseSearchPath`), so a recursive glob
-* under `src` scans `src` as the root with the double-star pattern as the
-* glob tail. For file targets the native reports paths relative to the
-* file's directory, so `rebaseBase` tracks that.
-*/
-function resolveTarget(entry, cwd) {
-	const absolute = path$1.resolve(cwd, entry);
-	try {
-		return statSync(absolute).isFile() ? {
-			root: absolute,
-			rebaseBase: path$1.dirname(absolute)
-		} : {
-			root: absolute,
-			rebaseBase: absolute
-		};
-	} catch {}
-	const normalized = entry.replace(/\\/g, "/");
-	const segments = normalized.split("/");
-	const globIndex = segments.findIndex((segment$1) => GLOB_CHARS.test(segment$1));
-	if (globIndex === -1) return {
-		root: absolute,
-		rebaseBase: absolute
-	};
-	const basePath = globIndex === 0 ? "." : segments.slice(0, globIndex).join("/");
-	const glob = globIndex === 0 ? normalized : segments.slice(globIndex).join("/");
-	const root = path$1.resolve(cwd, basePath);
-	return {
-		root,
-		glob,
-		rebaseBase: root
-	};
-}
-/** Rebase a native-reported file path (relative to the target) to a cwd-relative POSIX path. */
-function rebaseNativePath(filePath, target, cwd) {
-	const relative$1 = path$1.relative(cwd, path$1.resolve(target.rebaseBase, filePath));
-	return (relative$1 === "" ? "." : relative$1).split(path$1.sep).join("/");
-}
-/** `ast_edit` — run the validated rewrite across every target, aggregating like upstream's `runAstEditTargets`. */
-async function executeAstEdit(args, ctx) {
-	const natives = await nativesOrThrow();
-	const cwd = ctxCwd(ctx);
-	const record = argsRecord(args, "ast_edit");
-	const rawOps = record.ops;
-	if (!Array.isArray(rawOps) || rawOps.length === 0) throw new Error("ast_edit: `ops` must be a non-empty array of {pat, out} objects");
-	const rewrites = {};
-	rawOps.forEach((rawOp, index) => {
-		if (rawOp === null || typeof rawOp !== "object" || Array.isArray(rawOp)) throw new Error(`ast_edit: ops[${index}] must be a {pat, out} object`);
-		const op = rawOp;
-		if (typeof op.pat !== "string" || op.pat.length === 0) throw new Error(`ast_edit: ops[${index}].pat must be a non-empty pattern`);
-		if (typeof op.out !== "string") throw new Error(`ast_edit: ops[${index}].out must be a string`);
-		rewrites[op.pat] = op.out;
-	});
-	const targets = stringArray(record.paths, "paths", "ast_edit").map((entry) => resolveTarget(entry, cwd));
-	const dryRun = optionalBoolean(record.dryRun, "dryRun", "ast_edit") ?? true;
-	const changes = [];
-	const fileCounts = /* @__PURE__ */ new Map();
-	const parseErrors = [];
-	let totalReplacements = 0;
-	let filesSearched = 0;
-	let limitReached = false;
-	let applied = !dryRun;
-	for (const target of targets) {
-		const result = await natives.astEdit({
-			rewrites,
-			path: target.root,
-			glob: target.glob,
-			dryRun,
-			maxFiles: MAX_FILES,
-			failOnParseError: false
-		});
-		totalReplacements += result.totalReplacements;
-		filesSearched += result.filesSearched;
-		limitReached = limitReached || result.limitReached;
-		applied = applied && result.applied;
-		if (result.parseErrors !== void 0) parseErrors.push(...result.parseErrors);
-		for (const change of result.changes) changes.push({
-			...change,
-			path: rebaseNativePath(change.path, target, cwd)
-		});
-		for (const fileChange of result.fileChanges) {
-			const rebased = rebaseNativePath(fileChange.path, target, cwd);
-			fileCounts.set(rebased, (fileCounts.get(rebased) ?? 0) + fileChange.count);
-		}
-	}
-	const fileChanges = [...fileCounts].map(([filePath, count]) => ({
-		path: filePath,
-		count
-	}));
-	return {
-		changes,
-		fileChanges,
-		totalReplacements,
-		filesTouched: fileChanges.length,
-		filesSearched,
-		applied,
-		limitReached,
-		...parseErrors.length > 0 ? { parseErrors } : {}
-	};
-}
-/** `ast_grep` — pass patterns/path/offset/limit/includeMeta straight to the native, rebase match paths. */
-async function executeAstGrep(args, ctx) {
-	const natives = await nativesOrThrow();
-	const cwd = ctxCwd(ctx);
-	const record = argsRecord(args, "ast_grep");
-	const patterns = stringArray(record.patterns, "patterns", "ast_grep");
-	const rawPath = record.path;
-	if (rawPath !== void 0 && typeof rawPath !== "string") throw new Error("ast_grep: `path` must be a string");
-	const target = resolveTarget(rawPath !== void 0 && rawPath.length > 0 ? rawPath : ".", cwd);
-	const offset = optionalCount(record.offset, "offset", "ast_grep");
-	const limit = optionalCount(record.limit, "limit", "ast_grep");
-	const includeMeta = optionalBoolean(record.includeMeta, "includeMeta", "ast_grep");
-	const result = await natives.astGrep({
-		patterns,
-		path: target.root,
-		...target.glob !== void 0 ? { glob: target.glob } : {},
-		...offset !== void 0 ? { offset } : {},
-		...limit !== void 0 ? { limit } : {},
-		...includeMeta !== void 0 ? { includeMeta } : {}
-	});
-	const matches = result.matches.map((match) => ({
-		...match,
-		path: rebaseNativePath(match.path, target, cwd)
-	}));
-	return {
-		...result,
-		matches
-	};
-}
-/** Mount both ast devices on the registry (defaults to the real dvc registry). */
-function registerAstDevices(registry = { registerDvcDevice }) {
-	registry.registerDvcDevice("ast_edit", {
-		summary: summaries.ast_edit,
-		execute: executeAstEdit
-	});
-	registry.registerDvcDevice("ast_grep", {
-		summary: summaries.ast_grep,
-		execute: executeAstGrep
-	});
-}
-/** Roster summaries for the device nameplate — one line per device. */
-const summaries = {
-	ast_edit: "AST-aware structural rewrite: {ops: [{pat, out}], paths: string[], dryRun?: boolean} — ast-grep patterns; dryRun defaults true, set false to write files",
-	ast_grep: "AST pattern search: {patterns: string[], path?: string, offset?: number, limit?: number, includeMeta?: boolean} — returns structured matches with optional meta variables"
-};
-
 //#endregion
 //#region src/devices/browser/browser-device.ts
 let puppeteerModule;
@@ -609,7 +1435,7 @@ const PUPPETEER_CORE_VERSION = "25.3.0";
 */
 async function loadPuppeteer() {
 	if (puppeteerModule === void 0) try {
-		puppeteerModule = await import("../puppeteer-core-BIIJGWPE.js");
+		puppeteerModule = await import("../puppeteer-core-Bliv_vNf.js");
 	} catch {
 		try {
 			puppeteerModule = await import(pathToFileURL((await ensureVendored({
@@ -1674,7 +2500,7 @@ function ensureMustHave(gate, language) {
 	if (!MUST_HAVE.has(language) || gate.installTried.has(language)) return;
 	gate.installTried.add(language);
 	(async () => {
-		const registry = await import("../lsp-server-registry-LUjrrLxk.js");
+		const registry = await import("../lsp-server-registry-BcdkHROD.js");
 		const probePath = `/tmp/x.${language === "python" ? "py" : "ts"}`;
 		const primary = registry.primaryServerForFile(probePath);
 		if (primary === null) return;
@@ -2363,7 +3189,7 @@ async function lspDeviceRead(subpath, session) {
 	if (parsed === void 0) return `unknown read path dvc://lsp/${subpath} — reads: status | diagnostics?file=…[&all=1] | definition?file=&line=[&character=|&symbol=] | references?… | hover?…`;
 	if (parsed.action === "status") {
 		const availability = {};
-		const registry = await import("../lsp-server-registry-LUjrrLxk.js");
+		const registry = await import("../lsp-server-registry-BcdkHROD.js");
 		for (const language of [
 			"python",
 			"typescript",
@@ -2419,35 +3245,11 @@ function installLspDevices(registry = registerDvcDevice) {
 //#endregion
 //#region src/devices/ast/ast-reminder.ts
 /**
-* AST-capable extension set — empirically probed against the shipped
-* pi-natives binary (2026-09-27): grouped by grammar family. TS family and
-* header files ride the same grammars as their proven siblings.
+* AST-capable extension set —— 从引擎的语言面**派生**（spec：单一真相源）。
+* 2026-09-27 那版是对 shipped 二进制逐扩展实测的快照；引擎内置后两者必然
+* 一致，不再人工维护第二份。
 */
-const AST_CODE_EXTENSIONS = new Set([
-	".py",
-	".pyi",
-	".js",
-	".jsx",
-	".mjs",
-	".cjs",
-	".ts",
-	".tsx",
-	".mts",
-	".cts",
-	".rs",
-	".go",
-	".c",
-	".cpp",
-	".h",
-	".hpp",
-	".html",
-	".css",
-	".json",
-	".yaml",
-	".yml",
-	".sh",
-	".rb"
-]);
+const AST_CODE_EXTENSIONS = new Set(Object.keys(EXTENSION_TO_LANGUAGE));
 /** Reminders per agent session (user ruling 2026-09-27: five is enough). */
 const AST_REMINDER_CAP = 5;
 /** The one-line availability notice (single line, both dvc:// devices). */
@@ -3223,14 +4025,14 @@ const SECTION_FILE = "url-schemes-instruction.md";
 * when the package's own file is absent.
 */
 function loadSectionText() {
-	const here$1 = fileURLToPath(import.meta.url);
-	let dir = dirname(here$1);
+	const here = fileURLToPath(import.meta.url);
+	let dir = dirname(here);
 	for (;;) {
 		try {
 			return readFileSync(join(dir, SECTION_FILE), "utf8");
 		} catch {}
 		const parent = dirname(dir);
-		if (parent === dir) throw new Error(`${SECTION_FILE} not found from ${here$1} — it must ship with the package (package.json "files")`);
+		if (parent === dir) throw new Error(`${SECTION_FILE} not found from ${here} — it must ship with the package (package.json "files")`);
 		dir = parent;
 	}
 }
@@ -3263,8 +4065,8 @@ function splitSkillPath(path$2) {
 /** Join `subpath` under the skill's resource directory, rejecting escapes. */
 function resolveResourcePath(baseDir, subpath) {
 	const full = join(baseDir, subpath);
-	const rel = relative(baseDir, full);
-	if (rel === "" || rel === ".." || rel.startsWith("../")) throw new UrlSchemesError("URL_SKILL_RESOURCE_ESCAPE", `skill resource path "${subpath}" escapes its directory`);
+	const rel$1 = relative(baseDir, full);
+	if (rel$1 === "" || rel$1 === ".." || rel$1.startsWith("../")) throw new UrlSchemesError("URL_SKILL_RESOURCE_ESCAPE", `skill resource path "${subpath}" escapes its directory`);
 	return full;
 }
 /**
@@ -11407,10 +12209,10 @@ function apply(ctx, config) {
 	installLspDevices();
 	const httpHandler = createHttpHandler();
 	for (const scheme of HTTP_SCHEMES) resolver.register(scheme, httpHandler);
-	const registered = /* @__PURE__ */ new WeakSet();
+	const registered$1 = /* @__PURE__ */ new WeakSet();
 	ctx.on("agent/created", ({ agent }) => {
-		if (registered.has(agent)) return void 0;
-		registered.add(agent);
+		if (registered$1.has(agent)) return void 0;
+		registered$1.add(agent);
 		installAgentTools(ctx, agent, resolver, resolveGates(config)).catch((error) => {
 			ctx.logger("dsh-url-schemes").warn(`failed to install URL-aware tools for agent ${agent.id}: ${error instanceof Error ? error.message : String(error)}`);
 		});