vde-open 0.1.0 → 0.1.2

package/dist/{main-lxBamyBU.js → main-CqENdUsw.js}

@@ -1,22 +1,24 @@
 import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DC62tzP2.js";
-import { $ as literal, A as successEnvelope, B as readParamsSchema, C as VdeError, D as ExitCode, E as isVdeError, F as htmlModeChangeParamsSchema, G as sha256Schema, H as reorderParamsSchema, I as htmlModeSchema, J as watchRuleSchema, K as sourceKindSchema, L as linkOpenParamsSchema, M as closeParamsSchema, N as documentFormatSchema, P as documentIdSchema, Q as boolean, R as listParamsSchema, S as validateAnswers, U as revisionSchema, V as renderGrantParamsSchema, W as searchParamsSchema, X as _enum, Y as LIMITS, Z as array, _ as feedbackWaitParamsSchema, a as uniqueTokens, at as canonicalJson, b as submissionSchema, c as feedbackAckParamsSchema, d as feedbackDraftParamsSchema, et as number, f as feedbackForgetParamsSchema, g as feedbackSubmitParamsSchema, h as feedbackStatusSchema, i as codePointLength, it as ZodError, j as assetRecordSchema, k as errorEnvelope, l as feedbackCancelParamsSchema, m as feedbackListParamsSchema, n as batchesOf, nt as strictObject, o as answersSchema, p as feedbackIdParamsSchema, q as sourceStateSchema, r as partsOf, rt as string, s as cancellationSchema, tt as record, u as feedbackCreateParamsSchema, v as questionnaireSchema, w as exitCodeForError, x as utf8Length, y as requestIdSchema, z as openParamsSchema } from "./search-index-C0szMSlZ.js";
-import { a as analyzeDocument, c as classifyReference, d as hasHiddenSegment, f as isValidLogicalPath, i as ParseLimitError, l as dirnameOfLogicalPath, n as scanReferences, o as assetTypeOf, p as roleAllowed, r as extractTitle, s as classifyLink, u as encodeLogicalPath } from "./render-yCayIbhf.js";
-import { t as measureHeap } from "./heap-Dev_gSQn.js";
+import { $ as literal, A as successEnvelope, B as readParamsSchema, C as VdeError, D as ExitCode, E as isVdeError, F as htmlModeChangeParamsSchema, G as sha256Schema, H as reorderParamsSchema, I as htmlModeSchema, J as watchRuleSchema, K as sourceKindSchema, L as linkOpenParamsSchema, M as closeParamsSchema, N as documentFormatSchema, P as documentIdSchema, Q as boolean, R as listParamsSchema, S as validateAnswers, U as revisionSchema, V as renderGrantParamsSchema, W as searchParamsSchema, X as _enum, Y as LIMITS, Z as array, _ as feedbackWaitParamsSchema, a as uniqueTokens, at as canonicalJson, b as submissionSchema, c as feedbackAckParamsSchema, d as feedbackDraftParamsSchema, et as number, f as feedbackForgetParamsSchema, g as feedbackSubmitParamsSchema, h as feedbackStatusSchema, i as codePointLength, it as ZodError, j as assetRecordSchema, k as errorEnvelope, l as feedbackCancelParamsSchema, m as feedbackListParamsSchema, n as batchesOf, nt as strictObject, o as answersSchema, p as feedbackIdParamsSchema, q as sourceStateSchema, r as partsOf, rt as string, s as cancellationSchema, tt as record, u as feedbackCreateParamsSchema, v as questionnaireSchema, w as exitCodeForError, x as utf8Length, y as requestIdSchema, z as openParamsSchema } from "./search-index-__laOomT.js";
+import { a as analyzeDocument, c as classifyReference, d as hasHiddenSegment, f as isValidLogicalPath, i as ParseLimitError, l as dirnameOfLogicalPath, n as scanReferences, o as assetTypeOf, p as roleAllowed, r as extractTitle, s as classifyLink, u as encodeLogicalPath } from "./render-BNZz0CjQ.js";
+import { n as measureHeap, t as collectGarbage } from "./heap-C3qHm7SE.js";
 import { constants, existsSync, stat, unwatchFile, watch, watchFile } from "node:fs";
-import { appendFile, chmod, link, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, rmdir, stat as stat$1, writeFile } from "node:fs/promises";
+import { appendFile, chmod, link, lstat, mkdir, open, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat as stat$1, writeFile } from "node:fs/promises";
 import * as sp from "node:path";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { EventEmitter } from "node:events";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import * as nativeFs from "fs";
 import { readdir as readdir$1, readdirSync, realpath as realpath$1, realpathSync, stat as stat$2, statSync } from "fs";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, normalize, posix, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, normalize, posix as posix$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
 import { fileURLToPath as fileURLToPath$1 } from "node:url";
 import { Worker } from "node:worker_threads";
+import { performance } from "node:perf_hooks";
+import { getHeapStatistics } from "node:v8";
 import { STATUS_CODES, ServerResponse, createServer } from "node:http";
 import { Http2ServerRequest, constants as constants$1 } from "node:http2";
 import { Readable } from "node:stream";
@@ -152,7 +154,7 @@ function parseStrictJson(text) {
 }
 //#endregion
 //#region package.json
