@hudhod/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1017 @@
+import { a as ProviderEntry, i as FileSystemProvider, n as SpawnedProcess, o as ProviderStat, r as SpawnerOptions, s as ProviderWatchOptions, t as ProcessSpawner } from "./spawner-CqGITKbd.js";
+import { z } from "zod";
+import { ActivationEvent, ActiveEditor, CancellationToken, CommandDescriptor, CommandsApi, DeleteOptions, DiffApi, DiffChange, DiffOptions, DiffStat, DirectoryEntry, Disposable, Event, ExecOptions, ExecResult, Extension, ExtensionManifest, FileChangeEvent, FileStat, FileSystemApi, FindFilesOptions, FindInFilesOptions, HudhodApi, HudhodError, HudhodErrorCode, InputBoxOptions, KeybindingContribution, MessageSeverity, MoveOptions, PanelContribution, PanelRenderer, ProcessApi, ProcessHandle, ProcessInfo, QuickPickItem, QuickPickOptions, RegisterCommandOptions, RegisterPanelOptions, RegisterViewOptions, ResolvedKeybinding, SearchApi, SearchResult, SpawnOptions, TerminalApi, ViewContribution, WatchOptions, WindowApi, WorkspaceApi, WriteFileOptions } from "@hudhod/sdk";
+
+//#region src/base/cancellation.d.ts
+
+/** A token that is never cancelled. Useful as a default parameter. */
+declare const CancellationTokenNone: CancellationToken;
+/**
+ * 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();
+ * ```
+ */
+declare class CancellationTokenSource implements Disposable {
+  #private;
+  /** The token to hand to cancellable operations. */
+  readonly token: CancellationToken;
+  constructor();
+  /** Whether cancellation has been requested. */
+  get isCancellationRequested(): boolean;
+  /** Requests cancellation. Subsequent calls are no-ops. */
+  cancel(): void;
+  /** Releases listeners without cancelling. */
+  dispose(): void;
+}
+/**
+ * Adapts an {@link AbortSignal} into a {@link CancellationToken}.
+ *
+ * Lets callers pass the platform-standard signal to hudhod APIs.
+ */
+declare function tokenFromAbortSignal(signal: AbortSignal): CancellationToken;
+//#endregion
+//#region src/base/disposable.d.ts
+/**
+ * Wraps a callback as a {@link Disposable} that runs at most once.
+ *
+ * @example
+ * ```ts
+ * const sub = toDisposable(() => clearInterval(timer));
+ * sub.dispose();
+ * sub.dispose(); // no-op
+ * ```
+ */
+declare function toDisposable(onDispose: () => void): Disposable;
+/** A {@link Disposable} that does nothing. Useful as a default return value. */
+declare const NO_OP_DISPOSABLE: Disposable;
+/**
+ * Collects disposables and releases them together.
+ *
+ * Disposal runs in reverse insertion order, so resources are torn down in the
+ * opposite order they were set up. A failure in one disposable does not
+ * prevent the rest from running; all errors are collected and rethrown
+ * together via {@link AggregateError}.
+ *
+ * @example
+ * ```ts
+ * const store = new DisposableStore();
+ * store.add(emitter.event(handler));
+ * store.add(toDisposable(() => socket.close()));
+ * store.dispose();
+ * ```
+ */
+declare class DisposableStore implements Disposable {
+  #private;
+  /** Whether {@link dispose} has already run. */
+  get isDisposed(): boolean;
+  /** Number of disposables currently held. */
+  get size(): number;
+  /**
+   * Registers a disposable.
+   *
+   * When the store is already disposed the argument is disposed immediately,
+   * which keeps late registrations from leaking.
+   *
+   * @returns The same disposable, for convenient chaining.
+   */
+  add<T extends Disposable>(disposable: T): T;
+  /** Disposes and forgets a single entry. Returns `false` when not held. */
+  delete(disposable: Disposable): boolean;
+  /** Disposes everything held without marking the store itself as disposed. */
+  clear(): void;
+  /** Disposes everything held and blocks further use. Safe to call repeatedly. */
+  dispose(): void;
+}
+//#endregion
+//#region src/base/errors.d.ts
+/** Extra context attached to a {@link HudhodError}. */
+interface HudhodErrorDetails {
+  /** The path involved, for file system errors. */
+  readonly path?: string;
+  /** Output collected before the failure, for process errors. */
+  readonly partialOutput?: string;
+  /** The underlying failure, when this error wraps another. */
+  readonly cause?: unknown;
+}
+/**
+ * Builds a {@link HudhodError}.
+ *
+ * @example
+ * ```ts
+ * throw createError("FileNotFound", "No such file: /a.ts", { path: "/a.ts" });
+ * ```
+ */
+declare function createError(code: HudhodErrorCode, message: string, details?: HudhodErrorDetails): HudhodError;
+/** The path does not exist. */
+declare function fileNotFound(path: string): HudhodError;
+/** The path exists and overwriting was not permitted. */
+declare function fileExists(path: string): HudhodError;
+/** A directory was required but the path is not one. */
+declare function notADirectory(path: string): HudhodError;
+/** A file was required but the path is not one. */
+declare function notAFile(path: string): HudhodError;
+/** The directory still has children and `recursive` was not set. */
+declare function directoryNotEmpty(path: string): HudhodError;
+/** The path is malformed, relative, or escapes the workspace root. */
+declare function invalidPath(path: string, reason: string): HudhodError;
+//#endregion
+//#region src/base/event.d.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();
+ * ```
+ */
+declare class Emitter<T> implements Disposable {
+  #private;
+  /**
+   * @param options.onListenerError - Called when a listener throws.
+   * Defaults to `console.error`.
+   */
+  constructor(options?: {
+    onListenerError?: (error: unknown) => void;
+  });
+  /** Number of listeners currently subscribed. */
+  get listenerCount(): number;
+  /**
+   * Subscribes to this emitter.
+   *
+   * Registering the same function twice yields a single subscription, matching
+   * `Set` semantics; disposing either handle removes it.
+   */
+  readonly event: Event<T>;
+  /**
+   * 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: T): void;
+  /** Removes all listeners and blocks further subscription. */
+  dispose(): void;
+}
+//#endregion
+//#region src/base/paths.d.ts
+/**
+ * POSIX-style path utilities.
+ *
+ * hudhod paths are always absolute and rooted at the workspace root. Keeping a
+ * dedicated implementation here — rather than reaching for Node's `path` —
+ * means the core runs unchanged in the browser and stays free of platform
+ * separator quirks.
+ *
+ * @packageDocumentation
+ */
+/** The workspace root. */
+declare const ROOT = "/";
+/**
+ * Normalises a path: collapses duplicate slashes, resolves `.` and `..`, and
+ * strips any trailing slash.
+ *
+ * @throws An `InvalidPath` error when the path is relative, empty, or traverses
+ * above the workspace root.
+ *
+ * @example
+ * ```ts
+ * normalizePath("/src//lib/../index.ts"); // "/src/index.ts"
+ * ```
+ */
+declare function normalizePath(path: string): string;
+/**
+ * Joins segments onto a base path and normalises the result.
+ *
+ * @example
+ * ```ts
+ * joinPath("/src", "lib", "index.ts"); // "/src/lib/index.ts"
+ * ```
+ */
+declare function joinPath(base: string, ...segments: string[]): string;
+/**
+ * Returns the parent directory. The root is its own parent.
+ *
+ * @example
+ * ```ts
+ * dirname("/src/index.ts"); // "/src"
+ * dirname("/");             // "/"
+ * ```
+ */
+declare function dirname(path: string): string;
+/**
+ * Returns the final segment. The root has an empty basename.
+ *
+ * @example
+ * ```ts
+ * basename("/src/index.ts"); // "index.ts"
+ * ```
+ */
+declare function basename(path: string): string;
+/**
+ * Returns the lowercased extension including the leading dot, or an empty
+ * string when there is none.
+ *
+ * A leading dot marks a hidden file rather than an extension, so `.gitignore`
+ * has no extension.
+ *
+ * @example
+ * ```ts
+ * extname("/src/App.TSX");  // ".tsx"
+ * extname("/.gitignore");   // ""
+ * ```
+ */
+declare function extname(path: string): string;
+/**
+ * Expresses `path` relative to `from`, without a leading slash.
+ *
+ * @example
+ * ```ts
+ * relativePath("/src", "/src/lib/a.ts"); // "lib/a.ts"
+ * ```
+ */
+declare function relativePath(from: string, path: string): string;
+/**
+ * Whether `path` is `parent` or sits underneath it.
+ *
+ * Compares whole segments, so `/src` does not contain `/src-old`.
+ *
+ * @example
+ * ```ts
+ * isSubPath("/src", "/src/a.ts");  // true
+ * isSubPath("/src", "/src-old");   // false
+ * ```
+ */
+declare function isSubPath(parent: string, path: string): boolean;
+/**
+ * Splits a path into its segments. The root yields an empty array.
+ *
+ * @example
+ * ```ts
+ * pathSegments("/src/lib/a.ts"); // ["src", "lib", "a.ts"]
+ * ```
+ */
+declare function pathSegments(path: string): string[];
+//#endregion
+//#region src/commands/command-registry.d.ts
+/**
+ * Registers and invokes commands.
+ *
+ * @example
+ * ```ts
+ * const commands = new CommandRegistry();
+ * commands.registerCommand("demo.hello", () => "Hello", { title: "Say Hello" });
+ * await commands.executeCommand("demo.hello");
+ * ```
+ */
+declare class CommandRegistry implements CommandsApi, Disposable {
+  #private;
+  /** Fires whenever the command catalog changes. */
+  readonly onDidChangeCommands: Event<readonly CommandDescriptor[]>;
+  /**
+   * Registers a command handler.
+   *
+   * @throws A `CommandExists` error when `id` is already registered.
+   */
+  registerCommand(id: string, handler: (...args: readonly unknown[]) => unknown, options?: RegisterCommandOptions): Disposable;
+  /**
+   * Invokes a registered command.
+   *
+   * @throws A `CommandNotFound` error when no handler is registered for `id`.
+   */
+  executeCommand<T = unknown>(id: string, ...args: readonly unknown[]): Promise<T>;
+  /** Lists registered commands, alphabetically by title then id. */
+  getCommands(): Promise<CommandDescriptor[]>;
+  /** Removes all registered commands and listeners. */
+  dispose(): void;
+}
+//#endregion
+//#region src/keybindings/keybinding-registry.d.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" }
+ * ```
+ */
+declare class KeybindingRegistry implements Disposable {
+  #private;
+  /** Fires whenever the keybinding catalog changes. */
+  readonly onDidChangeKeybindings: Event<readonly ResolvedKeybinding[]>;
+  /**
+   * @param platform Platform identifier. Use `"mac"` for macOS; otherwise `"other"`.
+   */
+  constructor(platform?: "mac" | "other");
+  /**
+   * 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: KeybindingContribution, options?: {
+    source?: "extension" | "builtin";
+    extensionId?: string;
+  }): Disposable;
+  /**
+   * 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: {
+    readonly key: string;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+  }): ResolvedKeybinding | undefined;
+  /** Lists all registered keybindings, with top-of-stack (most recent) entries first. */
+  getKeybindings(): Promise<ResolvedKeybinding[]>;
+  /** Removes all registered keybindings and listeners. */
+  dispose(): void;
+}
+//#endregion
+//#region src/keybindings/keybinding-parser.d.ts
+/**
+ * Keybinding key sequence parsing and normalization.
+ *
+ * Keybindings are platform-independent at the manifest level; resolution to the
+ * current platform happens at runtime. This module defines how to parse and
+ * canonicalize key sequences.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A parsed and normalized key sequence.
+ *
+ * Modifiers are always in a canonical order: ctrl/cmd, shift, alt.
+ */
+interface NormalizedKeybinding {
+  ctrl: boolean;
+  shift: boolean;
+  alt: boolean;
+  key: string;
+}
+/**
+ * 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" }
+ */
+declare function parseKeybinding(binding: string): NormalizedKeybinding;
+/**
+ * Converts a {@link NormalizedKeybinding} back to a canonical string.
+ *
+ * @example
+ * keybindingToString({ ctrl: true, shift: true, alt: false, key: "p" }) => "ctrl+shift+p"
+ */
+declare function keybindingToString(binding: NormalizedKeybinding): string;
+/**
+ * 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.
+ */
+declare function keybindingFromEvent(event: {
+  readonly key: string;
+  readonly ctrlKey: boolean;
+  readonly metaKey: boolean;
+  readonly shiftKey: boolean;
+  readonly altKey: boolean;
+}): string;
+//#endregion
+//#region src/window/window-service.d.ts
+/**
+ * Host-supplied implementation of UI operations.
+ *
+ * The service delegates all UI interactions to this provider, allowing the host
+ * to supply React components, native dialogs, or any other UI implementation.
+ */
+interface WindowUiProvider {
+  showMessage(message: string, severity?: MessageSeverity): Promise<void>;
+  showInputBox(options?: InputBoxOptions): Promise<string | undefined>;
+  showQuickPick(items: readonly QuickPickItem[], options?: QuickPickOptions): Promise<string | undefined>;
+  registerPanel(id: string, render: PanelRenderer, options: RegisterPanelOptions): Disposable;
+  registerView(id: string, render: PanelRenderer, options: RegisterViewOptions): Disposable;
+  openPanel(id: string): Promise<void>;
+  closePanel(id: string): Promise<boolean>;
+  openFile(path: string): Promise<void>;
+  readonly activeEditor: ActiveEditor | undefined;
+  readonly onDidChangeActiveEditor: Event<ActiveEditor | undefined>;
+}
+/**
+ * Provides window and UI APIs to extensions.
+ *
+ * @example
+ * ```ts
+ * const provider = createMyWindowUiProvider();
+ * const window = new WindowService(provider);
+ * await window.showMessage("Hello!");
+ * ```
+ */
+declare class WindowService implements WindowApi, Disposable {
+  #private;
+  constructor(provider: WindowUiProvider);
+  showMessage(message: string, severity?: MessageSeverity): Promise<void>;
+  showInputBox(options?: InputBoxOptions): Promise<string | undefined>;
+  showQuickPick(items: readonly QuickPickItem[], options?: QuickPickOptions): Promise<string | undefined>;
+  registerPanel(id: string, render: PanelRenderer, options: RegisterPanelOptions): Disposable;
+  registerView(id: string, render: PanelRenderer, options: RegisterViewOptions): Disposable;
+  openPanel(id: string): Promise<void>;
+  closePanel(id: string): Promise<boolean>;
+  openFile(path: string): Promise<void>;
+  get activeEditor(): ActiveEditor | undefined;
+  get onDidChangeActiveEditor(): Event<ActiveEditor | undefined>;
+  dispose(): void;
+}
+//#endregion
+//#region src/workspace/config.d.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. */
+declare const DEFAULT_FILES_EXCLUDE: readonly string[];
+/** Glob patterns excluded from search. Broader than the tree exclusions. */
+declare const DEFAULT_SEARCH_EXCLUDE: readonly string[];
+/** Glob patterns whose changes are ignored by watchers. */
+declare const DEFAULT_WATCHER_EXCLUDE: readonly string[];
+/**
+ * Patterns omitted when snapshotting a workspace for storage.
+ *
+ * Everything here is either reproducible from `package.json` or machine-local.
+ */
+declare const DEFAULT_SNAPSHOT_EXCLUDE: readonly string[];
+/** Tunable workspace policy. */
+interface WorkspaceConfig {
+  /** Absolute path of the workspace root. */
+  readonly rootPath: string;
+  /** Patterns hidden from directory listings and the file tree. */
+  readonly filesExclude: readonly string[];
+  /** Patterns skipped by search, unless a call overrides them. */
+  readonly searchExclude: readonly string[];
+  /** Patterns whose changes never reach watchers. */
+  readonly watcherExclude: readonly string[];
+  /** Patterns omitted from workspace snapshots. */
+  readonly snapshotExclude: readonly string[];
+  /** Largest file, in bytes, that search will read. */
+  readonly maxSearchFileBytes: number;
+}
+/** Partial overrides accepted by {@link createWorkspaceConfig}. */
+type WorkspaceConfigOverrides = Partial<WorkspaceConfig>;
+/**
+ * Builds a {@link WorkspaceConfig}, filling in defaults.
+ *
+ * @example
+ * ```ts
+ * // Search node_modules too, but keep every other default.
+ * const config = createWorkspaceConfig({ searchExclude: ["**\/.git/**"] });
+ * ```
+ */
+declare function createWorkspaceConfig(overrides?: WorkspaceConfigOverrides): WorkspaceConfig;
+//#endregion
+//#region src/fs/file-system-service.d.ts
+/** Options for {@link FileSystemService}. */
+interface FileSystemServiceOptions {
+  /** Workspace policy, chiefly the exclusion patterns. */
+  readonly config?: WorkspaceConfig;
+  /**
+   * Milliseconds to coalesce change events over. Set to `0` to deliver
+   * synchronously, which makes tests deterministic.
+   * @defaultValue 20
+   */
+  readonly debounceMs?: number;
+}
+/**
+ * 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");
+ * ```
+ */
+declare class FileSystemService implements FileSystemApi, Disposable {
+  #private;
+  constructor(provider: FileSystemProvider, options?: FileSystemServiceOptions);
+  /** The workspace policy in force. */
+  get config(): WorkspaceConfig;
+  /**
+   * 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.
+   */
+  readonly onDidChangeFile: Event<readonly FileChangeEvent[]>;
+  readFile(path: string): Promise<Uint8Array>;
+  readTextFile(path: string): Promise<string>;
+  writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
+  writeTextFile(path: string, content: string, options?: WriteFileOptions): Promise<void>;
+  createFile(path: string, options?: WriteFileOptions): Promise<void>;
+  /** Creates a directory and every missing ancestor. Succeeds if it exists. */
+  createDirectory(path: string): Promise<void>;
+  delete(path: string, options?: DeleteOptions): Promise<void>;
+  rename(from: string, to: string, options?: MoveOptions): Promise<void>;
+  copy(from: string, to: string, options?: MoveOptions): Promise<void>;
+  stat(path: string): Promise<FileStat>;
+  exists(path: string): Promise<boolean>;
+  /**
+   * Lists a directory, hiding entries matched by `filesExclude` and sorting
+   * directories first, then by name.
+   */
+  readDirectory(path: string): Promise<DirectoryEntry[]>;
+  /**
+   * 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.
+   */
+  listDirectory(path: string, options: {
+    applyExcludes: boolean;
+  }): Promise<DirectoryEntry[]>;
+  watch(path: string, listener: (events: readonly FileChangeEvent[]) => unknown, options?: WatchOptions): Disposable;
+  /** Stops watching and releases listeners. */
+  dispose(): void;
+}
+//#endregion
+//#region src/diff/diff-service.d.ts
+/**
+ * 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);
+ * ```
+ */
+declare class DiffService implements DiffApi {
+  #private;
+  constructor(fileSystem: FileSystemService);
+  diffText(original: string, modified: string, options?: DiffOptions): Promise<DiffChange[]>;
+  diffFiles(originalPath: string, modifiedPath: string, options?: DiffOptions): Promise<DiffChange[]>;
+  diffStat(original: string, modified: string, options?: DiffOptions): Promise<DiffStat>;
+  createPatch(path: string, original: string, modified: string, options?: DiffOptions): Promise<string>;
+  /**
+   * 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.
+   */
+  applyPatch(path: string, patch: string): Promise<void>;
+}
+//#endregion
+//#region src/panels/panel-registry.d.ts
+/** Resolved metadata for a contributed panel. */
+interface PanelInfo {
+  /** Unique identifier, matching the id passed to `registerPanel`. */
+  readonly id: string;
+  /** Tab title. */
+  readonly title: string;
+  /** Opaque icon value supplied by the manifest contribution. */
+  readonly icon?: unknown;
+  /** Dock location, defaulted to `"bottom"` when the contribution omits it. */
+  readonly location: "left" | "right" | "bottom" | "center";
+  /** Whether the panel comes from an extension or the built-in shell. */
+  readonly source: "extension" | "builtin";
+  /** Id of the owning extension, when the source is an extension. */
+  readonly extensionId?: string;
+}
+/**
+ * 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();
+ * ```
+ */
+declare class PanelRegistry implements Disposable {
+  #private;
+  /** Fires whenever the panel catalog changes. */
+  readonly onDidChangePanels: Event<readonly PanelInfo[]>;
+  /**
+   * 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: PanelContribution, options?: {
+    source?: "extension" | "builtin";
+    extensionId?: string;
+  }): Disposable;
+  /** Lists the active panel per id, sorted by id for stable UI ordering. */
+  getPanels(): readonly PanelInfo[];
+  /** Removes all registered panels and listeners. */
+  dispose(): void;
+}
+//#endregion
+//#region src/views/view-registry.d.ts
+interface ViewInfo {
+  readonly id: string;
+  readonly title: string;
+  readonly container: string;
+  readonly order?: number;
+  readonly source: "extension" | "builtin";
+  readonly extensionId?: string;
+  readonly registrationOrder: number;
+}
+/** Tracks contributed views independently from activity-bar containers. */
+declare class ViewRegistry implements Disposable {
+  #private;
+  readonly onDidChangeViews: Event<readonly ViewInfo[]>;
+  registerView(contribution: ViewContribution, options?: {
+    source?: "extension" | "builtin";
+    extensionId?: string;
+  }): Disposable;
+  getViews(): readonly ViewInfo[];
+  getViewsForContainer(containerId: string): readonly ViewInfo[];
+  dispose(): void;
+}
+//#endregion
+//#region src/extensions/extension-host.d.ts
+/** Current lifecycle state of a registered extension. */
+type ExtensionStatus = "registered" | "activating" | "active" | "failed";
+/** A serializable snapshot of a registered extension. */
+interface ExtensionInfo {
+  /** Validated extension manifest. */
+  readonly manifest: ExtensionManifest;
+  /** Current lifecycle state. */
+  readonly status: ExtensionStatus;
+  /** Activation error message when status is `failed`. */
+  readonly error?: string;
+}
+/**
+ * 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");
+ * ```
+ */
+declare class InProcessExtensionHost implements Disposable {
+  #private;
+  constructor(hudhod: HudhodApi, registries: {
+    panels: PanelRegistry;
+    views: ViewRegistry;
+  });
+  /**
+   * 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: Extension): Disposable;
+  /** Lists registered extensions without exposing mutable host state. */
+  getExtensions(): readonly ExtensionInfo[];
+  /** Activates every extension that declared `event`. */
+  activateByEvent(event: ActivationEvent): Promise<void>;
+  /** Activates one extension by id. */
+  activate(extensionId: string): Promise<void>;
+  /** Deactivates one extension and releases its registered resources. */
+  deactivate(extensionId: string): Promise<boolean>;
+  /** Deactivates every extension and blocks further registration. */
+  dispose(): void;
+}
+//#endregion
+//#region src/extensions/manifest.d.ts
+/** Validates the serializable shape of an extension manifest. */
+declare const extensionManifestSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  version: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  activationEvents: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"onStartup">, z.ZodString, z.ZodString, z.ZodString]>>>;
+  contributes: z.ZodOptional<z.ZodObject<{
+    commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodString;
+      category: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    panels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodString;
+      icon: z.ZodOptional<z.ZodUnknown>;
+      location: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        bottom: "bottom";
+        center: "center";
+      }>>;
+    }, z.core.$strip>>>;
+    viewContainers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodString;
+      icon: z.ZodOptional<z.ZodUnknown>;
+      location: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        bottom: "bottom";
+        center: "center";
+      }>>;
+    }, z.core.$strip>>>;
+    views: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodString;
+      container: z.ZodString;
+      order: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    keybindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      command: z.ZodString;
+      key: z.ZodString;
+      mac: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Validates a manifest or throws `ZodError` with field-level diagnostics.
+ *
+ * @example
+ * ```ts
+ * const manifest = parseExtensionManifest(rawJson);
+ * ```
+ */
+declare function parseExtensionManifest(value: unknown): ExtensionManifest;
+//#endregion
+//#region src/fs/in-memory-provider.d.ts
+/** Options for {@link InMemoryFileSystemProvider}. */
+interface InMemoryFileSystemProviderOptions {
+  /**
+   * Clock used for `mtime` values. Inject a fake to make timestamps
+   * deterministic in tests.
+   * @defaultValue `Date.now`
+   */
+  readonly now?: () => number;
+}
+/**
+ * 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 {};"));
+ * ```
+ */
+declare class InMemoryFileSystemProvider implements FileSystemProvider {
+  #private;
+  readonly name = "in-memory";
+  constructor(options?: InMemoryFileSystemProviderOptions);
+  /**
+   * 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: Readonly<Record<string, string>>, options?: InMemoryFileSystemProviderOptions): InMemoryFileSystemProvider;
+  /** Every path currently stored, sorted. Intended for test assertions. */
+  snapshot(): string[];
+  readFile(path: string): Promise<Uint8Array>;
+  writeFile(path: string, data: Uint8Array): Promise<void>;
+  createDirectory(path: string): Promise<void>;
+  delete(path: string, options: {
+    recursive: boolean;
+  }): Promise<void>;
+  rename(from: string, to: string, options: {
+    overwrite: boolean;
+  }): Promise<void>;
+  stat(path: string): Promise<ProviderStat>;
+  readDirectory(path: string): Promise<ProviderEntry[]>;
+  watch(path: string, options: ProviderWatchOptions, listener: (events: readonly FileChangeEvent[]) => void): Disposable;
+}
+//#endregion
+//#region src/process/fake-spawner.d.ts
+/** How a faked command should behave. */
+interface FakeCommandBehaviour {
+  /** Chunks emitted on the output stream, in order. */
+  readonly output?: readonly string[];
+  /**
+   * Exit code once the output is exhausted.
+   * @defaultValue 0
+   */
+  readonly exitCode?: number;
+  /**
+   * Milliseconds to wait before exiting. The process stays running until then,
+   * which is what lets timeout behaviour be tested.
+   * @defaultValue 0
+   */
+  readonly delayMs?: number;
+  /**
+   * Never exit on its own. Only a `kill()` will end it. Useful for modelling
+   * servers and watchers.
+   * @defaultValue false
+   */
+  readonly neverExits?: boolean;
+}
+/** A record of one spawn call. */
+interface RecordedSpawn {
+  /** The executable requested. */
+  readonly command: string;
+  /** The arguments requested. */
+  readonly args: readonly string[];
+  /** The options the service passed through. */
+  readonly options: SpawnerOptions;
+}
+/**
+ * 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"]);
+ * ```
+ */
+declare class FakeProcessSpawner implements ProcessSpawner {
+  #private;
+  readonly name = "fake";
+  /** Every spawn that has been requested, in order. */
+  get spawns(): readonly RecordedSpawn[];
+  /** Scripts a command, keyed by executable name. */
+  register(command: string, behaviour: FakeCommandBehaviour): this;
+  /** Sets the behaviour used for unregistered commands. */
+  setFallback(behaviour: FakeCommandBehaviour): this;
+  spawn(command: string, args: readonly string[], options: SpawnerOptions): Promise<SpawnedProcess>;
+}
+//#endregion
+//#region src/process/process-service.d.ts
+/** Default wall-clock limit for {@link ProcessService.exec}. */
+declare const DEFAULT_EXEC_TIMEOUT_MS = 60000;
+/** Default output cap for {@link ProcessService.exec}, in bytes. */
+declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+/** Options for {@link ProcessService}. */
+interface ProcessServiceOptions {
+  /**
+   * Clock used for `startedAt` and duration measurement.
+   * @defaultValue `Date.now`
+   */
+  readonly now?: () => number;
+}
+/**
+ * Spawns and supervises processes.
+ *
+ * @example
+ * ```ts
+ * const processes = new ProcessService(spawner);
+ * const { exitCode, output } = await processes.exec("node", ["-v"]);
+ * ```
+ */
+declare class ProcessService implements ProcessApi {
+  #private;
+  constructor(spawner: ProcessSpawner, options?: ProcessServiceOptions);
+  /** Fires whenever a process starts. */
+  readonly onDidStartProcess: Event<ProcessInfo>;
+  /** Fires whenever a process exits, for any reason. */
+  readonly onDidExitProcess: Event<ProcessInfo>;
+  spawn(command: string, args?: readonly string[], options?: SpawnOptions): Promise<ProcessHandle>;
+  exec(command: string, args?: readonly string[], options?: ExecOptions): Promise<ExecResult>;
+  list(): Promise<ProcessInfo[]>;
+  kill(id: string): Promise<boolean>;
+  /** Kills every running process and releases listeners. */
+  dispose(): void;
+}
+//#endregion
+//#region src/search/search-service.d.ts
+/**
+ * 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");
+ * ```
+ */
+declare class SearchService implements SearchApi {
+  #private;
+  constructor(fileSystem: FileSystemService);
+  findFiles(include: string, options?: FindFilesOptions): Promise<string[]>;
+  findInFiles(query: string, options?: FindInFilesOptions): Promise<SearchResult>;
+  replaceInFiles(query: string, replacement: string, options?: FindInFilesOptions): Promise<number>;
+}
+//#endregion
+//#region src/runtime/runtime.d.ts
+interface HudhodRuntime {
+  readonly fs: FileSystemService;
+  readonly search: SearchService;
+  readonly diff: DiffService;
+  readonly process: ProcessService;
+  readonly commands: CommandRegistry;
+  readonly keybindings: KeybindingRegistry;
+  readonly panels: PanelRegistry;
+  readonly views: ViewRegistry;
+  readonly window: WindowService;
+  readonly extensions: InProcessExtensionHost;
+  readonly api: HudhodApi;
+  dispose(): void;
+}
+interface CreateHudhodRuntimeOptions {
+  readonly fileSystemProvider: FileSystemProvider;
+  readonly processSpawner: ProcessSpawner;
+  readonly windowUiProvider: WindowUiProvider;
+  readonly platform?: "mac" | "other";
+  readonly version?: string;
+  readonly workspace?: WorkspaceApi;
+  readonly terminal?: TerminalApi;
+}
+/** Creates an environment-agnostic Hudhod runtime from host-provided adapters. */
+declare function createHudhodRuntime(options: CreateHudhodRuntimeOptions): HudhodRuntime;
+//#endregion
+//#region src/services/service-registry.d.ts
+/** A unique, typed key used to retrieve a service. */
+interface ServiceIdentifier<T> {
+  /** Human-readable name used in diagnostics. */
+  readonly description: string;
+  /** Unique symbol backing the identifier. */
+  readonly key: symbol;
+  /** Type-only marker preserving `T` across calls. */
+  readonly __service?: T;
+}
+/** Creates a typed service identifier. */
+declare function createServiceIdentifier<T>(description: string): ServiceIdentifier<T>;
+type ServiceFactory<T> = (registry: ServiceRegistry) => T;
+/**
+ * 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);
+ * ```
+ */
+declare class ServiceRegistry implements Disposable {
+  #private;
+  /** Registers a lazy factory for a service. */
+  register<T>(identifier: ServiceIdentifier<T>, factory: ServiceFactory<T>): void;
+  /** Retrieves and lazily creates a registered service. */
+  get<T>(identifier: ServiceIdentifier<T>): T;
+  /** Whether a service factory is registered. */
+  has(identifier: ServiceIdentifier<unknown>): boolean;
+  /** Releases every created disposable service in reverse creation order. */
+  dispose(): void;
+}
+//#endregion
+export { CancellationTokenNone, CancellationTokenSource, CommandRegistry, type CreateHudhodRuntimeOptions, DEFAULT_EXEC_TIMEOUT_MS, DEFAULT_FILES_EXCLUDE, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_SEARCH_EXCLUDE, DEFAULT_SNAPSHOT_EXCLUDE, DEFAULT_WATCHER_EXCLUDE, DiffService, DisposableStore, Emitter, type ExtensionInfo, type ExtensionStatus, type FakeCommandBehaviour, FakeProcessSpawner, type FileSystemProvider, FileSystemService, type FileSystemServiceOptions, HudhodErrorDetails, type HudhodRuntime, InMemoryFileSystemProvider, type InMemoryFileSystemProviderOptions, InProcessExtensionHost, KeybindingRegistry, NO_OP_DISPOSABLE, type NormalizedKeybinding, type PanelInfo, PanelRegistry, ProcessService, type ProcessServiceOptions, type ProcessSpawner, type ProviderEntry, type ProviderStat, type ProviderWatchOptions, ROOT, type RecordedSpawn, SearchService, type ServiceIdentifier, ServiceRegistry, type SpawnedProcess, type SpawnerOptions, type ViewInfo, ViewRegistry, WindowService, type WindowUiProvider, type WorkspaceConfig, type WorkspaceConfigOverrides, 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 };