@hudhod/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2084 @@
+import { _ as DisposableStore, a as isSubPath, c as pathSegments, d as directoryNotEmpty, f as fileExists, g as notAFile, h as notADirectory, i as extname, l as relativePath, m as invalidPath, n as basename, o as joinPath, p as fileNotFound, r as dirname, s as normalizePath, t as ROOT, u as createError, v as NO_OP_DISPOSABLE, y as toDisposable } from "./paths-B3gr2EuI.js";
+import { applyPatch, createTwoFilesPatch, diffArrays, diffLines } from "diff";
+import { z } from "zod";
+import picomatch from "picomatch";
+
+//#region src/base/event.ts
+/**
+* Produces an {@link Event} and the means to fire it.
+*
+* Listener errors are isolated: one throwing listener never prevents the others
+* from running. Errors are reported to `onListenerError` instead of
+* propagating to the caller of {@link fire}, because an emitter's producer
+* generally cannot do anything useful about a consumer's failure.
+*
+* @typeParam T - The payload delivered to listeners.
+*
+* @example
+* ```ts
+* const emitter = new Emitter<string>();
+* const sub = emitter.event((name) => console.log(name));
+* emitter.fire("world");
+* sub.dispose();
+* ```
+*/
+var Emitter = class {
+	#listeners = /* @__PURE__ */ new Set();
+	#onListenerError;
+	#disposed = false;
+	/**
+	* @param options.onListenerError - Called when a listener throws.
+	* Defaults to `console.error`.
+	*/
+	constructor(options = {}) {
+		this.#onListenerError = options.onListenerError ?? ((error) => {
+			console.error("[hudhod] event listener threw", error);
+		});
+	}
+	/** Number of listeners currently subscribed. */
+	get listenerCount() {
+		return this.#listeners.size;
+	}
+	/**
+	* Subscribes to this emitter.
+	*
+	* Registering the same function twice yields a single subscription, matching
+	* `Set` semantics; disposing either handle removes it.
+	*/
+	event = (listener) => {
+		if (this.#disposed) return toDisposable(() => {});
+		this.#listeners.add(listener);
+		return toDisposable(() => {
+			this.#listeners.delete(listener);
+		});
+	};
+	/**
+	* Delivers `value` to every current listener.
+	*
+	* Iterates a snapshot, so listeners added or removed during delivery do not
+	* affect the in-flight dispatch.
+	*/
+	fire(value) {
+		if (this.#disposed) return;
+		for (const listener of Array.from(this.#listeners)) try {
+			listener(value);
+		} catch (error) {
+			this.#onListenerError(error);
+		}
+	}
+	/** Removes all listeners and blocks further subscription. */
+	dispose() {
+		this.#disposed = true;
+		this.#listeners.clear();
+	}
+};
+
+//#endregion
+//#region src/base/cancellation.ts
+/** A token that is never cancelled. Useful as a default parameter. */
+const CancellationTokenNone = Object.freeze({
+	isCancellationRequested: false,
+	onCancellationRequested: () => NO_OP_DISPOSABLE
+});
+/**
+* Creates a {@link CancellationToken} and controls when it fires.
+*
+* Listeners registered after cancellation are invoked immediately, so a late
+* subscriber cannot miss the signal.
+*
+* @example
+* ```ts
+* const source = new CancellationTokenSource();
+* const results = await search(query, source.token);
+* source.cancel();
+* ```
+*/
+var CancellationTokenSource = class {
+	#emitter = new Emitter();
+	#cancelled = false;
+	/** The token to hand to cancellable operations. */
+	token;
+	constructor() {
+		const isCancelled = () => this.#cancelled;
+		const onCancellationRequested = this.#emitter.event;
+		this.token = {
+			get isCancellationRequested() {
+				return isCancelled();
+			},
+			onCancellationRequested: (listener) => {
+				if (isCancelled()) {
+					listener();
+					return NO_OP_DISPOSABLE;
+				}
+				return onCancellationRequested(listener);
+			}
+		};
+	}
+	/** Whether cancellation has been requested. */
+	get isCancellationRequested() {
+		return this.#cancelled;
+	}
+	/** Requests cancellation. Subsequent calls are no-ops. */
+	cancel() {
+		if (this.#cancelled) return;
+		this.#cancelled = true;
+		this.#emitter.fire();
+	}
+	/** Releases listeners without cancelling. */
+	dispose() {
+		this.#emitter.dispose();
+	}
+};
+/**
+* Adapts an {@link AbortSignal} into a {@link CancellationToken}.
+*
+* Lets callers pass the platform-standard signal to hudhod APIs.
+*/
+function tokenFromAbortSignal(signal) {
+	return {
+		get isCancellationRequested() {
+			return signal.aborted;
+		},
+		onCancellationRequested: (listener) => {
+			if (signal.aborted) {
+				listener();
+				return NO_OP_DISPOSABLE;
+			}
+			const onAbort = () => listener();
+			signal.addEventListener("abort", onAbort, { once: true });
+			return { dispose() {
+				signal.removeEventListener("abort", onAbort);
+			} };
+		}
+	};
+}
+
+//#endregion
+//#region src/commands/command-registry.ts
+/**
+* Registers and invokes commands.
+*
+* @example
+* ```ts
+* const commands = new CommandRegistry();
+* commands.registerCommand("demo.hello", () => "Hello", { title: "Say Hello" });
+* await commands.executeCommand("demo.hello");
+* ```
+*/
+var CommandRegistry = class {
+	#commands = /* @__PURE__ */ new Map();
+	#changeEmitter = new Emitter();
+	/** Fires whenever the command catalog changes. */
+	onDidChangeCommands = (listener) => this.#changeEmitter.event(listener);
+	/**
+	* Registers a command handler.
+	*
+	* @throws A `CommandExists` error when `id` is already registered.
+	*/
+	registerCommand(id, handler, options = {}) {
+		if (this.#commands.has(id)) throw createError("CommandExists", `Command is already registered: ${id}`);
+		const registered = {
+			descriptor: {
+				id,
+				...options.title ? { title: options.title } : { title: id },
+				...options.category ? { category: options.category } : {}
+			},
+			handler
+		};
+		this.#commands.set(id, registered);
+		this.#fireChange();
+		let disposed = false;
+		return { dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			if (this.#commands.get(id) !== registered) return;
+			this.#commands.delete(id);
+			this.#fireChange();
+		} };
+	}
+	/**
+	* Invokes a registered command.
+	*
+	* @throws A `CommandNotFound` error when no handler is registered for `id`.
+	*/
+	async executeCommand(id, ...args) {
+		const command = this.#commands.get(id);
+		if (!command) throw createError("CommandNotFound", `Command not found: ${id}`);
+		return await command.handler(...args);
+	}
+	/** Lists registered commands, alphabetically by title then id. */
+	async getCommands() {
+		return sortedBy$3(Array.from(this.#commands.values(), ({ descriptor }) => descriptor.category ? {
+			id: descriptor.id,
+			title: descriptor.title,
+			category: descriptor.category
+		} : {
+			id: descriptor.id,
+			title: descriptor.title
+		}), (left, right) => left.title.localeCompare(right.title) || left.id.localeCompare(right.id));
+	}
+	/** Removes all registered commands and listeners. */
+	dispose() {
+		const changed = this.#commands.size > 0;
+		this.#commands.clear();
+		if (changed) this.#fireChange();
+		this.#changeEmitter.dispose();
+	}
+	#fireChange() {
+		this.getCommands().then((commands) => this.#changeEmitter.fire(commands));
+	}
+};
+function sortedBy$3(values, compare) {
+	const result = [];
+	for (const value of values) {
+		const index = result.findIndex((candidate) => compare(value, candidate) < 0);
+		if (index === -1) result.push(value);
+		else result.splice(index, 0, value);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/keybindings/keybinding-parser.ts
+/**
+* Parses a keybinding string like `"ctrl+shift+p"` into components.
+*
+* @throws Error when the syntax is malformed.
+* @example
+* parseKeybinding("ctrl+n") => { ctrl: true, shift: false, alt: false, key: "n" }
+* parseKeybinding("cmd+shift+k") => { ctrl: true, shift: true, alt: false, key: "k" }
+*/
+function parseKeybinding(binding) {
+	const parts = binding.toLowerCase().split("+");
+	if (parts.length < 1) throw new Error(`Keybinding must have at least a key: ${binding}`);
+	const normalized = {
+		ctrl: false,
+		shift: false,
+		alt: false,
+		key: ""
+	};
+	for (let i = 0; i < parts.length - 1; i++) {
+		const mod = parts[i];
+		if (mod === "ctrl") normalized.ctrl = true;
+		else if (mod === "cmd" || mod === "meta") normalized.ctrl = true;
+		else if (mod === "shift") normalized.shift = true;
+		else if (mod === "alt") normalized.alt = true;
+		else throw new Error(`Unknown modifier '${mod}' in keybinding: ${binding}`);
+	}
+	const keyPart = parts[parts.length - 1];
+	if (!keyPart) throw new Error(`Keybinding must end with a key: ${binding}`);
+	normalized.key = keyPart;
+	return normalized;
+}
+/**
+* Converts a {@link NormalizedKeybinding} back to a canonical string.
+*
+* @example
+* keybindingToString({ ctrl: true, shift: true, alt: false, key: "p" }) => "ctrl+shift+p"
+*/
+function keybindingToString(binding) {
+	const parts = [];
+	if (binding.ctrl) parts.push("ctrl");
+	if (binding.shift) parts.push("shift");
+	if (binding.alt) parts.push("alt");
+	parts.push(binding.key);
+	return parts.join("+");
+}
+/**
+* Resolves a keyboard event to a canonical key string, or `undefined` if no binding.
+*
+* Returns a string like `"ctrl+shift+p"` that can be matched against registered bindings.
+*/
+function keybindingFromEvent(event) {
+	const parts = [];
+	if (event.ctrlKey || event.metaKey) parts.push("ctrl");
+	if (event.shiftKey) parts.push("shift");
+	if (event.altKey) parts.push("alt");
+	parts.push(event.key.toLowerCase());
+	return parts.join("+");
+}
+
+//#endregion
+//#region src/keybindings/keybinding-registry.ts
+/**
+* Registers and resolves keybindings.
+*
+* @example
+* ```ts
+* const keybindings = new KeybindingRegistry("other");
+* keybindings.registerKeybinding({
+*   command: "demo.greet",
+*   key: "ctrl+n",
+*   mac: "cmd+n",
+* });
+* const binding = await keybindings.resolve({ key: "n", ctrlKey: true, ... });
+* // => { key: "ctrl+n", command: "demo.greet", source: "extension" }
+* ```
+*/
+var KeybindingRegistry = class {
+	#stack = /* @__PURE__ */ new Map();
+	#changeEmitter = new Emitter();
+	#platform;
+	/** Fires whenever the keybinding catalog changes. */
+	onDidChangeKeybindings = (listener) => this.#changeEmitter.event(listener);
+	/**
+	* @param platform Platform identifier. Use `"mac"` for macOS; otherwise `"other"`.
+	*/
+	constructor(platform = "other") {
+		this.#platform = platform;
+	}
+	/**
+	* Registers a keybinding.
+	*
+	* If the same key is already bound, this replaces it. Disposing the returned
+	* {@link Disposable} restores the previous binding.
+	*
+	* @throws invalidKeybinding when the key syntax is malformed.
+	*/
+	registerKeybinding(binding, options) {
+		const keyNormalized = parseKeybinding(binding.key);
+		const macNormalized = binding.mac ? parseKeybinding(binding.mac) : void 0;
+		const keyStr = keybindingToString(this.#platform === "mac" && macNormalized ? macNormalized : keyNormalized);
+		const stacked = {
+			contribution: binding,
+			source: options?.source ?? "extension",
+			extensionId: options?.extensionId
+		};
+		if (!this.#stack.has(keyStr)) this.#stack.set(keyStr, []);
+		this.#stack.get(keyStr).push(stacked);
+		this.#fireChange();
+		let disposed = false;
+		return { dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const stack = this.#stack.get(keyStr);
+			if (!stack) return;
+			const idx = stack.indexOf(stacked);
+			if (idx >= 0) stack.splice(idx, 1);
+			if (stack.length === 0) this.#stack.delete(keyStr);
+			this.#fireChange();
+		} };
+	}
+	/**
+	* Resolves a keyboard event to a keybinding, if one is registered.
+	*
+	* @param event A keyboard event-like object with `key`, `ctrlKey`, `metaKey`, `shiftKey`, `altKey`.
+	* @returns The registered keybinding, or `undefined` if no match.
+	*/
+	resolve(event) {
+		const keyStr = keybindingFromEvent(event);
+		const stack = this.#stack.get(keyStr);
+		if (!stack || stack.length === 0) return void 0;
+		const top = stack[stack.length - 1];
+		if (!top) return void 0;
+		return {
+			key: keyStr,
+			command: top.contribution.command,
+			source: top.source,
+			extensionId: top.extensionId
+		};
+	}
+	/** Lists all registered keybindings, with top-of-stack (most recent) entries first. */
+	async getKeybindings() {
+		const result = [];
+		for (const [keyStr, stack] of this.#stack) if (stack.length > 0) {
+			const top = stack[stack.length - 1];
+			if (!top) continue;
+			result.push({
+				key: keyStr,
+				command: top.contribution.command,
+				source: top.source,
+				extensionId: top.extensionId
+			});
+		}
+		return sortedBy$2(result, (left, right) => left.key.localeCompare(right.key));
+	}
+	/** Removes all registered keybindings and listeners. */
+	dispose() {
+		const changed = this.#stack.size > 0;
+		this.#stack.clear();
+		if (changed) this.#fireChange();
+		this.#changeEmitter.dispose();
+	}
+	#fireChange() {
+		this.getKeybindings().then((bindings) => this.#changeEmitter.fire(bindings));
+	}
+};
+function sortedBy$2(values, compare) {
+	const result = [];
+	for (const value of values) {
+		const index = result.findIndex((candidate) => compare(value, candidate) < 0);
+		if (index === -1) result.push(value);
+		else result.splice(index, 0, value);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/window/window-service.ts
+/**
+* Provides window and UI APIs to extensions.
+*
+* @example
+* ```ts
+* const provider = createMyWindowUiProvider();
+* const window = new WindowService(provider);
+* await window.showMessage("Hello!");
+* ```
+*/
+var WindowService = class {
+	#provider;
+	constructor(provider) {
+		this.#provider = provider;
+	}
+	async showMessage(message, severity) {
+		return this.#provider.showMessage(message, severity);
+	}
+	async showInputBox(options) {
+		return this.#provider.showInputBox(options);
+	}
+	async showQuickPick(items, options) {
+		return this.#provider.showQuickPick(items, options);
+	}
+	registerPanel(id, render, options) {
+		return this.#provider.registerPanel(id, render, options);
+	}
+	registerView(id, render, options) {
+		return this.#provider.registerView(id, render, options);
+	}
+	async openPanel(id) {
+		return this.#provider.openPanel(id);
+	}
+	async closePanel(id) {
+		return this.#provider.closePanel(id);
+	}
+	async openFile(path) {
+		return this.#provider.openFile(path);
+	}
+	get activeEditor() {
+		return this.#provider.activeEditor;
+	}
+	get onDidChangeActiveEditor() {
+		return this.#provider.onDidChangeActiveEditor;
+	}
+	dispose() {}
+};
+
+//#endregion
+//#region src/diff/diff-service.ts
+/** Default lines of context in a unified patch. */
+const DEFAULT_CONTEXT = 3;
+/**
+* Compares text and applies patches.
+*
+* @example
+* ```ts
+* const diff = new DiffService(fs);
+* const patch = await diff.createPatch("/a.ts", before, after);
+* await diff.applyPatch("/a.ts", patch);
+* ```
+*/
+var DiffService = class {
+	#fs;
+	constructor(fileSystem) {
+		this.#fs = fileSystem;
+	}
+	async diffText(original, modified, options = {}) {
+		const parts = options.ignoreCase ? diffArrays(splitLines(original), splitLines(modified), { comparator: (left, right) => left.toLowerCase() === right.toLowerCase() }) : diffLines(original, modified, { ignoreWhitespace: options.ignoreWhitespace ?? false });
+		const changes = [];
+		for (const part of parts) {
+			const lines = Array.isArray(part.value) ? part.value : splitLines(part.value);
+			if (lines.length === 0) continue;
+			changes.push({
+				type: part.added ? "added" : part.removed ? "removed" : "unchanged",
+				lines
+			});
+		}
+		return changes;
+	}
+	async diffFiles(originalPath, modifiedPath, options = {}) {
+		const [original, modified] = await Promise.all([this.#fs.readTextFile(originalPath), this.#fs.readTextFile(modifiedPath)]);
+		return this.diffText(original, modified, options);
+	}
+	async diffStat(original, modified, options = {}) {
+		const changes = await this.diffText(original, modified, options);
+		let added = 0;
+		let removed = 0;
+		for (const change of changes) {
+			if (change.type === "added") added += change.lines.length;
+			if (change.type === "removed") removed += change.lines.length;
+		}
+		return {
+			added,
+			removed
+		};
+	}
+	async createPatch(path, original, modified, options = {}) {
+		return createTwoFilesPatch(path, path, original, modified, void 0, void 0, {
+			context: options.context ?? DEFAULT_CONTEXT,
+			ignoreWhitespace: options.ignoreWhitespace ?? false
+		});
+	}
+	/**
+	* Applies a unified diff to a file.
+	*
+	* @throws A `PatchFailed` error when the patch does not apply cleanly, which
+	* usually means the file changed after the patch was produced.
+	*/
+	async applyPatch(path, patch) {
+		const result = applyPatch(await this.#fs.readTextFile(path), patch);
+		if (result === false) throw createError("PatchFailed", `Patch did not apply cleanly to ${path}`, { path });
+		await this.#fs.writeTextFile(path, result);
+	}
+};
+/**
+* Splits a jsdiff chunk into lines, dropping the artefact empty string that a
+* trailing newline produces.
+*/
+function splitLines(value) {
+	if (value === "") return [];
+	const lines = value.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	return lines;
+}
+
+//#endregion
+//#region src/extensions/manifest.ts
+const extensionId = z.string().min(3).max(128).regex(/^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)+$/, "must be a dot-separated lowercase identifier, for example acme.todo-finder");
+const commandContribution = z.object({
+	id: z.string().min(1).max(256),
+	title: z.string().min(1).max(256),
+	category: z.string().min(1).max(128).optional()
+});
+const panelContribution = z.object({
+	id: z.string().min(1).max(256),
+	title: z.string().min(1).max(256),
+	icon: z.unknown().optional(),
+	location: z.enum([
+		"left",
+		"right",
+		"bottom",
+		"center"
+	]).optional()
+});
+const viewContainerContribution = z.object({
+	id: z.string().min(1).max(256),
+	title: z.string().min(1).max(256),
+	icon: z.unknown().optional(),
+	location: z.enum([
+		"left",
+		"right",
+		"bottom",
+		"center"
+	]).optional()
+});
+const viewContribution = z.object({
+	id: z.string().min(1).max(256),
+	title: z.string().min(1).max(256),
+	container: z.string().min(1).max(256),
+	order: z.number().finite().optional()
+});
+const keybindingContribution = z.object({
+	command: z.string().min(1),
+	key: z.string().min(1).superRefine((val, ctx) => {
+		try {
+			parseKeybinding(val);
+		} catch {
+			ctx.addIssue({
+				code: "custom",
+				message: `Invalid keybinding syntax: ${val}`
+			});
+		}
+	}),
+	mac: z.string().min(1).superRefine((val, ctx) => {
+		try {
+			parseKeybinding(val);
+		} catch {
+			ctx.addIssue({
+				code: "custom",
+				message: `Invalid macOS keybinding syntax: ${val}`
+			});
+		}
+	}).optional()
+});
+const activationEvent = z.union([
+	z.literal("onStartup"),
+	z.string().regex(/^onCommand:[^\s]+$/),
+	z.string().regex(/^onFileOpen:.+$/),
+	z.string().regex(/^onView:[^\s]+$/)
+]);
+/** Validates the serializable shape of an extension manifest. */
+const extensionManifestSchema = z.object({
+	id: extensionId,
+	name: z.string().min(1).max(128),
+	version: z.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/, "must be a semantic version"),
+	description: z.string().max(512).optional(),
+	activationEvents: z.array(activationEvent).min(1).optional(),
+	contributes: z.object({
+		commands: z.array(commandContribution).optional(),
+		panels: z.array(panelContribution).optional(),
+		viewContainers: z.array(viewContainerContribution).optional(),
+		views: z.array(viewContribution).optional(),
+		keybindings: z.array(keybindingContribution).optional()
+	}).optional()
+}).superRefine((manifest, context) => {
+	const commandIds = manifest.contributes?.commands?.map((command) => command.id) ?? [];
+	const panelIds = manifest.contributes?.panels?.map((panel) => panel.id) ?? [];
+	const viewContainerIds = manifest.contributes?.viewContainers?.map((container) => container.id) ?? [];
+	const viewIds = (manifest.contributes?.views ?? []).map((view) => view.id);
+	const keybindings = manifest.contributes?.keybindings ?? [];
+	if (new Set(commandIds).size !== commandIds.length) context.addIssue({
+		code: "custom",
+		path: ["contributes", "commands"],
+		message: "command contribution ids must be unique"
+	});
+	if (new Set(panelIds).size !== panelIds.length) context.addIssue({
+		code: "custom",
+		path: ["contributes", "panels"],
+		message: "panel contribution ids must be unique"
+	});
+	if (new Set(viewContainerIds).size !== viewContainerIds.length) context.addIssue({
+		code: "custom",
+		path: ["contributes", "viewContainers"],
+		message: "view container contribution ids must be unique"
+	});
+	if (new Set(viewIds).size !== viewIds.length) context.addIssue({
+		code: "custom",
+		path: ["contributes", "views"],
+		message: "view contribution ids must be unique"
+	});
+	for (const [i, kb] of keybindings.entries()) if (!commandIds.includes(kb.command)) context.addIssue({
+		code: "custom",
+		path: [
+			"contributes",
+			"keybindings",
+			i,
+			"command"
+		],
+		message: `Command '${kb.command}' is not defined in contributes.commands`
+	});
+	const seen = /* @__PURE__ */ new Set();
+	for (const [i, kb] of keybindings.entries()) {
+		const key = kb.key;
+		const pair = `${key}:${kb.command}`;
+		if (seen.has(pair)) context.addIssue({
+			code: "custom",
+			path: [
+				"contributes",
+				"keybindings",
+				i
+			],
+			message: `Duplicate keybinding: key '${key}' for command '${kb.command}'`
+		});
+		seen.add(pair);
+	}
+});
+/**
+* Validates a manifest or throws `ZodError` with field-level diagnostics.
+*
+* @example
+* ```ts
+* const manifest = parseExtensionManifest(rawJson);
+* ```
+*/
+function parseExtensionManifest(value) {
+	return extensionManifestSchema.parse(value);
+}
+
+//#endregion
+//#region src/extensions/extension-host.ts
+/**
+* Loads and activates trusted, first-party extensions.
+*
+* The host deliberately does not sandbox code or impose permissions: hudhod's
+* current extension model is curated and first-party. Activation is deduplicated
+* so concurrent triggers only call an extension's `activate` method once.
+*
+* @example
+* ```ts
+* const host = new InProcessExtensionHost(hudhod, { panels, views });
+* host.register(extension);
+* await host.activateByEvent("onStartup");
+* ```
+*/
+var InProcessExtensionHost = class {
+	#hudhod;
+	#panels;
+	#views;
+	#extensions = /* @__PURE__ */ new Map();
+	#disposed = false;
+	constructor(hudhod, registries) {
+		this.#hudhod = hudhod;
+		this.#panels = registries.panels;
+		this.#views = registries.views;
+	}
+	/**
+	* Registers an extension without running its activation hook.
+	*
+	* Contributed keybindings and panels are registered immediately so they can be
+	* discovered before the extension's activate hook runs, enabling lazy activation.
+	*
+	* @throws `ZodError` when the manifest is malformed.
+	* @throws `Error` when another extension already owns the same id.
+	*/
+	register(extension) {
+		this.#assertActive();
+		const manifest = parseExtensionManifest(extension.manifest);
+		if (this.#extensions.has(manifest.id)) throw new Error(`Extension is already registered: ${manifest.id}`);
+		const registered = {
+			extension,
+			manifest,
+			subscriptions: new DisposableStore(),
+			status: "registered"
+		};
+		const keybindings = manifest.contributes?.keybindings ?? [];
+		for (const kb of keybindings) {
+			const disp = this.#hudhod.keybindings.registerKeybinding(kb);
+			registered.subscriptions.add(disp);
+		}
+		const panels = manifest.contributes?.panels ?? [];
+		for (const panel of panels) {
+			const disp = this.#panels.registerPanel(panel, {
+				source: "extension",
+				extensionId: manifest.id
+			});
+			registered.subscriptions.add(disp);
+		}
+		const viewContainers = manifest.contributes?.viewContainers ?? [];
+		for (const container of viewContainers) {
+			const disp = this.#panels.registerPanel(container, {
+				source: "extension",
+				extensionId: manifest.id
+			});
+			registered.subscriptions.add(disp);
+		}
+		const views = manifest.contributes?.views ?? [];
+		for (const view of views) {
+			const disp = this.#views.registerView(view, {
+				source: "extension",
+				extensionId: manifest.id
+			});
+			registered.subscriptions.add(disp);
+		}
+		this.#extensions.set(manifest.id, registered);
+		let disposed = false;
+		return { dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			if (registered.status === "registered") registered.subscriptions.dispose();
+			else this.deactivate(manifest.id);
+			this.#extensions.delete(manifest.id);
+		} };
+	}
+	/** Lists registered extensions without exposing mutable host state. */
+	getExtensions() {
+		return Array.from(this.#extensions.values(), (registered) => registered.error ? {
+			manifest: registered.manifest,
+			status: registered.status,
+			error: registered.error
+		} : {
+			manifest: registered.manifest,
+			status: registered.status
+		});
+	}
+	/** Activates every extension that declared `event`. */
+	async activateByEvent(event) {
+		this.#assertActive();
+		const matching = [...this.#extensions.values()].filter((registered) => (registered.manifest.activationEvents ?? ["onStartup"]).includes(event));
+		await Promise.all(matching.map((registered) => this.#activate(registered)));
+	}
+	/** Activates one extension by id. */
+	async activate(extensionId$1) {
+		this.#assertActive();
+		const registered = this.#extensions.get(extensionId$1);
+		if (!registered) throw new Error(`Extension is not registered: ${extensionId$1}`);
+		await this.#activate(registered);
+	}
+	/** Deactivates one extension and releases its registered resources. */
+	async deactivate(extensionId$1) {
+		const registered = this.#extensions.get(extensionId$1);
+		if (!registered || registered.status === "registered") return false;
+		try {
+			await registered.extension.deactivate?.();
+		} finally {
+			registered.subscriptions.dispose();
+			registered.status = "registered";
+			registered.error = void 0;
+			registered.activatePromise = void 0;
+		}
+		return true;
+	}
+	/** Deactivates every extension and blocks further registration. */
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		for (const [id] of this.#extensions) this.deactivate(id);
+		this.#extensions.clear();
+	}
+	async #activate(registered) {
+		if (registered.status === "active") return;
+		if (registered.activatePromise) return registered.activatePromise;
+		registered.status = "activating";
+		registered.activatePromise = (async () => {
+			try {
+				const subscriptions = [];
+				const push = subscriptions.push.bind(subscriptions);
+				subscriptions.push = (...items) => {
+					for (const item of items) registered.subscriptions.add(item);
+					return push(...items);
+				};
+				const context = {
+					manifest: registered.manifest,
+					subscriptions,
+					hudhod: this.#hudhod
+				};
+				await registered.extension.activate(context);
+				registered.status = "active";
+			} catch (error) {
+				registered.status = "failed";
+				registered.error = error instanceof Error ? error.message : String(error);
+				registered.subscriptions.dispose();
+				throw error;
+			} finally {
+				registered.activatePromise = void 0;
+			}
+		})();
+		return registered.activatePromise;
+	}
+	#assertActive() {
+		if (this.#disposed) throw new Error("Extension host is disposed");
+	}
+};
+
+//#endregion
+//#region src/panels/panel-registry.ts
+/**
+* Registers and lists contributed panels.
+*
+* @example
+* ```ts
+* const panels = new PanelRegistry();
+* const sub = panels.registerPanel(
+*   { id: "demo.logs", title: "Logs" },
+*   { extensionId: "demo" },
+* );
+* panels.getPanels();
+* // => [{ id: "demo.logs", title: "Logs", location: "bottom", source: "extension", extensionId: "demo" }]
+* sub.dispose();
+* ```
+*/
+var PanelRegistry = class {
+	#stack = /* @__PURE__ */ new Map();
+	#changeEmitter = new Emitter();
+	/** Fires whenever the panel catalog changes. */
+	onDidChangePanels = (listener) => this.#changeEmitter.event(listener);
+	/**
+	* Registers a panel contribution.
+	*
+	* If the same id is already registered, this replaces it. Disposing the returned
+	* {@link Disposable} restores the previous registration.
+	*/
+	registerPanel(contribution, options) {
+		const info = {
+			id: contribution.id,
+			title: contribution.title,
+			icon: contribution.icon,
+			location: contribution.location ?? "bottom",
+			source: options?.source ?? "extension",
+			extensionId: options?.extensionId
+		};
+		let stack = this.#stack.get(info.id);
+		if (!stack) {
+			stack = [];
+			this.#stack.set(info.id, stack);
+		}
+		stack.push(info);
+		this.#fireChange();
+		let disposed = false;
+		return { dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const current = this.#stack.get(info.id);
+			if (!current) return;
+			const idx = current.indexOf(info);
+			if (idx >= 0) current.splice(idx, 1);
+			if (current.length === 0) this.#stack.delete(info.id);
+			this.#fireChange();
+		} };
+	}
+	/** Lists the active panel per id, sorted by id for stable UI ordering. */
+	getPanels() {
+		const result = [];
+		for (const stack of this.#stack.values()) {
+			const top = stack[stack.length - 1];
+			if (top) result.push(top);
+		}
+		return result.sort((a, b) => a.id.localeCompare(b.id));
+	}
+	/** Removes all registered panels and listeners. */
+	dispose() {
+		const changed = this.#stack.size > 0;
+		this.#stack.clear();
+		if (changed) this.#fireChange();
+		this.#changeEmitter.dispose();
+	}
+	#fireChange() {
+		this.#changeEmitter.fire(this.getPanels());
+	}
+};
+
+//#endregion
+//#region src/views/view-registry.ts
+/** Tracks contributed views independently from activity-bar containers. */
+var ViewRegistry = class {
+	#stack = /* @__PURE__ */ new Map();
+	#changeEmitter = new Emitter();
+	#nextRegistrationOrder = 0;
+	onDidChangeViews = (listener) => this.#changeEmitter.event(listener);
+	registerView(contribution, options) {
+		const info = {
+			...contribution,
+			source: options?.source ?? "extension",
+			extensionId: options?.extensionId,
+			registrationOrder: this.#nextRegistrationOrder++
+		};
+		const stack = this.#stack.get(info.id) ?? [];
+		this.#stack.set(info.id, stack);
+		stack.push(info);
+		this.#fireChange();
+		let disposed = false;
+		return { dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const current = this.#stack.get(info.id);
+			if (!current) return;
+			const index = current.indexOf(info);
+			if (index >= 0) current.splice(index, 1);
+			if (current.length === 0) this.#stack.delete(info.id);
+			this.#fireChange();
+		} };
+	}
+	getViews() {
+		return [...this.#stack.values()].map((stack) => stack.at(-1)).filter((view) => view !== void 0).sort((left, right) => {
+			if (left.order === void 0 && right.order !== void 0) return 1;
+			if (left.order !== void 0 && right.order === void 0) return -1;
+			if (left.order !== void 0 && right.order !== void 0 && left.order !== right.order) return left.order - right.order;
+			return left.registrationOrder - right.registrationOrder;
+		});
+	}
+	getViewsForContainer(containerId) {
+		return this.getViews().filter((view) => view.container === containerId);
+	}
+	dispose() {
+		const changed = this.#stack.size > 0;
+		this.#stack.clear();
+		if (changed) this.#fireChange();
+		this.#changeEmitter.dispose();
+	}
+	#fireChange() {
+		this.#changeEmitter.fire(this.getViews());
+	}
+};
+
+//#endregion
+//#region src/base/glob.ts
+/** Matches nothing. */
+const MATCH_NONE = () => false;
+/**
+* Compiles glob patterns into a matcher.
+*
+* Patterns are matched against the path **without its leading slash**, so
+* `src/**` and `**\/*.ts` behave the way authors expect. Matching is
+* case-insensitive on the basename only where picomatch defaults apply; dotfiles
+* are matched, unlike shell globbing, because hiding `.env` from a search would
+* be surprising.
+*
+* An empty pattern list yields a matcher that never matches, so callers can
+* treat "no excludes" as "exclude nothing" without a special case.
+*
+* @example
+* ```ts
+* const isExcluded = createMatcher(["**\/node_modules/**"]);
+* isExcluded("/node_modules/react/index"); // true
+* ```
+*/
+function createMatcher(patterns) {
+	if (patterns.length === 0) return MATCH_NONE;
+	const isMatch = picomatch([...patterns], { dot: true });
+	return (path) => {
+		const relative = path.startsWith("/") ? path.slice(1) : path;
+		if (relative.length === 0) return false;
+		return isMatch(relative);
+	};
+}
+/**
+* Compiles patterns into a matcher that *inverts* an empty pattern list.
+*
+* Used for include patterns, where "no filter" means "everything".
+*/
+function createIncludeMatcher(patterns) {
+	if (!patterns || patterns.length === 0) return () => true;
+	return createMatcher(patterns);
+}
+
+//#endregion
+//#region src/workspace/config.ts
+/**
+* Workspace-wide configuration.
+*
+* These defaults were previously hardcoded inside the file system layer, which
+* meant a caller could not search `node_modules` even when they wanted to.
+* Hoisting them here makes the policy explicit and overridable — per workspace
+* and per call.
+*
+* @packageDocumentation
+*/
+/** Glob patterns excluded from directory listings and the file tree. */
+const DEFAULT_FILES_EXCLUDE = ["**/.git/**", "**/node_modules/**"];
+/** Glob patterns excluded from search. Broader than the tree exclusions. */
+const DEFAULT_SEARCH_EXCLUDE = [
+	"**/.git/**",
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.next/**",
+	"**/coverage/**",
+	"**/*.lock",
+	"**/pnpm-lock.yaml",
+	"**/package-lock.json"
+];
+/** Glob patterns whose changes are ignored by watchers. */
+const DEFAULT_WATCHER_EXCLUDE = [
+	"**/.git/**",
+	"**/node_modules/**",
+	"**/.next/**"
+];
+/**
+* Patterns omitted when snapshotting a workspace for storage.
+*
+* Everything here is either reproducible from `package.json` or machine-local.
+*/
+const DEFAULT_SNAPSHOT_EXCLUDE = [
+	"**/.git/**",
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.next/**",
+	"**/package-lock.json"
+];
+/**
+* Builds a {@link WorkspaceConfig}, filling in defaults.
+*
+* @example
+* ```ts
+* // Search node_modules too, but keep every other default.
+* const config = createWorkspaceConfig({ searchExclude: ["**\/.git/**"] });
+* ```
+*/
+function createWorkspaceConfig(overrides = {}) {
+	return {
+		rootPath: overrides.rootPath ?? "/",
+		filesExclude: overrides.filesExclude ?? DEFAULT_FILES_EXCLUDE,
+		searchExclude: overrides.searchExclude ?? DEFAULT_SEARCH_EXCLUDE,
+		watcherExclude: overrides.watcherExclude ?? DEFAULT_WATCHER_EXCLUDE,
+		snapshotExclude: overrides.snapshotExclude ?? DEFAULT_SNAPSHOT_EXCLUDE,
+		maxSearchFileBytes: overrides.maxSearchFileBytes ?? 2 * 1024 * 1024
+	};
+}
+
+//#endregion
+//#region src/fs/file-system-service.ts
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+/** How long to collect change events before delivering a batch. */
+const CHANGE_DEBOUNCE_MS = 20;
+/**
+* Reads and writes workspace files.
+*
+* @example
+* ```ts
+* const fs = new FileSystemService(new InMemoryFileSystemProvider());
+* await fs.writeTextFile("/src/a.ts", "export const a = 1;");
+* await fs.readTextFile("/src/a.ts");
+* ```
+*/
+var FileSystemService = class {
+	#provider;
+	#config;
+	#debounceMs;
+	#store = new DisposableStore();
+	#changeEmitter = new Emitter();
+	#isWatcherExcluded;
+	#isFileExcluded;
+	#pending = [];
+	#flushHandle;
+	#rootWatch;
+	constructor(provider, options = {}) {
+		this.#provider = provider;
+		this.#config = options.config ?? createWorkspaceConfig();
+		this.#debounceMs = options.debounceMs ?? CHANGE_DEBOUNCE_MS;
+		this.#isWatcherExcluded = createMatcher(this.#config.watcherExclude);
+		this.#isFileExcluded = createMatcher(this.#config.filesExclude);
+		this.#store.add(this.#changeEmitter);
+	}
+	/** The workspace policy in force. */
+	get config() {
+		return this.#config;
+	}
+	/**
+	* Fires for every change in the workspace, after exclusion filtering and
+	* debouncing.
+	*
+	* The underlying provider watch is established lazily on first subscription
+	* and torn down when the last listener leaves, so an idle workspace does no
+	* watching at all.
+	*/
+	onDidChangeFile = (listener) => {
+		this.#ensureRootWatch();
+		const subscription = this.#changeEmitter.event(listener);
+		return toDisposable(() => {
+			subscription.dispose();
+			if (this.#changeEmitter.listenerCount === 0) {
+				this.#rootWatch?.dispose();
+				this.#rootWatch = void 0;
+			}
+		});
+	};
+	async readFile(path) {
+		return this.#provider.readFile(normalizePath(path));
+	}
+	async readTextFile(path) {
+		return decoder.decode(await this.readFile(path));
+	}
+	async writeFile(path, data, options = {}) {
+		const target = normalizePath(path);
+		const exists = await this.exists(target);
+		if (exists && options.overwrite === false) throw fileExists(target);
+		if (!exists && options.create === false) throw fileNotFound(target);
+		if (options.createParents !== false) await this.createDirectory(dirname(target));
+		await this.#provider.writeFile(target, data);
+	}
+	async writeTextFile(path, content, options = {}) {
+		await this.writeFile(path, encoder.encode(content), options);
+	}
+	async createFile(path, options = {}) {
+		await this.writeFile(path, new Uint8Array(0), {
+			overwrite: false,
+			...options
+		});
+	}
+	/** Creates a directory and every missing ancestor. Succeeds if it exists. */
+	async createDirectory(path) {
+		const target = normalizePath(path);
+		if (target === ROOT) return;
+		const missing = [];
+		for (let current = target; current !== ROOT; current = dirname(current)) {
+			if (await this.exists(current)) break;
+			missing.push(current);
+		}
+		for (let index = missing.length - 1; index >= 0; index -= 1) {
+			const directory = missing[index];
+			if (!directory) continue;
+			await this.#provider.createDirectory(directory);
+		}
+	}
+	async delete(path, options = {}) {
+		await this.#provider.delete(normalizePath(path), { recursive: options.recursive ?? false });
+	}
+	async rename(from, to, options = {}) {
+		const target = normalizePath(to);
+		await this.createDirectory(dirname(target));
+		await this.#provider.rename(normalizePath(from), target, { overwrite: options.overwrite ?? false });
+	}
+	async copy(from, to, options = {}) {
+		const source = normalizePath(from);
+		const target = normalizePath(to);
+		if (!(options.overwrite ?? false) && await this.exists(target)) throw fileExists(target);
+		if ((await this.stat(source)).type !== "directory") {
+			await this.writeFile(target, await this.#provider.readFile(source), { overwrite: true });
+			return;
+		}
+		await this.createDirectory(target);
+		for (const entry of await this.#provider.readDirectory(source)) await this.copy(joinPath(source, entry.name), joinPath(target, entry.name), options);
+	}
+	async stat(path) {
+		return this.#provider.stat(normalizePath(path));
+	}
+	async exists(path) {
+		try {
+			await this.#provider.stat(normalizePath(path));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Lists a directory, hiding entries matched by `filesExclude` and sorting
+	* directories first, then by name.
+	*/
+	async readDirectory(path) {
+		return this.listDirectory(path, { applyExcludes: true });
+	}
+	/**
+	* Lists a directory, optionally without applying `filesExclude`.
+	*
+	* `filesExclude` is a presentation policy — it governs what the file tree
+	* shows. Search has its own `searchExclude`, so it must be able to walk the
+	* unfiltered listing; otherwise a caller could never search `node_modules`
+	* even by explicitly clearing the search exclusions.
+	*/
+	async listDirectory(path, options) {
+		const target = normalizePath(path);
+		return sortedBy$1((await this.#provider.readDirectory(target)).map((entry) => ({
+			name: entry.name,
+			path: joinPath(target, entry.name),
+			type: entry.type
+		})).filter((entry) => !options.applyExcludes || !this.#isFileExcluded(entry.path)), compareEntries);
+	}
+	watch(path, listener, options = {}) {
+		const target = normalizePath(path);
+		const isExcluded = options.excludes ? createMatcher(options.excludes) : this.#isWatcherExcluded;
+		return this.#provider.watch(target, { recursive: options.recursive ?? true }, (events) => {
+			const relevant = events.filter((event) => !isExcluded(event.path));
+			if (relevant.length > 0) listener(relevant);
+		});
+	}
+	/** Stops watching and releases listeners. */
+	dispose() {
+		if (this.#flushHandle !== void 0) clearTimeout(this.#flushHandle);
+		this.#rootWatch?.dispose();
+		this.#rootWatch = void 0;
+		this.#store.dispose();
+	}
+	/** Starts the workspace-wide watch, if it is not already running. */
+	#ensureRootWatch() {
+		if (this.#rootWatch) return;
+		this.#rootWatch = this.#provider.watch(this.#config.rootPath, { recursive: true }, (events) => this.#queue(events));
+	}
+	/** Buffers events, filtering exclusions, and schedules a batched delivery. */
+	#queue(events) {
+		const relevant = events.filter((event) => !this.#isWatcherExcluded(event.path));
+		if (relevant.length === 0) return;
+		this.#pending.push(...relevant);
+		if (this.#debounceMs <= 0) {
+			this.#flush();
+			return;
+		}
+		if (this.#flushHandle !== void 0) return;
+		this.#flushHandle = setTimeout(() => this.#flush(), this.#debounceMs);
+	}
+	/** Delivers the buffered batch, collapsing repeats of the same path. */
+	#flush() {
+		if (this.#flushHandle !== void 0) {
+			clearTimeout(this.#flushHandle);
+			this.#flushHandle = void 0;
+		}
+		if (this.#pending.length === 0) return;
+		const batch = dedupeChanges(this.#pending);
+		this.#pending = [];
+		this.#changeEmitter.fire(batch);
+	}
+};
+/** Directories first, then case-insensitive name order. */
+function compareEntries(a, b) {
+	if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+	return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+function sortedBy$1(values, compare) {
+	const result = [];
+	for (const value of values) {
+		const index = result.findIndex((candidate) => compare(value, candidate) < 0);
+		if (index === -1) result.push(value);
+		else result.splice(index, 0, value);
+	}
+	return result;
+}
+/**
+* Collapses repeated events for one path, keeping the last.
+*
+* A create followed by a delete within the same tick means the file is gone;
+* reporting both would force every consumer to reason about ordering.
+*/
+function dedupeChanges(events) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const event of events) latest.set(event.path, event);
+	return [...latest.values()];
+}
+
+//#endregion
+//#region src/fs/in-memory-provider.ts
+/**
+* A complete file system held in a `Map`.
+*
+* @example
+* ```ts
+* const provider = new InMemoryFileSystemProvider();
+* await provider.createDirectory("/src");
+* await provider.writeFile("/src/a.ts", new TextEncoder().encode("export {};"));
+* ```
+*/
+var InMemoryFileSystemProvider = class InMemoryFileSystemProvider {
+	name = "in-memory";
+	#nodes = /* @__PURE__ */ new Map();
+	#watchers = /* @__PURE__ */ new Set();
+	#now;
+	constructor(options = {}) {
+		this.#now = options.now ?? Date.now;
+		this.#nodes.set(ROOT, {
+			type: "directory",
+			data: new Uint8Array(0),
+			mtime: this.#now()
+		});
+	}
+	/**
+	* Seeds the provider from a plain object, for concise test fixtures.
+	*
+	* Parent directories are created automatically.
+	*
+	* @example
+	* ```ts
+	* const provider = InMemoryFileSystemProvider.from({
+	*   "/package.json": "{}",
+	*   "/src/index.ts": "export const a = 1;",
+	* });
+	* ```
+	*/
+	static from(files, options = {}) {
+		const provider = new InMemoryFileSystemProvider(options);
+		const encoder$1 = new TextEncoder();
+		for (const [path, contents] of Object.entries(files)) {
+			provider.#ensureParents(path);
+			provider.#nodes.set(path, {
+				type: "file",
+				data: encoder$1.encode(contents),
+				mtime: provider.#now()
+			});
+		}
+		return provider;
+	}
+	/** Every path currently stored, sorted. Intended for test assertions. */
+	snapshot() {
+		return sortedBy(Array.from(this.#nodes.keys()), (left, right) => left.localeCompare(right));
+	}
+	async readFile(path) {
+		const node = this.#nodes.get(path);
+		if (!node) throw fileNotFound(path);
+		if (node.type === "directory") throw notAFile(path);
+		return node.data.slice();
+	}
+	async writeFile(path, data) {
+		const existing = this.#nodes.get(path);
+		if (existing?.type === "directory") throw notAFile(path);
+		const parent = dirname(path);
+		const parentNode = this.#nodes.get(parent);
+		if (!parentNode) throw fileNotFound(parent);
+		if (parentNode.type !== "directory") throw notADirectory(parent);
+		this.#nodes.set(path, {
+			type: "file",
+			data: data.slice(),
+			mtime: this.#now()
+		});
+		this.#emit([{
+			type: existing ? "changed" : "created",
+			path
+		}]);
+	}
+	async createDirectory(path) {
+		const existing = this.#nodes.get(path);
+		if (existing) {
+			if (existing.type === "directory") return;
+			throw fileExists(path);
+		}
+		const parent = dirname(path);
+		const parentNode = this.#nodes.get(parent);
+		if (!parentNode) throw fileNotFound(parent);
+		if (parentNode.type !== "directory") throw notADirectory(parent);
+		this.#nodes.set(path, {
+			type: "directory",
+			data: new Uint8Array(0),
+			mtime: this.#now()
+		});
+		this.#emit([{
+			type: "created",
+			path
+		}]);
+	}
+	async delete(path, options) {
+		const node = this.#nodes.get(path);
+		if (!node) throw fileNotFound(path);
+		if (node.type === "directory") {
+			const descendants = this.#descendantsOf(path);
+			if (descendants.length > 0 && !options.recursive) throw directoryNotEmpty(path);
+			const removed = [];
+			for (const descendant of descendants) {
+				this.#nodes.delete(descendant);
+				removed.push({
+					type: "deleted",
+					path: descendant
+				});
+			}
+			this.#nodes.delete(path);
+			removed.push({
+				type: "deleted",
+				path
+			});
+			this.#emit(removed);
+			return;
+		}
+		this.#nodes.delete(path);
+		this.#emit([{
+			type: "deleted",
+			path
+		}]);
+	}
+	async rename(from, to, options) {
+		if (!this.#nodes.get(from)) throw fileNotFound(from);
+		const destination = this.#nodes.get(to);
+		if (destination && !options.overwrite) throw fileExists(to);
+		const parent = dirname(to);
+		const parentNode = this.#nodes.get(parent);
+		if (!parentNode) throw fileNotFound(parent);
+		if (parentNode.type !== "directory") throw notADirectory(parent);
+		const events = [];
+		if (destination) for (const descendant of this.#descendantsOf(to)) {
+			this.#nodes.delete(descendant);
+			events.push({
+				type: "deleted",
+				path: descendant
+			});
+		}
+		const moves = [[from, to]];
+		for (const descendant of this.#descendantsOf(from)) moves.push([descendant, to + descendant.slice(from.length)]);
+		for (const [source, target] of moves) {
+			const moved = this.#nodes.get(source);
+			if (!moved) continue;
+			this.#nodes.delete(source);
+			this.#nodes.set(target, {
+				...moved,
+				mtime: this.#now()
+			});
+			events.push({
+				type: "deleted",
+				path: source
+			});
+			events.push({
+				type: "created",
+				path: target
+			});
+		}
+		this.#emit(events);
+	}
+	async stat(path) {
+		const node = this.#nodes.get(path);
+		if (!node) throw fileNotFound(path);
+		return {
+			type: node.type,
+			size: node.type === "directory" ? 0 : node.data.byteLength,
+			mtime: node.mtime
+		};
+	}
+	async readDirectory(path) {
+		const node = this.#nodes.get(path);
+		if (!node) throw fileNotFound(path);
+		if (node.type !== "directory") throw notADirectory(path);
+		const prefix = path === ROOT ? ROOT : `${path}/`;
+		const entries = [];
+		for (const [candidate, child] of this.#nodes) {
+			if (candidate === path) continue;
+			if (!candidate.startsWith(prefix)) continue;
+			if (candidate.slice(prefix.length).includes("/")) continue;
+			entries.push({
+				name: basename(candidate),
+				type: child.type
+			});
+		}
+		return entries;
+	}
+	watch(path, options, listener) {
+		const watcher = {
+			path,
+			recursive: options.recursive,
+			listener
+		};
+		this.#watchers.add(watcher);
+		return toDisposable(() => {
+			this.#watchers.delete(watcher);
+		});
+	}
+	/** Creates any missing ancestor directories of `path`. */
+	#ensureParents(path) {
+		const parent = dirname(path);
+		if (parent === ROOT || this.#nodes.has(parent)) return;
+		this.#ensureParents(parent);
+		this.#nodes.set(parent, {
+			type: "directory",
+			data: new Uint8Array(0),
+			mtime: this.#now()
+		});
+	}
+	/** Every path strictly beneath `path`, deepest first so deletion is safe. */
+	#descendantsOf(path) {
+		const prefix = path === ROOT ? ROOT : `${path}/`;
+		return sortedBy(Array.from(this.#nodes.keys()).filter((candidate) => candidate !== path && candidate.startsWith(prefix)), (left, right) => right.length - left.length);
+	}
+	/** Delivers events to watchers whose scope covers them. */
+	#emit(events) {
+		if (events.length === 0) return;
+		for (const watcher of this.#watchers) {
+			const relevant = events.filter((event) => watcher.recursive ? isSubPath(watcher.path, event.path) : dirname(event.path) === watcher.path);
+			if (relevant.length > 0) watcher.listener(relevant);
+		}
+	}
+};
+function sortedBy(values, compare) {
+	const result = [];
+	for (const value of values) {
+		const index = result.findIndex((candidate) => compare(value, candidate) < 0);
+		if (index === -1) result.push(value);
+		else result.splice(index, 0, value);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/process/fake-spawner.ts
+/** Exit code reported for a killed process. */
+const KILLED_EXIT_CODE = 137;
+/**
+* A spawner that replays scripted behaviour.
+*
+* @example
+* ```ts
+* const spawner = new FakeProcessSpawner();
+* spawner.register("node", { output: ["v22.0.0\n"] });
+* const { output } = await new ProcessService(spawner).exec("node", ["-v"]);
+* ```
+*/
+var FakeProcessSpawner = class {
+	name = "fake";
+	#behaviours = /* @__PURE__ */ new Map();
+	#spawns = [];
+	#fallback = {
+		output: [],
+		exitCode: 0
+	};
+	/** Every spawn that has been requested, in order. */
+	get spawns() {
+		return this.#spawns;
+	}
+	/** Scripts a command, keyed by executable name. */
+	register(command, behaviour) {
+		this.#behaviours.set(command, behaviour);
+		return this;
+	}
+	/** Sets the behaviour used for unregistered commands. */
+	setFallback(behaviour) {
+		this.#fallback = behaviour;
+		return this;
+	}
+	async spawn(command, args, options) {
+		this.#spawns.push({
+			command,
+			args: [...args],
+			options
+		});
+		const behaviour = this.#behaviours.get(command) ?? this.#fallback;
+		let killed = false;
+		let onKilled = () => {};
+		const killedSignal = new Promise((resolve) => {
+			onKilled = resolve;
+		});
+		const chunks = behaviour.output ?? [];
+		const output = new ReadableStream({ async start(controller) {
+			for (const chunk of chunks) {
+				if (killed) break;
+				controller.enqueue(chunk);
+			}
+			if (behaviour.neverExits && !killed) await killedSignal;
+			controller.close();
+		} });
+		const exit = (async () => {
+			if (behaviour.neverExits) {
+				await killedSignal;
+				return KILLED_EXIT_CODE;
+			}
+			if (behaviour.delayMs) await Promise.race([new Promise((resolve) => setTimeout(resolve, behaviour.delayMs)), killedSignal]);
+			return killed ? KILLED_EXIT_CODE : behaviour.exitCode ?? 0;
+		})();
+		return {
+			output,
+			input: new WritableStream(),
+			exit,
+			kill() {
+				if (killed) return;
+				killed = true;
+				onKilled();
+			},
+			resize() {}
+		};
+	}
+};
+
+//#endregion
+//#region src/process/process-service.ts
+/** Default wall-clock limit for {@link ProcessService.exec}. */
+const DEFAULT_EXEC_TIMEOUT_MS = 6e4;
+/** Default output cap for {@link ProcessService.exec}, in bytes. */
+const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+/**
+* Spawns and supervises processes.
+*
+* @example
+* ```ts
+* const processes = new ProcessService(spawner);
+* const { exitCode, output } = await processes.exec("node", ["-v"]);
+* ```
+*/
+var ProcessService = class {
+	#spawner;
+	#now;
+	#tracked = /* @__PURE__ */ new Map();
+	#store = new DisposableStore();
+	#startEmitter = new Emitter();
+	#exitEmitter = new Emitter();
+	#nextId = 1;
+	constructor(spawner, options = {}) {
+		this.#spawner = spawner;
+		this.#now = options.now ?? Date.now;
+		this.#store.add(this.#startEmitter);
+		this.#store.add(this.#exitEmitter);
+	}
+	/** Fires whenever a process starts. */
+	onDidStartProcess = (listener) => this.#startEmitter.event(listener);
+	/** Fires whenever a process exits, for any reason. */
+	onDidExitProcess = (listener) => this.#exitEmitter.event(listener);
+	async spawn(command, args = [], options = {}) {
+		const process = await this.#spawner.spawn(command, args, options);
+		const id = `p${this.#nextId++}`;
+		const tracked = {
+			info: {
+				id,
+				command,
+				args: [...args],
+				startedAt: this.#now(),
+				status: "running"
+			},
+			process
+		};
+		this.#tracked.set(id, tracked);
+		this.#startEmitter.fire({ ...tracked.info });
+		process.exit.then((exitCode) => this.#settle(id, exitCode), () => this.#settle(id, -1));
+		return this.#toHandle(tracked);
+	}
+	async exec(command, args = [], options = {}) {
+		const timeout = options.timeout ?? DEFAULT_EXEC_TIMEOUT_MS;
+		const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+		const startedAt = this.#now();
+		const handle = await this.spawn(command, args, options);
+		let output = "";
+		let bytes = 0;
+		let truncated = false;
+		const encoder$1 = new TextEncoder();
+		let timedOut = false;
+		const timer = timeout === false ? void 0 : setTimeout(() => {
+			timedOut = true;
+			handle.kill();
+		}, timeout);
+		try {
+			const reader = handle.output.getReader();
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (value === void 0) continue;
+					output += value;
+					if (maxOutputBytes !== false) {
+						bytes += encoder$1.encode(value).length;
+						if (bytes > maxOutputBytes) {
+							truncated = true;
+							handle.kill();
+							break;
+						}
+					}
+				}
+			} finally {
+				reader.releaseLock();
+			}
+			const exitCode = await handle.exit;
+			if (timedOut) throw createError("ProcessTimeout", `Command "${describe(command, args)}" exceeded its ${String(timeout)}ms timeout and was killed`, { partialOutput: output });
+			if (truncated) throw createError("OutputLimitExceeded", `Command "${describe(command, args)}" exceeded its ${String(maxOutputBytes)}-byte output limit and was killed`, { partialOutput: output });
+			return {
+				exitCode,
+				output,
+				truncated: false,
+				durationMs: this.#now() - startedAt
+			};
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+		}
+	}
+	async list() {
+		return Array.from(this.#tracked.values(), ({ info }) => ({
+			id: info.id,
+			command: info.command,
+			args: info.args,
+			startedAt: info.startedAt,
+			status: info.status,
+			exitCode: info.exitCode
+		}));
+	}
+	async kill(id) {
+		const tracked = this.#tracked.get(id);
+		if (!tracked || tracked.info.status !== "running") return false;
+		tracked.info.status = "killed";
+		tracked.process.kill();
+		return true;
+	}
+	/** Kills every running process and releases listeners. */
+	dispose() {
+		for (const tracked of this.#tracked.values()) if (tracked.info.status === "running") tracked.process.kill();
+		this.#tracked.clear();
+		this.#store.dispose();
+	}
+	/** Records the exit and notifies listeners, at most once per process. */
+	#settle(id, exitCode) {
+		const tracked = this.#tracked.get(id);
+		if (!tracked || tracked.info.status !== "running") {
+			if (tracked && tracked.info.exitCode === void 0) {
+				tracked.info.exitCode = exitCode;
+				this.#exitEmitter.fire({ ...tracked.info });
+			}
+			return;
+		}
+		tracked.info.status = "exited";
+		tracked.info.exitCode = exitCode;
+		this.#exitEmitter.fire({ ...tracked.info });
+	}
+	/** Projects internal bookkeeping into the public handle shape. */
+	#toHandle(tracked) {
+		return {
+			get id() {
+				return tracked.info.id;
+			},
+			get command() {
+				return tracked.info.command;
+			},
+			get args() {
+				return tracked.info.args;
+			},
+			get startedAt() {
+				return tracked.info.startedAt;
+			},
+			get status() {
+				return tracked.info.status;
+			},
+			get exitCode() {
+				return tracked.info.exitCode;
+			},
+			output: tracked.process.output,
+			input: tracked.process.input,
+			exit: tracked.process.exit,
+			kill: () => {
+				this.kill(tracked.info.id);
+			},
+			resize: (dimensions) => {
+				tracked.process.resize(dimensions);
+			}
+		};
+	}
+};
+/** Renders a command and its arguments for error messages. */
+function describe(command, args) {
+	return [command, ...args].join(" ");
+}
+
+//#endregion
+//#region src/search/search-service.ts
+/** Default cap on results, matching the SDK documentation. */
+const DEFAULT_MAX_RESULTS = 1e3;
+/** Characters with special meaning in a regular expression. */
+const REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+/** Escapes a literal string for safe use inside a regular expression. */
+function escapeRegExp(value) {
+	return value.replace(REGEX_SPECIAL, "\\$&");
+}
+/**
+* Builds the matcher used to scan file contents.
+*
+* Always global, so every match on a line is found rather than just the first.
+*
+* @throws A `TypeError` when `isRegex` is set and the pattern is malformed.
+*/
+function buildQueryRegExp(query, options) {
+	const source = options.isRegex ? query : escapeRegExp(query);
+	const pattern = options.wholeWord ? `\\b(?:${source})\\b` : source;
+	const flags = options.caseSensitive ? "g" : "gi";
+	return new RegExp(pattern, flags);
+}
+/**
+* Finds files and searches their contents.
+*
+* @example
+* ```ts
+* const search = new SearchService(fs);
+* const paths = await search.findFiles("src/**\/*.ts");
+* const { matches } = await search.findInFiles("TODO");
+* ```
+*/
+var SearchService = class {
+	#fs;
+	constructor(fileSystem) {
+		this.#fs = fileSystem;
+	}
+	async findFiles(include, options = {}) {
+		const isIncluded = createMatcher([include]);
+		const isExcluded = createMatcher(options.exclude ?? this.#fs.config.searchExclude);
+		const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;
+		const found = [];
+		await this.#walk(this.#fs.config.rootPath, isExcluded, options, (path) => {
+			if (!isIncluded(path)) return true;
+			found.push(path);
+			return found.length < maxResults;
+		});
+		return found;
+	}
+	async findInFiles(query, options = {}) {
+		if (query.length === 0) return {
+			matches: [],
+			limitHit: false
+		};
+		const isIncluded = createIncludeMatcher(options.include);
+		const isExcluded = createMatcher(options.exclude ?? this.#fs.config.searchExclude);
+		const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;
+		const pattern = buildQueryRegExp(query, options);
+		const matches = [];
+		let limitHit = false;
+		await this.#walk(this.#fs.config.rootPath, isExcluded, options, async (path) => {
+			if (!isIncluded(path)) return true;
+			const contents = await this.#readSearchable(path);
+			if (contents === void 0) return true;
+			for (const match of matchesIn(path, contents, pattern)) {
+				matches.push(match);
+				if (matches.length >= maxResults) {
+					limitHit = true;
+					return false;
+				}
+			}
+			return true;
+		});
+		return {
+			matches,
+			limitHit
+		};
+	}
+	async replaceInFiles(query, replacement, options = {}) {
+		const { matches } = await this.findInFiles(query, options);
+		const paths = [...new Set(matches.map((match) => match.path))];
+		const pattern = buildQueryRegExp(query, options);
+		for (const path of paths) {
+			const contents = await this.#fs.readTextFile(path);
+			pattern.lastIndex = 0;
+			await this.#fs.writeTextFile(path, contents.replace(pattern, replacement));
+		}
+		return paths.length;
+	}
+	/**
+	* Reads a file for searching, skipping anything unsuitable.
+	*
+	* Returns `undefined` for files that are too large or that appear to be
+	* binary, so the caller can move on without special-casing either.
+	*/
+	async #readSearchable(path) {
+		if ((await this.#fs.stat(path)).size > this.#fs.config.maxSearchFileBytes) return void 0;
+		const contents = await this.#fs.readTextFile(path);
+		if (contents.slice(0, 8e3).includes("\0")) return void 0;
+		return contents;
+	}
+	/**
+	* Depth-first walk of every file beneath `directory`.
+	*
+	* `visit` returns `false` to stop the walk early. Directories matched by
+	* `isExcluded` are skipped whole, so excluding `node_modules` costs one check
+	* rather than a traversal of everything inside it.
+	*/
+	async #walk(directory, isExcluded, options, visit) {
+		if (options.token?.isCancellationRequested) return false;
+		let entries;
+		try {
+			entries = await this.#fs.listDirectory(directory, { applyExcludes: false });
+		} catch {
+			return true;
+		}
+		for (const entry of entries) {
+			if (options.token?.isCancellationRequested) return false;
+			if (isExcluded(entry.path)) continue;
+			if (entry.type === "directory") {
+				if (!await this.#walk(entry.path, isExcluded, options, visit)) return false;
+				continue;
+			}
+			if (!await visit(entry.path)) return false;
+		}
+		return true;
+	}
+};
+/** Yields every match of `pattern` in `contents`, with line and column. */
+function* matchesIn(path, contents, pattern) {
+	const lines = contents.split("\n");
+	for (const [index, line] of lines.entries()) {
+		pattern.lastIndex = 0;
+		let match;
+		while ((match = pattern.exec(line)) !== null) {
+			yield {
+				path,
+				line: index + 1,
+				column: match.index,
+				length: match[0].length,
+				preview: line
+			};
+			if (match[0].length === 0) pattern.lastIndex += 1;
+		}
+	}
+}
+
+//#endregion
+//#region src/runtime/runtime.ts
+const unavailableWorkspace = {
+	rootPath: "/",
+	async applyEdit() {
+		throw new Error("Workspace API is not configured");
+	},
+	async revertEdit() {
+		throw new Error("Workspace API is not configured");
+	},
+	async editHistory() {
+		return [];
+	},
+	onDidApplyEdit: () => ({ dispose() {} })
+};
+const unavailableTerminal = {
+	async create() {
+		throw new Error("Terminal API is not configured");
+	},
+	terminals: [],
+	onDidOpenTerminal: () => ({ dispose() {} }),
+	onDidCloseTerminal: () => ({ dispose() {} })
+};
+/** Creates an environment-agnostic Hudhod runtime from host-provided adapters. */
+function createHudhodRuntime(options) {
+	const fs = new FileSystemService(options.fileSystemProvider);
+	const process = new ProcessService(options.processSpawner);
+	const commands = new CommandRegistry();
+	const keybindings = new KeybindingRegistry(options.platform ?? "other");
+	const panels = new PanelRegistry();
+	const views = new ViewRegistry();
+	const window = new WindowService(options.windowUiProvider);
+	const search = new SearchService(fs);
+	const diff = new DiffService(fs);
+	const api = {
+		version: options.version ?? "0.1.0",
+		fs,
+		workspace: options.workspace ?? unavailableWorkspace,
+		search,
+		diff,
+		process,
+		terminal: options.terminal ?? unavailableTerminal,
+		commands,
+		keybindings,
+		window
+	};
+	const extensions = new InProcessExtensionHost(api, {
+		panels,
+		views
+	});
+	let disposed = false;
+	return {
+		fs,
+		search,
+		diff,
+		process,
+		commands,
+		keybindings,
+		panels,
+		views,
+		window,
+		extensions,
+		api,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			extensions.dispose();
+			window.dispose();
+			views.dispose();
+			panels.dispose();
+			keybindings.dispose();
+			commands.dispose();
+			process.dispose();
+			fs.dispose();
+		}
+	};
+}
+
+//#endregion
+//#region src/services/service-registry.ts
+/** Creates a typed service identifier. */
+function createServiceIdentifier(description) {
+	return {
+		description,
+		key: Symbol(description)
+	};
+}
+/**
+* Owns workspace-scoped services.
+*
+* @example
+* ```ts
+* const fsId = createServiceIdentifier<FileSystemService>("fs");
+* const services = new ServiceRegistry();
+* services.register(fsId, () => new FileSystemService(provider));
+* const fs = services.get(fsId);
+* ```
+*/
+var ServiceRegistry = class {
+	#factories = /* @__PURE__ */ new Map();
+	#instances = /* @__PURE__ */ new Map();
+	#disposables = new DisposableStore();
+	#disposed = false;
+	/** Registers a lazy factory for a service. */
+	register(identifier, factory) {
+		this.#assertActive();
+		if (this.#factories.has(identifier.key)) throw new Error(`Service already registered: ${identifier.description}`);
+		this.#factories.set(identifier.key, factory);
+	}
+	/** Retrieves and lazily creates a registered service. */
+	get(identifier) {
+		this.#assertActive();
+		const existing = this.#instances.get(identifier.key);
+		if (existing !== void 0) return existing;
+		const factory = this.#factories.get(identifier.key);
+		if (!factory) throw new Error(`Service not registered: ${identifier.description}`);
+		const instance = factory(this);
+		this.#instances.set(identifier.key, instance);
+		if (isDisposable(instance)) this.#disposables.add(instance);
+		return instance;
+	}
+	/** Whether a service factory is registered. */
+	has(identifier) {
+		return this.#factories.has(identifier.key);
+	}
+	/** Releases every created disposable service in reverse creation order. */
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#instances.clear();
+		this.#factories.clear();
+		this.#disposables.dispose();
+	}
+	#assertActive() {
+		if (this.#disposed) throw new Error("Service registry is disposed");
+	}
+};
+function isDisposable(value) {
+	return typeof value === "object" && value !== null && "dispose" in value && typeof value.dispose === "function";
+}
+
+//#endregion
+export { CancellationTokenNone, CancellationTokenSource, CommandRegistry, DEFAULT_EXEC_TIMEOUT_MS, DEFAULT_FILES_EXCLUDE, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_SEARCH_EXCLUDE, DEFAULT_SNAPSHOT_EXCLUDE, DEFAULT_WATCHER_EXCLUDE, DiffService, DisposableStore, Emitter, FakeProcessSpawner, FileSystemService, InMemoryFileSystemProvider, InProcessExtensionHost, KeybindingRegistry, NO_OP_DISPOSABLE, PanelRegistry, ProcessService, ROOT, SearchService, ServiceRegistry, ViewRegistry, WindowService, basename, createError, createHudhodRuntime, createServiceIdentifier, createWorkspaceConfig, directoryNotEmpty, dirname, extensionManifestSchema, extname, fileExists, fileNotFound, invalidPath, isSubPath, joinPath, keybindingFromEvent, keybindingToString, normalizePath, notADirectory, notAFile, parseExtensionManifest, parseKeybinding, pathSegments, relativePath, toDisposable, tokenFromAbortSignal };