-var version = "0.1.0";
+var version = "0.1.2";
 //#endregion
 //#region src/documents/cursor.ts
 function invalidCursor(reason) {
@@ -184,7 +186,7 @@ function createCursorCodec(secret, now = Date.now) {
 //#endregion
 //#region ../../packages/document/src/profiles.ts
 const MARKDOWN_PARSER_PROFILE = "markdown-tanstack-v1";
-const HTML_STATIC_PARSER_PROFILE = "html-static-v1";
+const HTML_STATIC_PARSER_PROFILE = "html-static-v2";
 //#endregion
 //#region ../../packages/document/src/source-lines.ts
 const LF = 10;
@@ -3150,8 +3152,8 @@ function buildFormat(cwd, root, absolute) {
 		};
 		return (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
 	}
-	if (absolute) return (p) => posix.relative(cwd, p) || ".";
-	return (p) => posix.relative(cwd, `${root}/${p}`) || ".";
+	if (absolute) return (p) => posix$1.relative(cwd, p) || ".";
+	return (p) => posix$1.relative(cwd, `${root}/${p}`) || ".";
 }
 function buildRelative(cwd, root) {
 	if (root.startsWith(`${cwd}/`)) {
@@ -3159,7 +3161,7 @@ function buildRelative(cwd, root) {
 		return (p) => `${prefix}/${p}`;
 	}
 	return (p) => {
-		const result = posix.relative(cwd, `${root}/${p}`);
+		const result = posix$1.relative(cwd, `${root}/${p}`);
 		return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
 	};
 }
@@ -3214,7 +3216,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
 	if (pattern[pattern.length - 1] === "/") result = pattern.slice(0, -1);
 	if (result[result.length - 1] !== "*" && opts.expandDirectories) result += "/**";
 	const escapedCwd = escapePath(cwd);
-	result = isAbsolute$1(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+	result = isAbsolute$1(result.replace(ESCAPING_BACKSLASHES, "")) ? posix$1.relative(escapedCwd, result) : posix$1.normalize(result);
 	const parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0];
 	const parts = splitPattern(result);
 	if (parentDir) {
@@ -3225,7 +3227,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
 			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
 			i++;
 		}
-		const potentialRoot = posix.join(cwd, parentDir.slice(i * 3));
+		const potentialRoot = posix$1.join(cwd, parentDir.slice(i * 3));
 		if (potentialRoot[0] !== "." && props.root.length > potentialRoot.length) {
 			props.root = ensureNonDriveRelativePath(potentialRoot);
 			props.depthOffset = -n + i;
@@ -3247,7 +3249,7 @@ function normalizePattern(pattern, opts, props, isIgnore) {
 		}
 		props.depthOffset = newCommonPath.length;
 		props.commonPath = newCommonPath;
-		props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd);
+		props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix$1.join(cwd, ...newCommonPath) : cwd);
 	}
 	return result;
 }
@@ -3513,6 +3515,550 @@ function isExcludedDirectoryName(name) {
 	return isHidden(name) || EXCLUDED_DIRECTORIES.has(name);
 }
 //#endregion
+//#region src/documents/repository.ts
+const METADATA_LIMIT = 4096;
+function kindOf(stats) {
+	if (stats.isSymbolicLink()) return "symlink";
+	if (stats.isFile()) return "file";
+	if (stats.isDirectory()) return "directory";
+	return "other";
+}
+function notRegularFile(path) {
+	return Object.assign(/* @__PURE__ */ new Error(`${path} is not a regular file.`), { code: "EFTYPE" });
+}
+const nodeRepositoryFs = {
+	lstat: async (path) => kindOf(await lstat(path)),
+	stat: async (path) => kindOf(await stat$1(path)),
+	readlink: (path) => readlink(path),
+	realpath: (path) => realpath(path),
+	readSmall: async (path, limit) => {
+		const before = await lstat(path);
+		if (!before.isFile()) throw notRegularFile(path);
+		const handle = await open(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+		try {
+			const opened = await handle.stat();
+			if (!opened.isFile() || opened.ino !== before.ino || opened.dev !== before.dev) throw notRegularFile(path);
+			return await readBounded(handle, limit);
+		} finally {
+			await handle.close();
+		}
+	}
+};
+function createLimiter(limit) {
+	let active = 0;
+	const waiting = [];
+	return {
+		async run(work) {
+			if (active < limit) active += 1;
+			else await new Promise((resolveTurn) => waiting.push(resolveTurn));
+			try {
+				return await work();
+			} finally {
+				const next = waiting.shift();
+				if (next) next();
+				else active -= 1;
+			}
+		},
+		get active() {
+			return active;
+		}
+	};
+}
+function limitRepositoryFs(fs, limiter) {
+	return {
+		lstat: (path) => limiter.run(() => fs.lstat(path)),
+		stat: (path) => limiter.run(() => fs.stat(path)),
+		readlink: (path) => limiter.run(() => fs.readlink(path)),
+		realpath: (path) => limiter.run(() => fs.realpath(path)),
+		readSmall: (path, size) => limiter.run(() => fs.readSmall(path, size))
+	};
+}
+var Unresolved = class extends Error {
+	reason;
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+	}
+};
+function failureOf(error, invalid) {
+	if (error instanceof Unresolved) return error;
+	const code = error?.code;
+	if (code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP" || code === "EFTYPE") return new Unresolved(invalid);
+	return new Unresolved("unreadable");
+}
+const HEX_OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+const REFTABLE_HEAD = "refs/heads/.invalid";
+function isValidRefName(ref) {
+	if (ref === "@" || ref.endsWith("/") || ref.endsWith(".")) return false;
+	if (ref.includes("..") || ref.includes("@{") || ref.includes("//")) return false;
+	if (/[\u0000- \u007f~^:?*[\\]/.test(ref)) return false;
+	return ref.split("/").every((part) => part !== "" && !part.startsWith(".") && !part.endsWith(".lock"));
+}
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+function parseHead(bytes) {
+	const content = bytes.toString("latin1").replace(/\s+$/, "");
+	if (HEX_OBJECT_ID.test(content)) return null;
+	if (!content.startsWith("ref:")) throw new Unresolved("invalid-git-dir");
+	const ref = content.slice(4).replace(/^\s+/, "");
+	if (ref === REFTABLE_HEAD) return null;
+	if (!ref.startsWith("refs/") || !isValidRefName(ref)) throw new Unresolved("invalid-git-dir");
+	if (!ref.startsWith("refs/heads/")) return null;
+	try {
+		return utf8.decode(Buffer.from(ref.slice(11), "latin1"));
+	} catch {
+		return null;
+	}
+}
+function parseLinkFile(bytes, prefix, invalid) {
+	let content;
+	try {
+		content = utf8.decode(bytes);
+	} catch {
+		throw new Unresolved(invalid);
+	}
+	content = content.replace(/\r?\n$/, "");
+	if (!content.startsWith(prefix)) throw new Unresolved(invalid);
+	const path = content.slice(prefix.length);
+	if (path === "" || path.includes("\n") || path.includes("\0")) throw new Unresolved(invalid);
+	return path;
+}
+function createRepositoryDetector(options = {}) {
+	const fs = options.fs ?? nodeRepositoryFs;
+	const path = options.platform === "win32" ? win32 : posix;
+	const isWindows = options.platform === "win32";
+	const probes = /* @__PURE__ */ new Map();
+	const checkouts = /* @__PURE__ */ new Map();
+	const segmentsOf = (absolute) => absolute.split(path.sep).filter((part) => part !== "");
+	const relativeSegments = (from, to) => segmentsOf(path.relative(from, to));
+	const permits = (documentRoot, target) => {
+		if (!isWindows) return true;
+		const root = path.parse(target).root;
+		if (/^[A-Za-z]:[\\/]$/.test(root)) return true;
+		return root.toLowerCase() === documentRoot.toLowerCase();
+	};
+	const allowed = (documentRoot, target) => {
+		if (!permits(documentRoot, target)) throw new Unresolved("blocked-path");
+		return target;
+	};
+	const probe = (directory) => {
+		let pending = probes.get(directory);
+		if (!pending) {
+			pending = fs.lstat(path.join(directory, ".git")).then((kind) => kind, (error) => error.code === "ENOENT" || error.code === "ENOTDIR" ? "absent" : "error");
+			probes.set(directory, pending);
+		}
+		return pending;
+	};
+	const readMetadata = async (file, invalid) => {
+		let bytes;
+		try {
+			bytes = await fs.readSmall(file, METADATA_LIMIT);
+		} catch (error) {
+			throw failureOf(error, invalid);
+		}
+		if (bytes === null) throw new Unresolved("limit-exceeded");
+		return bytes;
+	};
+	const realpathOf = async (target, invalid) => {
+		try {
+			return await fs.realpath(target);
+		} catch (error) {
+			throw failureOf(error, invalid);
+		}
+	};
+	const expectDirectory = async (target) => {
+		let kind;
+		try {
+			kind = await fs.stat(target);
+		} catch (error) {
+			throw failureOf(error, "invalid-git-dir");
+		}
+		if (kind !== "directory") throw new Unresolved("invalid-git-dir");
+	};
+	const validated = /* @__PURE__ */ new Map();
+	const validateGitDir = (gitDir) => {
+		let pending = validated.get(gitDir);
+		if (!pending) {
+			pending = (async () => {
+				await expectDirectory(gitDir);
+				const branch = parseHead(await readMetadata(path.join(gitDir, "HEAD"), "invalid-git-dir"));
+				await expectDirectory(path.join(gitDir, "objects"));
+				await expectDirectory(path.join(gitDir, "refs"));
+				return branch;
+			})();
+			validated.set(gitDir, pending);
+		}
+		return pending;
+	};
+	const repositoryNameSegments = (commonDir) => {
+		const segments = segmentsOf(commonDir);
+		const last = segments.at(-1) ?? "";
+		if (last === ".git") return segments.slice(0, -1);
+		if (last.length > 4 && last.endsWith(".git")) return [...segments.slice(0, -1), last.slice(0, -4)];
+		return segments;
+	};
+	const standalone = (checkoutDir) => ({
+		state: "resolved",
+		id: checkoutDir,
+		nameSegments: segmentsOf(checkoutDir),
+		checkout: {
+			id: checkoutDir,
+			kind: "main"
+		}
+	});
+	const commonDirOf = async (gitDir, documentRoot) => {
+		try {
+			await fs.lstat(path.join(gitDir, "commondir"));
+		} catch (error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "ENOTDIR") return null;
+			throw failureOf(error, "invalid-git-file");
+		}
+		const written = parseLinkFile(await readMetadata(path.join(gitDir, "commondir"), "invalid-git-file"), "", "invalid-git-file");
+		return realpathOf(allowed(documentRoot, path.resolve(gitDir, written)), "invalid-git-dir");
+	};
+	const resolveGitFile = async (checkoutDir, gitFile, documentRoot) => {
+		const written = parseLinkFile(await readMetadata(gitFile, "invalid-git-file"), "gitdir: ", "invalid-git-file");
+		const gitDir = await realpathOf(allowed(documentRoot, path.resolve(checkoutDir, written)), "invalid-git-file");
+		const commonDir = await commonDirOf(gitDir, documentRoot);
+		if (commonDir === null) {
+			await validateGitDir(gitDir);
+			return standalone(checkoutDir);
+		}
+		await validateGitDir(commonDir);
+		if (path.dirname(gitDir) !== path.join(commonDir, "worktrees")) throw new Unresolved("link-mismatch");
+		const branch = parseHead(await readMetadata(path.join(gitDir, "HEAD"), "invalid-git-dir"));
+		const backWritten = parseLinkFile(await readMetadata(path.join(gitDir, "gitdir"), "link-mismatch"), "", "link-mismatch");
+		const back = allowed(documentRoot, path.resolve(gitDir, backWritten));
+		if (path.basename(back) !== ".git") throw new Unresolved("link-mismatch");
+		if (await realpathOf(path.dirname(back), "link-mismatch") !== checkoutDir) throw new Unresolved("link-mismatch");
+		return {
+			state: "resolved",
+			id: commonDir,
+			nameSegments: repositoryNameSegments(commonDir),
+			checkout: {
+				id: checkoutDir,
+				kind: "linked",
+				name: path.basename(gitDir),
+				branch
+			}
+		};
+	};
+	const resolveGitLink = async (checkoutDir, gitLink, documentRoot) => {
+		let target;
+		try {
+			target = allowed(documentRoot, path.resolve(checkoutDir, await fs.readlink(gitLink)));
+		} catch (error) {
+			throw failureOf(error, "invalid-git-dir");
+		}
+		let kind;
+		try {
+			kind = await fs.lstat(target);
+		} catch (error) {
+			throw failureOf(error, "invalid-git-dir");
+		}
+		if (kind === "directory") {
+			await validateGitDir(target);
+			return standalone(checkoutDir);
+		}
+		if (kind === "file") {
+			const written = parseLinkFile(await readMetadata(target, "invalid-git-file"), "gitdir: ", "invalid-git-file");
+			const gitDir = await realpathOf(allowed(documentRoot, path.resolve(checkoutDir, written)), "invalid-git-file");
+			const common = await commonDirOf(gitDir, documentRoot);
+			if (common === null) await validateGitDir(gitDir);
+			else {
+				await validateGitDir(common);
+				parseHead(await readMetadata(path.join(gitDir, "HEAD"), "invalid-git-dir"));
+			}
+			return standalone(checkoutDir);
+		}
+		throw new Unresolved("invalid-git-dir");
+	};
+	const resolveCheckout = (checkoutDir, kind, documentRoot) => {
+		let pending = checkouts.get(checkoutDir);
+		if (!pending) {
+			const gitEntry = path.join(checkoutDir, ".git");
+			const work = async () => {
+				if (kind === "directory") {
+					await validateGitDir(gitEntry);
+					return {
+						state: "resolved",
+						id: gitEntry,
+						nameSegments: repositoryNameSegments(gitEntry),
+						checkout: {
+							id: checkoutDir,
+							kind: "main"
+						}
+					};
+				}
+				if (kind === "file") return resolveGitFile(checkoutDir, gitEntry, documentRoot);
+				if (kind === "symlink") return resolveGitLink(checkoutDir, gitEntry, documentRoot);
+				throw new Unresolved("invalid-git-dir");
+			};
+			pending = work().catch((error) => ({
+				state: "unresolved",
+				reason: failureOf(error, "invalid-git-dir").reason
+			}));
+			checkouts.set(checkoutDir, pending);
+		}
+		return pending;
+	};
+	const detect = async (canonicalPath) => {
+		const documentRoot = path.parse(canonicalPath).root;
+		let directory = path.dirname(canonicalPath);
+		let kind;
+		for (;;) {
+			const found = await probe(directory);
+			if (found === "error") return {
+				state: "unresolved",
+				id: directory,
+				nameSegments: segmentsOf(directory),
+				pathInCheckout: relativeSegments(directory, canonicalPath),
+				reason: "unreadable"
+			};
+			if (found !== "absent") {
+				kind = found;
+				break;
+			}
+			const parent = path.dirname(directory);
+			if (parent === directory || directory === options.stopAt) return { state: "outside" };
+			directory = parent;
+		}
+		const gitEntry = path.join(directory, ".git");
+		if (kind === "directory" && canonicalPath.startsWith(gitEntry + path.sep)) {
+			try {
+				await validateGitDir(gitEntry);
+			} catch (error) {
+				return {
+					state: "unresolved",
+					id: directory,
+					nameSegments: segmentsOf(directory),
+					pathInCheckout: relativeSegments(directory, canonicalPath),
+					reason: failureOf(error, "invalid-git-dir").reason
+				};
+			}
+			return {
+				state: "resolved",
+				id: gitEntry,
+				nameSegments: repositoryNameSegments(gitEntry),
+				checkout: null,
+				pathInCheckout: relativeSegments(directory, canonicalPath)
+			};
+		}
+		const resolution = await resolveCheckout(directory, kind, documentRoot);
+		const pathInCheckout = relativeSegments(directory, canonicalPath);
+		if (resolution.state === "unresolved") return {
+			state: "unresolved",
+			id: directory,
+			nameSegments: segmentsOf(directory),
+			pathInCheckout,
+			reason: resolution.reason ?? "invalid-git-dir"
+		};
+		return {
+			state: "resolved",
+			id: resolution.id,
+			nameSegments: resolution.nameSegments,
+			checkout: resolution.checkout,
+			pathInCheckout
+		};
+	};
+	return { detect };
+}
+function supersedes(current, sequence) {
+	return current === void 0 || current.sequence < sequence || current.sequence === sequence && current.value?.state === "pending";
+}
+var RepositoryTracker = class {
+	#fs;
+	#platform;
+	#limiter = createLimiter(2);
+	#stopAt;
+	#createDetector;
+	waitMs;
+	lateApplyMs;
+	lateApplyMaxMs;
+	#sequence = 0;
+	#documents = /* @__PURE__ */ new Map();
+	#checkouts = /* @__PURE__ */ new Map();
+	#members = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.#fs = limitRepositoryFs(options.fs ?? nodeRepositoryFs, this.#limiter);
+		this.#platform = options.platform ?? (process.platform === "win32" ? "win32" : "posix");
+		this.waitMs = options.waitMs ?? 2e3;
+		this.lateApplyMs = options.lateApplyMs ?? 250;
+		this.lateApplyMaxMs = options.lateApplyMaxMs ?? 1e3;
+		this.#stopAt = options.stopAt;
+		this.#createDetector = options.createDetector;
+	}
+	begin(paths) {
+		this.#sequence += 1;
+		const detector = this.#createDetector?.() ?? createRepositoryDetector({
+			fs: this.#fs,
+			platform: this.#platform,
+			...this.#stopAt === void 0 ? {} : { stopAt: this.#stopAt }
+		});
+		const results = /* @__PURE__ */ new Map();
+		const settled = /* @__PURE__ */ new Map();
+		const work = [...new Set(paths)].map((path) => {
+			const finished = detector.detect(path).then((detection) => {
+				results.set(path, detection);
+			}, () => {
+				results.set(path, {
+					state: "unresolved",
+					id: path,
+					nameSegments: [],
+					pathInCheckout: [],
+					reason: "unreadable"
+				});
+			});
+			settled.set(path, finished);
+			return finished;
+		});
+		return {
+			sequence: this.#sequence,
+			startedAt: Date.now(),
+			results,
+			done: Promise.all(work).then(() => void 0),
+			settled: (path) => settled.get(path) ?? Promise.resolve()
+		};
+	}
+	async wait(batch) {
+		const remaining = batch.startedAt + this.waitMs - Date.now();
+		if (remaining <= 0) return;
+		let timer;
+		await Promise.race([batch.done, new Promise((resolveTimeout) => {
+			timer = setTimeout(resolveTimeout, remaining);
+		})]);
+		clearTimeout(timer);
+	}
+	#compose(stored, checkouts = this.#checkouts) {
+		if (stored === void 0) return { state: "pending" };
+		if (stored.state === "outside") return null;
+		if (stored.state !== "resolved") return stored;
+		if (stored.checkoutId === null) {
+			const { checkoutId: _none, ...rest } = stored;
+			return {
+				...rest,
+				checkout: null
+			};
+		}
+		const entry = checkouts.get(stored.checkoutId);
+		if (entry === void 0) return { state: "pending" };
+		return {
+			state: "resolved",
+			id: entry.repositoryId,
+			nameSegments: entry.nameSegments,
+			checkout: entry.info,
+			pathInCheckout: stored.pathInCheckout
+		};
+	}
+	view(documentId) {
+		return this.#compose(this.#documents.get(documentId)?.value);
+	}
+	stage(batch, targets, options) {
+		const documents = /* @__PURE__ */ new Map();
+		const checkouts = /* @__PURE__ */ new Map();
+		const unfinished = [];
+		const appliesTo = (current) => supersedes(current, batch.sequence);
+		for (const target of targets) {
+			const current = this.#documents.get(target.documentId);
+			const detection = batch.results.get(target.path);
+			if (detection === void 0) {
+				unfinished.push(target);
+				if (options.pendingWhenUnfinished && current === void 0) documents.set(target.documentId, {
+					sequence: batch.sequence,
+					value: { state: "pending" }
+				});
+				continue;
+			}
+			if (!appliesTo(current)) continue;
+			let value;
+			if (detection.state === "resolved" && detection.checkout !== null) {
+				const { checkout } = detection;
+				value = {
+					state: "resolved",
+					checkoutId: checkout.id,
+					pathInCheckout: detection.pathInCheckout
+				};
+				if (appliesTo(this.#checkouts.get(checkout.id))) checkouts.set(checkout.id, {
+					sequence: batch.sequence,
+					info: checkout,
+					repositoryId: detection.id,
+					nameSegments: detection.nameSegments
+				});
+			} else if (detection.state === "resolved") {
+				const { checkout: _none, ...rest } = detection;
+				value = {
+					...rest,
+					checkoutId: null
+				};
+			} else value = detection;
+			documents.set(target.documentId, {
+				sequence: batch.sequence,
+				value
+			});
+		}
+		const merged = new Map(this.#checkouts);
+		for (const [id, entry] of checkouts) merged.set(id, entry);
+		const affected = new Set(documents.keys());
+		for (const id of checkouts.keys()) for (const member of this.#members.get(id) ?? []) affected.add(member);
+		let changed = false;
+		for (const documentId of affected) {
+			const before = this.view(documentId);
+			const after = this.#compose(documents.get(documentId)?.value ?? this.#documents.get(documentId)?.value, merged);
+			if (canonicalJson(before) !== canonicalJson(after)) {
+				changed = true;
+				break;
+			}
+		}
+		return {
+			changed,
+			unfinished,
+			documents,
+			checkouts
+		};
+	}
+	apply(staged) {
+		for (const [id, entry] of staged.checkouts) if (supersedes(this.#checkouts.get(id), entry.sequence)) this.#checkouts.set(id, entry);
+		for (const [documentId, entry] of staged.documents) {
+			const current = this.#documents.get(documentId);
+			if (entry.value.state === "pending" && current !== void 0) continue;
+			if (supersedes(current, entry.sequence)) this.#setDocument(documentId, entry);
+		}
+		this.#dropUnused();
+	}
+	#setDocument(documentId, entry) {
+		const before = this.#documents.get(documentId)?.value;
+		if (before?.state === "resolved" && before.checkoutId !== null) this.#members.get(before.checkoutId)?.delete(documentId);
+		this.#documents.set(documentId, entry);
+		if (entry.value.state === "resolved" && entry.value.checkoutId !== null) {
+			let members = this.#members.get(entry.value.checkoutId);
+			if (!members) {
+				members = /* @__PURE__ */ new Set();
+				this.#members.set(entry.value.checkoutId, members);
+			}
+			members.add(documentId);
+		}
+	}
+	forget(documentIds) {
+		for (const documentId of documentIds) {
+			const before = this.#documents.get(documentId)?.value;
+			if (before?.state === "resolved" && before.checkoutId !== null) this.#members.get(before.checkoutId)?.delete(documentId);
+			this.#documents.delete(documentId);
+		}
+		this.#dropUnused();
+	}
+	#dropUnused() {
+		for (const [id, members] of this.#members) if (members.size === 0) this.#members.delete(id);
+		for (const id of this.#checkouts.keys()) if (!this.#members.has(id)) this.#checkouts.delete(id);
+	}
+	retainedCounts() {
+		return {
+			repositoryDocuments: this.#documents.size,
+			repositoryCheckouts: this.#checkouts.size,
+			repositoryOperations: this.#limiter.active
+		};
+	}
+};
+//#endregion
 //#region src/documents/revision.ts
 function sha256Hex(bytes) {
 	return createHash("sha256").update(bytes).digest("hex");
@@ -3542,7 +4088,7 @@ const MISSING_RETRY_INTERVAL_MS = 100;
 function profileOf(format) {
 	return format === "markdown" ? MARKDOWN_PARSER_PROFILE : HTML_STATIC_PARSER_PROFILE;
 }
-function toSummary(record, order, searchState = "excluded", pendingRequestIds = [], interactiveAllowed = false) {
+function toSummary(record, order, searchState = "excluded", pendingRequestIds = [], interactiveAllowed = false, repository = null) {
 	return {
 		documentId: record.documentId,
 		key: record.key,
@@ -3551,6 +4097,8 @@ function toSummary(record, order, searchState = "excluded", pendingRequestIds =
 		title: record.title,
 		displayPath: record.displayPath,
 		pathSegments: record.pathSegments,
+		canonicalPath: record.sourceKind === "file" ? record.canonicalPath : null,
+		repository,
 		revision: record.currentRevision,
 		sourceState: record.sourceState,
 		searchState,
@@ -3625,6 +4173,7 @@ var DocumentService = class {
 	#interactive = /* @__PURE__ */ new Map();
 	#interactiveGenerations = 0;
 	#linkConfirmations = /* @__PURE__ */ new Map();
+	#repositories;
 	constructor(options) {
 		this.#store = options.store;
 		this.#cursors = options.cursors;
@@ -3634,6 +4183,68 @@ var DocumentService = class {
 		this.#readSource = options.readSource ?? readSourceFile;
 		this.#scan = options.scan ?? ((kind, text) => Promise.resolve(scanReferences(kind, text)));
 		this.#searchStateOf = options.searchStateOf ?? (() => "excluded");
+		this.#repositories = new RepositoryTracker(options.repositories);
+	}
+	async initializeRepositories() {
+		const state = this.#store.payload;
+		const targets = this.#trackedFiles(state, state.openOrder);
+		if (targets.length === 0) return;
+		const batch = this.#repositories.begin(targets.map((target) => target.path));
+		await this.#repositories.wait(batch);
+		const staged = this.#repositories.stage(batch, targets, { pendingWhenUnfinished: true });
+		this.#repositories.apply(staged);
+		this.#applyWhenDone(batch, staged.unfinished);
+	}
+	#trackedFiles(state, documentIds) {
+		const targets = [];
+		for (const documentId of documentIds) {
+			const record = state.documents[documentId];
+			if (record?.isOpen && record.sourceKind === "file" && record.canonicalPath !== null) targets.push({
+				documentId,
+				path: record.canonicalPath,
+				epoch: this.openEpoch(documentId)
+			});
+		}
+		return targets;
+	}
+	async #applyBatch(batch, targets) {
+		let staged = null;
+		await this.#store.transaction((tx) => {
+			const live = targets.filter((target) => tx.state.documents[target.documentId]?.isOpen === true && this.openEpoch(target.documentId) === target.epoch);
+			const next = this.#repositories.stage(batch, live, { pendingWhenUnfinished: false });
+			if (next.changed) tx.state.catalogVersion += 1;
+			staged = next;
+		});
+		const applied = staged;
+		if (applied === null) return [];
+		this.#repositories.apply(applied);
+		if (applied.changed) this.#emit({ type: "catalog-changed" });
+		return applied.unfinished;
+	}
+	#applyWhenDone(batch, targets) {
+		if (targets.length === 0) return;
+		let ready = [];
+		let timer = null;
+		let delay = this.#repositories.lateApplyMs;
+		const flush = () => {
+			timer = null;
+			const now = ready;
+			ready = [];
+			delay = Math.min(delay * 2, this.#repositories.lateApplyMaxMs);
+			this.#applyBatch(batch, now).catch(() => void 0);
+		};
+		for (const target of targets) batch.settled(target.path).then(() => {
+			ready.push(target);
+			timer ??= setTimeout(flush, delay);
+		});
+	}
+	async #redetect(documentIds) {
+		const state = this.#store.payload;
+		const targets = this.#trackedFiles(state, documentIds.filter((documentId) => state.documents[documentId]?.sourceState !== "missing"));
+		if (targets.length === 0) return;
+		const batch = this.#repositories.begin(targets.map((target) => target.path));
+		await this.#repositories.wait(batch);
+		this.#applyWhenDone(batch, await this.#applyBatch(batch, targets));
 	}
 	async #withPathLocks(paths, work) {
 		const releases = [];
@@ -3805,7 +4416,8 @@ var DocumentService = class {
 			pathQueues: this.#pathQueues.size,
 			openEpochs: this.#openEpochs.size,
 			interactive: this.#interactive.size,
-			linkConfirmations: this.#linkConfirmations.size
+			linkConfirmations: this.#linkConfirmations.size,
+			...this.#repositories.retainedCounts()
 		};
 	}
 	async open(rawParams) {
@@ -3854,15 +4466,18 @@ var DocumentService = class {
 		const settings = await this.#assetSettings(params);
 		if (settings.explicit !== void 0 && resolved.unique.size !== 1) throw new VdeError("E_INVALID_ARGUMENT", "--asset can only be specified when opening a single document.", { documents: resolved.unique.size });
 		if (params.htmlMode !== void 0 && ![...resolved.unique.values()].some((entry) => entry.format === "html")) throw new VdeError("E_INVALID_ARGUMENT", "--html-mode applies to HTML documents.");
+		const batch = this.#repositories.begin(resolved.unique.keys());
 		return this.#withPathLocks(resolved.unique.keys(), async () => {
 			const incoming = await this.#readCandidates(resolved, settings, warnings);
 			if (incoming.length === 0 && watchTargets.length === 0) throw new VdeError("E_PATH_NOT_FOUND", "No documents found.", { paths: params.paths });
-			return this.#commitOpen(params, incoming, watchTargets, settings, warnings);
+			await this.#repositories.wait(batch);
+			return this.#commitOpen(params, incoming, watchTargets, settings, warnings, batch);
 		});
 	}
-	async #commitOpen(params, incoming, watchTargets, settings, warnings) {
+	async #commitOpen(params, incoming, watchTargets, settings, warnings, batch) {
 		if ((params.title !== void 0 || params.key !== void 0) && incoming.length !== 1) throw new VdeError("E_INVALID_ARGUMENT", "--title and --key can only be specified when opening a single document.", { documents: incoming.length });
 		const events = [];
+		let repositories = null;
 		const result = await this.#store.transaction((tx) => {
 			const state = tx.state;
 			const timestamp = this.#now().toISOString();
@@ -3906,9 +4521,11 @@ var DocumentService = class {
 				rules.push(rule);
 			}
 			assertOpenLimits(state);
-			if (created + updated > 0) state.catalogVersion += 1;
+			if (batch !== void 0) repositories = this.#repositories.stage(batch, this.#trackedFiles(state, touched), { pendingWhenUnfinished: true });
+			const repositoryChanged = repositories?.changed === true;
+			if (created + updated > 0 || repositoryChanged) state.catalogVersion += 1;
 			if (state.activeDocumentId === null) state.activeDocumentId = state.openOrder[0] ?? null;
-			if (openSetChanged) events.unshift({ type: "catalog-changed" });
+			if (openSetChanged || repositoryChanged) events.unshift({ type: "catalog-changed" });
 			return {
 				data: {
 					documents: touched.map((documentId) => this.#summary(state, documentId)),
@@ -3921,6 +4538,11 @@ var DocumentService = class {
 				warnings
 			};
 		});
+		const staged = repositories;
+		if (staged !== null && batch !== void 0) {
+			this.#repositories.apply(staged);
+			this.#applyWhenDone(batch, staged.unfinished);
+		}
 		for (const item of incoming) this.#record(item);
 		const permissionChanged = [];
 		result.data.documents.forEach((summary, index) => {
@@ -4183,7 +4805,7 @@ var DocumentService = class {
 		};
 	}
 	#summary(state, documentId) {
-		return toSummary(state.documents[documentId], state.openOrder.indexOf(documentId), this.#searchStateOf(documentId), pendingRequestIdsOf(state, documentId), this.interactiveAllowed(documentId));
+		return toSummary(state.documents[documentId], state.openOrder.indexOf(documentId), this.#searchStateOf(documentId), pendingRequestIdsOf(state, documentId), this.interactiveAllowed(documentId), state.documents[documentId]?.sourceKind === "file" ? this.#repositories.view(documentId) : null);
 	}
 	#findExisting(state, item, key) {
 		if (item.sourceKind === "file") return Object.values(state.documents).find((record) => record.sourceKind === "file" && record.canonicalPath === item.canonicalPath);
@@ -4518,6 +5140,7 @@ var DocumentService = class {
 			};
 		});
 		for (const documentId of result.data.closed) this.#openEpochs.set(documentId, this.openEpoch(documentId) + 1);
+		this.#repositories.forget(result.data.closed);
 		if (changed) this.#emit({ type: "catalog-changed" });
 		for (const event of cancelled) this.#emit(event);
 		return result;
@@ -4595,6 +5218,7 @@ var DocumentService = class {
 		const targets = raw === void 0 ? this.#store.payload.openOrder : [this.#requireOpen(documentIdSchema.parse(raw)).documentId];
 		const changed = [];
 		for (const documentId of targets) if ((await this.refreshFromDisk(documentId)).changed) changed.push(documentId);
+		await this.#redetect(targets);
 		const state = this.#store.payload;
 		return {
 			data: {
@@ -4730,6 +5354,7 @@ var DocumentService = class {
 		const before = this.#store.payload;
 		const rule = before.watchRules.find((candidate) => candidate.watchId === watchId);
 		if (!rule) return [];
+		const batch = this.#repositories.begin(candidates.keys());
 		const isOpenPath = (state, path) => Object.values(state.documents).some((record) => record.isOpen && record.sourceKind === "file" && record.canonicalPath === path);
 		let totalBytes = openSourceBytes(before);
 		const discovered = [];
@@ -4769,7 +5394,9 @@ var DocumentService = class {
 			}
 		}
 		if (discovered.length === 0) return [];
+		await this.#repositories.wait(batch);
 		const appliedItems = [];
+		let repositories = null;
 		const registered = await this.#store.transaction((tx) => {
 			const state = tx.state;
 			const current = state.watchRules.find((candidate) => candidate.watchId === watchId);
@@ -4785,10 +5412,16 @@ var DocumentService = class {
 			}
 			if (added.length === 0) return [];
 			assertOpenLimits(state);
+			repositories = this.#repositories.stage(batch, this.#trackedFiles(state, added), { pendingWhenUnfinished: true });
 			state.catalogVersion += 1;
 			if (state.activeDocumentId === null) state.activeDocumentId = state.openOrder[0] ?? null;
 			return added;
 		});
+		const staged = repositories;
+		if (staged !== null) {
+			this.#repositories.apply(staged);
+			this.#applyWhenDone(batch, staged.unfinished);
+		}
 		for (const item of appliedItems) this.#record(item);
 		if (registered.length > 0) this.#emit({ type: "catalog-changed" });
 		return registered;
@@ -5869,7 +6502,8 @@ function createRenderService(options) {
 				role
 			})),
 			links: output.links,
-			diagnostics: output.diagnostics
+			diagnostics: output.diagnostics,
+			headingTargets: output.headingTargets
 		};
 		snapshots.set(cacheKey, snapshot);
 		while (snapshots.size > SNAPSHOT_CACHE_SIZE) {
@@ -5965,6 +6599,7 @@ function createRenderService(options) {
 				target: null,
 				count: 1
 			}, ...snapshot.diagnostics] : snapshot.diagnostics,
+			headingTargets: snapshot.headingTargets,
 			bridge: bridge === null ? null : {
 				instanceId: bridge.instanceId,
 				requestId: bridge.requestId
@@ -6063,6 +6698,108 @@ function createRenderService(options) {
 	};
 }
 //#endregion
+//#region src/diagnostics/idle-collect.ts
+const COLLECT_AFTER_IDLE_MS = 2e3;
+function createIdleTrigger(run, delayMs = COLLECT_AFTER_IDLE_MS) {
+	let timer = null;
+	const cancel = () => {
+		if (timer) clearTimeout(timer);
+		timer = null;
+	};
+	return {
+		touch() {
+			cancel();
+			timer = setTimeout(() => {
+				timer = null;
+				run();
+			}, delayMs);
+			timer.unref();
+		},
+		cancel
+	};
+}
+function createWorkerCollect(options) {
+	let collecting = null;
+	let closed = false;
+	const held = [];
+	const release = () => {
+		if (collecting) clearTimeout(collecting.timer);
+		collecting = null;
+		for (const request of held.splice(0)) request.send();
+	};
+	const idle = createIdleTrigger(() => {
+		const worker = options.worker();
+		if (closed || worker === null || collecting) return;
+		if (options.busy()) {
+			idle.touch();
+			return;
+		}
+		const id = options.nextId();
+		const timer = setTimeout(release, options.waitLimitMs ?? 1e4);
+		timer.unref();
+		collecting = {
+			id,
+			timer
+		};
+		worker.postMessage({
+			id,
+			op: "collect"
+		});
+	}, options.delayMs);
+	return {
+		dispatch(send, reject) {
+			if (collecting) held.push({
+				send,
+				reject
+			});
+			else send();
+		},
+		touch: () => idle.touch(),
+		settle(id) {
+			if (collecting?.id !== id) return false;
+			release();
+			return true;
+		},
+		reset: () => {
+			if (collecting) release();
+		},
+		close(error) {
+			closed = true;
+			idle.cancel();
+			if (collecting) clearTimeout(collecting.timer);
+			collecting = null;
+			for (const request of held.splice(0)) request.reject(error);
+		}
+	};
+}
+function utilizationSincePreviousCall() {
+	let previous = performance.eventLoopUtilization();
+	return () => {
+		const current = performance.eventLoopUtilization();
+		const { utilization } = performance.eventLoopUtilization(current, previous);
+		previous = current;
+		return utilization;
+	};
+}
+function startHeapWatch(options = {}) {
+	const growthBytes = options.growthBytes ?? 8388608;
+	const idleUtilization = options.idleUtilization ?? .05;
+	const heapUsed = options.heapUsed ?? (() => getHeapStatistics().used_heap_size);
+	const utilization = options.utilization ?? utilizationSincePreviousCall();
+	const collect = options.collect ?? collectGarbage;
+	let baseline = heapUsed();
+	const timer = setInterval(() => {
+		const busy = utilization() >= idleUtilization;
+		const used = heapUsed();
+		baseline = Math.min(baseline, used);
+		if (busy || used - baseline < growthBytes) return;
+		collect();
+		baseline = heapUsed();
+	}, options.intervalMs ?? 2e3);
+	timer.unref();
+	return { stop: () => clearInterval(timer) };
+}
+//#endregion
 //#region src/diagnostics/until-aborted.ts
 function untilAborted(promise, signal) {
 	if (!signal) return promise;
@@ -6148,6 +6885,15 @@ function createSearchService(options) {
 	let closed = false;
 	let indexedAt = now().toISOString();
 	let syncing = null;
+	const collector = createWorkerCollect({
+		worker: () => worker,
+		busy: () => pending.size > 0,
+		nextId: () => {
+			const id = nextId;
+			nextId += 1;
+			return id;
+		}
+	});
 	let syncRequested = false;
 	const failAll = (error) => {
 		for (const waiter of pending.values()) {
@@ -6168,6 +6914,7 @@ function createSearchService(options) {
 		const created = new Worker(workerPath);
 		created.unref();
 		created.on("message", (reply) => {
+			if (collector.settle(reply.id)) return;
 			const waiter = pending.get(reply.id);
 			if (!waiter) return;
 			pending.delete(reply.id);
@@ -6178,31 +6925,36 @@ function createSearchService(options) {
 		created.on("error", () => {
 			if (worker === created) discardWorker();
 			failAll(new VdeError("E_INDEX_NOT_READY", "The search index is not available."));
+			collector.reset();
 		});
 		worker = created;
 		return created;
 	};
 	const request = (work) => {
 		if (closed) return Promise.reject(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
-		return new Promise((resolve, reject) => {
-			const id = nextId;
-			nextId += 1;
-			const timer = setTimeout(() => {
-				pending.delete(id);
-				discardWorker();
-				failAll(new VdeError("E_INDEX_NOT_READY", "The search index is not available."));
-				reject(new VdeError("E_INDEX_NOT_READY", "The search index operation did not finish in time.", { reason: "timeout" }));
-			}, timeoutMs);
-			pending.set(id, {
-				resolve,
-				reject,
-				timer
-			});
-			ensureWorker().postMessage({
-				id,
-				...work
-			});
+		const result = new Promise((resolve, reject) => {
+			collector.dispatch(() => {
+				const id = nextId;
+				nextId += 1;
+				const timer = setTimeout(() => {
+					pending.delete(id);
+					discardWorker();
+					failAll(new VdeError("E_INDEX_NOT_READY", "The search index is not available."));
+					reject(new VdeError("E_INDEX_NOT_READY", "The search index operation did not finish in time.", { reason: "timeout" }));
+				}, timeoutMs);
+				pending.set(id, {
+					resolve,
+					reject,
+					timer
+				});
+				ensureWorker().postMessage({
+					id,
+					...work
+				});
+			}, reject);
 		});
+		if (work.op !== "diagnostics") result.then(collector.touch, collector.touch);
+		return result;
 	};
 	const analyzeOnce = async (format, text) => {
 		try {
@@ -6513,6 +7265,7 @@ function createSearchService(options) {
 		},
 		async close() {
 			closed = true;
+			collector.close(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
 			failAll(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
 			const current = worker;
 			worker = null;
@@ -12505,6 +13258,15 @@ function createParseService(options = {}) {
 	let nextId = 1;
 	let closed = false;
 	const pending = /* @__PURE__ */ new Map();
+	const collector = createWorkerCollect({
+		worker: () => worker,
+		busy: () => pending.size > 0,
+		nextId: () => {
+			const id = nextId;
+			nextId += 1;
+			return id;
+		}
+	});
 	const failAll = (error) => {
 		for (const waiter of pending.values()) {
 			clearTimeout(waiter.timer);
@@ -12522,6 +13284,7 @@ function createParseService(options = {}) {
 		const created = new Worker(workerPath);
 		created.unref();
 		created.on("message", (reply) => {
+			if (collector.settle(reply.id)) return;
 			const waiter = pending.get(reply.id);
 			if (!waiter) return;
 			pending.delete(reply.id);
@@ -12532,32 +13295,37 @@ function createParseService(options = {}) {
 		created.on("error", () => {
 			if (worker === created) worker = null;
 			failAll(new VdeError("E_PARSE_FAILED", "The document could not be parsed.", { reason: "worker" }));
+			collector.reset();
 		});
 		worker = created;
 		return created;
 	};
 	const request = (work) => {
 		if (closed) return Promise.reject(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
-		return new Promise((resolve, reject) => {
-			const id = nextId;
-			nextId += 1;
-			const timer = setTimeout(() => {
-				discardWorker();
-				failAll(new VdeError("E_PARSE_FAILED", "Parsing the document did not finish in time.", {
-					reason: "timeout",
-					timeoutMs
-				}));
-			}, timeoutMs);
-			pending.set(id, {
-				resolve,
-				reject,
-				timer
-			});
-			ensureWorker().postMessage({
-				id,
-				...work
-			});
+		const result = new Promise((resolve, reject) => {
+			collector.dispatch(() => {
+				const id = nextId;
+				nextId += 1;
+				const timer = setTimeout(() => {
+					discardWorker();
+					failAll(new VdeError("E_PARSE_FAILED", "Parsing the document did not finish in time.", {
+						reason: "timeout",
+						timeoutMs
+					}));
+				}, timeoutMs);
+				pending.set(id, {
+					resolve,
+					reject,
+					timer
+				});
+				ensureWorker().postMessage({
+					id,
+					...work
+				});
+			}, reject);
 		});
+		if (work.op !== "diagnostics") result.then(collector.touch, collector.touch);
+		return result;
 	};
 	return {
 		diagnostics: (collectGarbage, signal) => worker === null ? Promise.resolve(null) : untilAborted(request({
@@ -12580,6 +13348,7 @@ function createParseService(options = {}) {
 		}),
 		async close() {
 			closed = true;
+			collector.close(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
 			failAll(new VdeError("E_DAEMON_STOPPING", "The daemon is stopping."));
 			const current = worker;
 			worker = null;
@@ -12944,6 +13713,7 @@ async function startDaemon(options) {
 	let feedback = null;
 	let announceStopping = () => void 0;
 	let lockTimer = null;
+	let heapWatch = null;
 	let stopping = null;
 	const stopRequested = new AbortController();
 	const owned = {
@@ -12977,6 +13747,7 @@ async function startDaemon(options) {
 		};
 		stopRequested.abort();
 		if (lockTimer) clearInterval(lockTimer);
+		heapWatch?.stop();
 		await step("watcher", () => watcher?.close(), SHUTDOWN_CLOSE_TIMEOUT_MS);
 		await step("feedback", () => feedback?.close());
 		await step("drain", () => ipc?.drain());
@@ -13060,6 +13831,7 @@ async function startDaemon(options) {
 			scan: (kind, text) => parser.scan(kind, text),
 			emit
 		});
+		await documents.initializeRepositories();
 		feedback = new FeedbackService({
 			store: openedStore,
 			documents,
@@ -13238,6 +14010,7 @@ async function startDaemon(options) {
 		};
 		lockTimer = setInterval(() => void checkLock(), LOCK_CHECK_INTERVAL_MS);
 		lockTimer.unref();
+		heapWatch = startHeapWatch();
 		logger.log("daemon.started", { openDocuments: openedStore.payload.openOrder.length });
 	} catch (error) {
 		logger.log("daemon.start-failed", { code: error instanceof VdeError ? error.code : "E_INTERNAL" });