@hienlh/ppm 0.20.9 → 0.21.0

package/src/services/lsp/server-registry.ts

@@ -0,0 +1,401 @@
+/**
+ * Which language server serves which file, how to find it, and what to tell
+ * the user when it is missing.
+ *
+ * Nothing here spawns or touches the filesystem — it answers "what would you
+ * run" so the decisions are testable on their own. `lsp-manager.ts` does the
+ * looking and the launching.
+ *
+ * The language ids are LSP's, which are VS Code's, and they are deliberately
+ * *not* PPM's Monaco ids. Monaco maps `.tsx` to `typescript`; LSP calls it
+ * `typescriptreact`, and the distinction is load-bearing rather than cosmetic —
+ * tsserver decides whether to parse JSX from the language id, so a `.tsx` file
+ * announced as `typescript` gets a syntax error on its first tag.
+ */
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+export interface LanguageServerDefinition {
+  /** Stable id, used in status reporting and as the marker owner. */
+  id: string;
+  displayName: string;
+  /** LSP language ids this server handles. */
+  languages: string[];
+  command: string;
+  args: string[];
+  /**
+   * Files that mark the root of a project this server understands. The nearest
+   * ancestor holding one becomes the rootUri, so a monorepo package gets its
+   * own server rather than one rooted at the repository top.
+   */
+  rootMarkers: string[];
+  /** Shown verbatim when the command cannot be found. */
+  installHint: string;
+  /**
+   * The npm package PPM depends on for this server, when it ships one.
+   *
+   * Only set where the package is in PPM's own `dependencies` — naming one that is not there
+   * makes `bundledServerEntry` answer with a path nothing ever wrote.
+   */
+  bundledPackage?: string;
+  initializationOptions?: Record<string, unknown>;
+}
+
+/**
+ * File extension to LSP language id.
+ *
+ * Extensionless names that are whole filenames (Dockerfile, Makefile) are
+ * matched separately, in `lspLanguageForPath`.
+ */
+const EXTENSION_LANGUAGE: Record<string, string> = {
+  ts: "typescript", mts: "typescript", cts: "typescript",
+  tsx: "typescriptreact",
+  js: "javascript", mjs: "javascript", cjs: "javascript",
+  jsx: "javascriptreact",
+  py: "python", pyi: "python",
+  go: "go",
+  rs: "rust",
+  c: "c", h: "c",
+  cc: "cpp", cpp: "cpp", cxx: "cpp", hpp: "cpp", hh: "cpp", hxx: "cpp",
+  json: "json",
+  jsonc: "jsonc",
+  html: "html", htm: "html",
+  css: "css", scss: "scss", less: "less",
+  yaml: "yaml", yml: "yaml",
+  sh: "shellscript", bash: "shellscript", zsh: "shellscript",
+  php: "php",
+  rb: "ruby",
+  lua: "lua",
+  vue: "vue",
+  svelte: "svelte",
+};
+
+const FILENAME_LANGUAGE: Record<string, string> = {
+  dockerfile: "dockerfile",
+  "tsconfig.json": "jsonc",
+  "jsconfig.json": "jsonc",
+  ".eslintrc.json": "jsonc",
+};
+
+/** The LSP language id for a path, or null when no server could serve it. */
+export function lspLanguageForPath(filePath: string): string | null {
+  const base = filePath.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
+  const byName = FILENAME_LANGUAGE[base];
+  if (byName) return byName;
+
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return null; // no extension, or a dotfile with no suffix
+  return EXTENSION_LANGUAGE[base.slice(dot + 1)] ?? null;
+}
+
+/**
+ * The servers PPM knows how to drive.
+ *
+ * The first entry that is actually installed wins, so ordering within a
+ * language matters. TypeScript comes from `typescript-language-server`, which
+ * wraps the same tsserver VS Code drives — the intelligence is identical, only
+ * the transport differs.
+ */
+export const LANGUAGE_SERVERS: LanguageServerDefinition[] = [
+  {
+    id: "typescript",
+    displayName: "TypeScript",
+    languages: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    command: "typescript-language-server",
+    args: ["--stdio"],
+    rootMarkers: ["tsconfig.json", "jsconfig.json", "package.json"],
+    // `typescript@5` is pinned deliberately. The 7.x line is the native port
+    // and ships no `tsserver.js`, so typescript-language-server refuses to
+    // start against it with "provides no tsserver" — which reads like a broken
+    // install rather than the wrong major version.
+    installHint: "bun add -g typescript-language-server typescript@5",
+    // Shipped with PPM, so this one works on a fresh install with nothing else done. The
+    // project's own copy still wins where there is one — a repository pinned to TypeScript 4
+    // has to be analysed by its own server, not by whatever PPM happens to carry.
+    bundledPackage: "typescript-language-server",
+    initializationOptions: {
+      // Matches what VS Code asks tsserver for: completions that can add an
+      // import, and snippet text so a function completion fills its parens.
+      preferences: {
+        includeCompletionsForModuleExports: true,
+        includeCompletionsWithSnippetText: true,
+        includeCompletionsWithInsertText: true,
+        importModuleSpecifierPreference: "shortest",
+        // Inlay hints are opt-in *per kind* on the server side, and tsserver
+        // returns an empty array for every one that is off. Without these the
+        // editor asks, the server answers "no hints", and a feature that is
+        // switched on in Monaco shows nothing at all — measured as 0 hints for
+        // a 2233-line file.
+        //
+        // Parameter names only. Those are the ones worth reading — they say
+        // what a bare `true` or a positional array index means at a call site.
+        // The type hints (variable, property, return) are the noisy ones: they
+        // restate what the code already says on most lines, and VS Code ships
+        // all of them off.
+        includeInlayParameterNameHints: "all",
+        // `foo(name)` for `foo(name: string)` is the one hint that never adds
+        // anything, so it is suppressed the way VS Code suppresses it.
+        includeInlayParameterNameHintsWhenArgumentMatchesName: false,
+        includeInlayEnumMemberValueHints: true,
+        includeInlayFunctionLikeReturnTypeHints: false,
+        includeInlayFunctionParameterTypeHints: false,
+        includeInlayVariableTypeHints: false,
+        includeInlayPropertyDeclarationTypeHints: false,
+      },
+    },
+  },
+  {
+    id: "pyright",
+    displayName: "Pyright",
+    languages: ["python"],
+    command: "pyright-langserver",
+    args: ["--stdio"],
+    rootMarkers: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"],
+    installHint: "bun add -g pyright",
+  },
+  {
+    id: "gopls",
+    displayName: "gopls",
+    languages: ["go"],
+    command: "gopls",
+    args: [],
+    rootMarkers: ["go.work", "go.mod"],
+    installHint: "go install golang.org/x/tools/gopls@latest",
+  },
+  {
+    id: "rust-analyzer",
+    displayName: "rust-analyzer",
+    languages: ["rust"],
+    command: "rust-analyzer",
+    args: [],
+    rootMarkers: ["Cargo.toml"],
+    installHint: "rustup component add rust-analyzer",
+  },
+  {
+    id: "clangd",
+    displayName: "clangd",
+    languages: ["c", "cpp"],
+    command: "clangd",
+    args: ["--background-index"],
+    rootMarkers: ["compile_commands.json", "compile_flags.txt", ".clangd", "CMakeLists.txt", "Makefile"],
+    installHint: "install clangd from your package manager (pacman -S clang, apt install clangd)",
+  },
+  {
+    id: "json",
+    displayName: "JSON",
+    languages: ["json", "jsonc"],
+    command: "vscode-json-language-server",
+    args: ["--stdio"],
+    rootMarkers: ["package.json"],
+    installHint: "bun add -g vscode-langservers-extracted",
+  },
+  {
+    id: "html",
+    displayName: "HTML",
+    languages: ["html"],
+    command: "vscode-html-language-server",
+    args: ["--stdio"],
+    rootMarkers: ["package.json"],
+    installHint: "bun add -g vscode-langservers-extracted",
+  },
+  {
+    id: "css",
+    displayName: "CSS",
+    languages: ["css", "scss", "less"],
+    command: "vscode-css-language-server",
+    args: ["--stdio"],
+    rootMarkers: ["package.json"],
+    installHint: "bun add -g vscode-langservers-extracted",
+  },
+  {
+    id: "yaml",
+    displayName: "YAML",
+    languages: ["yaml"],
+    command: "yaml-language-server",
+    args: ["--stdio"],
+    rootMarkers: [],
+    installHint: "bun add -g yaml-language-server",
+  },
+  {
+    id: "bash",
+    displayName: "Bash",
+    languages: ["shellscript"],
+    command: "bash-language-server",
+    args: ["start"],
+    rootMarkers: [],
+    installHint: "bun add -g bash-language-server",
+  },
+  {
+    id: "intelephense",
+    displayName: "Intelephense",
+    languages: ["php"],
+    command: "intelephense",
+    args: ["--stdio"],
+    rootMarkers: ["composer.json"],
+    installHint: "bun add -g intelephense",
+  },
+  {
+    id: "solargraph",
+    displayName: "Solargraph",
+    languages: ["ruby"],
+    command: "solargraph",
+    args: ["stdio"],
+    rootMarkers: ["Gemfile", ".solargraph.yml"],
+    installHint: "gem install solargraph",
+  },
+  {
+    id: "lua",
+    displayName: "Lua",
+    languages: ["lua"],
+    command: "lua-language-server",
+    args: [],
+    rootMarkers: [".luarc.json"],
+    installHint: "install lua-language-server from your package manager",
+  },
+  {
+    id: "vue",
+    displayName: "Vue",
+    languages: ["vue"],
+    command: "vue-language-server",
+    args: ["--stdio"],
+    rootMarkers: ["package.json"],
+    installHint: "bun add -g @vue/language-server",
+  },
+  {
+    id: "svelte",
+    displayName: "Svelte",
+    languages: ["svelte"],
+    command: "svelteserver",
+    args: ["--stdio"],
+    rootMarkers: ["package.json"],
+    installHint: "bun add -g svelte-language-server",
+  },
+];
+
+/** Every server that claims this language, in preference order. */
+export function serversForLanguage(languageId: string): LanguageServerDefinition[] {
+  return LANGUAGE_SERVERS.filter((s) => s.languages.includes(languageId));
+}
+
+export function serverById(id: string): LanguageServerDefinition | undefined {
+  return LANGUAGE_SERVERS.find((s) => s.id === id);
+}
+
+/**
+ * Directories to search, nearest first, from the file's own directory up to and
+ * including the project root.
+ *
+ * Every directory here is both searched for `node_modules/.bin/<server>` — which
+ * is then *executed* — and searched for a root marker that would become a
+ * server's rootUri. So the bound is the whole trust story: without it a file at
+ * `~/notes/x.ts` puts `~/node_modules/.bin` on the list and roots a server at
+ * the user's home directory, indexing everything they own.
+ *
+ * The bound is enforced rather than assumed. The walk used to stop by comparing
+ * *lengths*, which happens to hold for a file inside the project and not at all
+ * for one outside it: `/home/ada/repo-other/deep/x.ts` against a project at
+ * `/home/ada/repo` yielded three `repo-other` directories and `/home/ada`. The
+ * bridge confines the path before this is reached, so nothing could reach it —
+ * but a guard whose comment claims more than its code does is one caller away
+ * from being a real hole.
+ */
+export function ancestorDirs(filePath: string, projectPath: string, platform: NodeJS.Platform = process.platform): string[] {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  const root = p.normalize(projectPath).replace(/[\\/]+$/, "");
+  const start = p.dirname(p.normalize(filePath));
+  // Windows paths are case-insensitive, so `C:\Users\Ada\Repo` and `c:\users\ada\repo` name
+  // one directory. Comparing them case-sensitively refuses the project outright — and, once
+  // the walk can no longer recognise its own root, lets it climb straight past it to `C:\`.
+  const fold = (dir: string) => (platform === "win32" ? dir.toLowerCase() : dir);
+  const foldedRoot = fold(root);
+  const inside = (dir: string) => fold(dir) === foldedRoot || fold(dir).startsWith(foldedRoot + p.sep);
+  if (!inside(start)) return [root];
+
+  const dirs: string[] = [];
+  for (let dir = start; ; ) {
+    dirs.push(dir);
+    if (fold(dir) === foldedRoot) return dirs;
+    const parent = p.dirname(dir);
+    if (parent === dir) break; // hit the filesystem root
+    dir = parent;
+  }
+  dirs.push(root);
+  return dirs;
+}
+
+/**
+ * Absolute paths to try for a server command, in order, ending with the bare
+ * command for PATH lookup.
+ *
+ * A project's own `node_modules/.bin` comes first so a repository that pins its
+ * language server gets that version — the same reason VS Code offers "Use
+ * Workspace Version" for TypeScript. Getting this backwards means a project
+ * pinned to TypeScript 4 is analysed by whatever is installed globally.
+ *
+ * That does mean opening a file runs a binary the repository supplied, so it is
+ * worth being explicit about what bounds it. Registering a project in PPM
+ * already hands that directory a terminal and an agent running in
+ * `bypassPermissions`; a `postinstall` script has run long before any of this.
+ * The setting is off by default and per device, so a language server exists only
+ * where someone asked for one. And `dirs` comes from `ancestorDirs`, which
+ * answers with directories inside the project and nothing else — that is the
+ * part that had to be enforced rather than assumed, and it is where the
+ * confinement actually lives.
+ */
+export function candidateCommandPaths(command: string, dirs: string[], platform: NodeJS.Platform = process.platform): string[] {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  // npm/bun write a .cmd shim on Windows; the extensionless file there is a
+  // shell script Windows cannot execute.
+  const names = platform === "win32" ? [`${command}.cmd`, `${command}.exe`, command] : [command];
+
+  const candidates: string[] = [];
+  for (const dir of dirs) {
+    for (const name of names) {
+      candidates.push(p.join(dir, "node_modules", ".bin", name));
+    }
+  }
+  candidates.push(command);
+  return candidates;
+}
+
+/**
+ * The copy PPM ships itself, for servers listed in its own dependencies.
+ *
+ * The floor under the other two lookups, and the reason the TypeScript server works on a
+ * fresh install with nothing else done: PPM depends on `typescript-language-server`, so npm
+ * puts it in PPM's *own* `node_modules` — which is neither the project's nor on `PATH`, so
+ * without this it was installed and unreachable.
+ *
+ * This answers with the package's **entry script**, not npm's `.bin` shim, and that is the
+ * load-bearing part. The shim starts `#!/usr/bin/env node`; PPM runs on Bun, and someone who
+ * installed it with `bun install -g ppm` may have no `node` on the machine at all. Measured:
+ * spawning the shim with nothing named `node` on `PATH` exits **127** with `env: 'node': No
+ * such file or directory` — after the server had already been reported as installed. The
+ * caller runs this with `process.execPath` instead. It also retires the `.cmd`/`.exe` guessing
+ * on Windows, since the entry is the same `.mjs` file on every platform.
+ *
+ * Resolved through the package rather than built from `import.meta.dir`: PPM runs from a
+ * global install, from a checkout, and from a bundled binary, and only the resolver knows
+ * where its dependencies actually landed in each. `null` when the package is absent, which is
+ * every server PPM does not bundle.
+ */
+export function bundledServerEntry(
+  definition: LanguageServerDefinition,
+  resolve: (specifier: string) => string = createRequire(import.meta.url).resolve,
+): string | null {
+  const pkg = definition.bundledPackage;
+  if (!pkg) return null;
+  let manifestPath: string;
+  let manifest: { bin?: string | Record<string, string> };
+  try {
+    manifestPath = resolve(`${pkg}/package.json`);
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as typeof manifest;
+  } catch {
+    return null;
+  }
+  // `bin` is either a bare string — the package's own name — or a map of command to path.
+  const relative = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[definition.command];
+  if (!relative) return null;
+  return path.resolve(path.dirname(manifestPath), relative);
+}

package/src/services/search-index-db.service.ts

@@ -10,7 +10,7 @@ import { resolve } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { getPpmDir } from "./ppm-dir.ts";
 
-export const SEARCH_INDEX_SCHEMA_VERSION = 1;
+export const SEARCH_INDEX_SCHEMA_VERSION = 2;
 
 let db: Database | null = null;
 
@@ -75,6 +75,14 @@ function runMigrations(database: Database): void {
 
       CREATE INDEX IF NOT EXISTS idx_session_meta_project ON session_meta(project_path);
     `);
-    database.exec(`PRAGMA user_version = ${SEARCH_INDEX_SCHEMA_VERSION}`);
   }
+  if (row.user_version < 2) {
+    // Records which build of the indexer wrote a row. `isStale` compares it, so
+    // improving what gets indexed re-indexes every session instead of leaving
+    // the old, thinner rows stamped as fresh forever (jsonl_mtime still matches).
+    database.exec(
+      "ALTER TABLE session_meta ADD COLUMN indexer_version INTEGER NOT NULL DEFAULT 0",
+    );
+  }
+  database.exec(`PRAGMA user_version = ${SEARCH_INDEX_SCHEMA_VERSION}`);
 }

package/src/shared/blame.ts

@@ -77,3 +77,54 @@ export function formatRelativeTime(timestampMs: number, now: number = Date.now()
   }
   return "just now";
 }
+
+/**
+ * What the editor's blame hover shows beyond the one-line annotation: the whole
+ * commit message, and the change the commit made to the hovered line.
+ *
+ * Separate from `BlameCommitInfo` because it costs a `git show` per commit,
+ * where the annotation costs one `git blame` per file. It is fetched for the
+ * line the cursor is on and nothing else.
+ */
+export interface BlameLineDetail {
+  hash: string;
+  author: string;
+  authorMail: string;
+  /** Unix seconds. */
+  authorTime: number;
+  /** Subject and body, as committed. */
+  message: string;
+  /** What the commit removed at this line, capped. */
+  removed: string[];
+  /** The line as this commit wrote it. */
+  added: string[];
+}
+
+/**
+ * The absolute date beside the relative one, in GitLens' wording:
+ * "December 2nd, 2025 4:17 PM". Both are shown because "9 months ago" is the
+ * useful reading and the exact date is the one you need to go looking for a
+ * commit.
+ *
+ * Built by hand rather than with `toLocaleString`, whose output depends on the
+ * host's locale and would make the format untestable and inconsistent between
+ * the machine serving PPM and the phone reading it.
+ */
+export function formatAbsoluteTime(timestampMs: number): string {
+  const d = new Date(timestampMs);
+  const months = [
+    "January", "February", "March", "April", "May", "June",
+    "July", "August", "September", "October", "November", "December",
+  ];
+  const day = d.getDate();
+  const hour12 = d.getHours() % 12 || 12;
+  const minute = String(d.getMinutes()).padStart(2, "0");
+  const meridiem = d.getHours() < 12 ? "AM" : "PM";
+  return `${months[d.getMonth()]} ${day}${ordinalSuffix(day)}, ${d.getFullYear()} ${hour12}:${minute} ${meridiem}`;
+}
+
+function ordinalSuffix(day: number): string {
+  // 11th, 12th, 13th are the exceptions to the last-digit rule.
+  if (day % 100 >= 11 && day % 100 <= 13) return "th";
+  return ["th", "st", "nd", "rd"][day % 10] ?? "th";
+}

package/src/shared/lsp-uri.ts

@@ -0,0 +1,108 @@
+/**
+ * `file:` URI conversion, shared because both sides need it: the server hands
+ * document URIs to language servers, and the browser turns a URI a server
+ * returned (a definition, a diagnostic, a reference) back into a path it can
+ * open a tab for.
+ *
+ * The encoding deliberately matches what VS Code puts on the wire, because
+ * that is what every language server has been tested against:
+ *
+ *   /home/ada/a b/c.ts   ->  file:///home/ada/a%20b/c.ts
+ *   C:\Users\ada\b.ts    ->  file:///c%3A/Users/ada/b.ts
+ *
+ * Two details that look like details and are not:
+ *
+ * - The Windows drive letter is lower-cased. The same file reached as `C:\` and
+ *   `c:\` must produce one URI, or a diagnostic published for one spelling never
+ *   clears the markers set under the other.
+ * - `/` is not escaped but everything else in a segment is, so a `#` or `?` in a
+ *   filename cannot truncate the URI into a fragment or a query.
+ */
+
+/** True for a Windows-style absolute path such as `C:\x` or `C:/x`. */
+function isWindowsAbsolute(path: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(path);
+}
+
+export function pathToFileUri(path: string): string {
+  const withSlashes = path.replace(/\\/g, "/");
+
+  if (isWindowsAbsolute(withSlashes)) {
+    const drive = withSlashes[0]!.toLowerCase();
+    const rest = withSlashes.slice(2); // drop "C:"
+    return `file:///${drive}%3A${encodePath(rest)}`;
+  }
+
+  // A UNC path (\\server\share) becomes an authority.
+  if (withSlashes.startsWith("//")) {
+    const [, , authority = "", ...segments] = withSlashes.split("/");
+    return `file://${encodeURIComponent(authority)}${encodePath(`/${segments.join("/")}`)}`;
+  }
+
+  return `file://${encodePath(withSlashes)}`;
+}
+
+/** Percent-encode each segment, leaving the separators alone. */
+function encodePath(path: string): string {
+  return path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+
+/**
+ * Turn a `file:` URI back into an OS path. Returns null for any other scheme —
+ * servers legitimately emit `untitled:` and their own custom schemes, and
+ * treating one of those as a path would open a tab for a file that never
+ * existed.
+ */
+export function fileUriToPath(uri: string): string | null {
+  if (!uri.startsWith("file:")) return null;
+
+  // file:///x, file://host/x, and the malformed-but-common file:/x.
+  let rest = uri.slice("file:".length);
+  let authority = "";
+  if (rest.startsWith("//")) {
+    rest = rest.slice(2);
+    const slash = rest.indexOf("/");
+    authority = slash < 0 ? rest : rest.slice(0, slash);
+    rest = slash < 0 ? "" : rest.slice(slash);
+  }
+
+  const decoded = rest.split("/").map(decodeSegment).join("/");
+
+  // A drive letter arrives as "/c:/Users/..." and has to lose the leading slash.
+  if (/^\/[A-Za-z]:/.test(decoded)) {
+    return decoded.slice(1);
+  }
+  if (authority) {
+    return `//${decodeSegment(authority)}${decoded}`;
+  }
+  return decoded;
+}
+
+function decodeSegment(segment: string): string {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    // A stray "%" that is not an escape — keep the segment verbatim rather than
+    // losing the whole path.
+    return segment;
+  }
+}
+
+/**
+ * A comparison key for two URIs that name the same file.
+ *
+ * Servers do not always echo a URI back byte for byte: casing of an escape
+ * (`%3a` vs `%3A`), an unescaped colon, or a Windows drive in the other case
+ * all appear in practice. Diagnostics are keyed by URI, so two spellings of one
+ * file means markers that are set twice and cleared never.
+ */
+export function uriKey(uri: string): string {
+  const path = fileUriToPath(uri);
+  if (path === null) return uri;
+  const normalized = path.replace(/\\/g, "/");
+  return isWindowsAbsolute(normalized)
+    // Windows paths are case-insensitive; POSIX paths are not, so only the
+    // drive letter is folded.
+    ? `${normalized[0]!.toLowerCase()}${normalized.slice(1)}`
+    : normalized;
+}

package/src/web/app.tsx

@@ -40,6 +40,7 @@ import { useExtensionWs } from "@/hooks/use-extension-ws";
 import { useIsMobile } from "@/hooks/use-is-mobile";
 import { UploadProgressPanel } from "@/components/os-explorer/upload/upload-progress-panel";
 import { cn } from "@/lib/utils";
+import { isRecoveryReloadPending } from "@/lib/chunk-recovery";
 
 // Lazy: the explorer feature (views, actions, skins, icon map) is the same heavy bundle the
 // desktop floating window already keeps out of the initial chunk (see `WINDOW_CONTENT`) —
@@ -148,6 +149,11 @@ export function App() {
   useEffect(() => {
     if (authState !== "authenticated") return;
     const handler = (e: BeforeUnloadEvent) => {
+      // Except when the app is reloading itself out of a missing chunk. This
+      // fires from `vite:preloadError`, before the throw unmounts anything, so
+      // the guard is still installed — and "Leave site?" in front of an
+      // automatic recovery is a question the user cannot answer usefully.
+      if (isRecoveryReloadPending()) return;
       e.preventDefault();
     };
     window.addEventListener("beforeunload", handler);

package/src/web/components/ai-resources/ai-resource-editor.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useState, useCallback, useRef } from "react";
 import Editor from "@monaco-editor/react";
-import { Save, Undo2, Loader2, AlertTriangle, Lock } from "lucide-react";
+import { Save, Undo2, Loader2, AlertTriangle, Lock } from "@/lib/icons";
 import { useMonacoTheme } from "@/lib/use-monaco-theme";
 import { useAiResourcesStore } from "@/stores/ai-resources-store";
 import { readAiResource, writeAiResource, type AiResourceType, type AiResourceScope } from "@/lib/api-ai-resources";

package/src/web/components/ai-resources/ai-resources-panel.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useState } from "react";
-import { RefreshCw, Search, Sparkles, FolderOpen } from "lucide-react";
+import { RefreshCw, Search, Sparkles, FolderOpen } from "@/lib/icons";
 import { SidebarHeader } from "@/components/ui/sidebar-header";
 import { useShallow } from "zustand/react/shallow";
 import { useProjectStore } from "@/stores/project-store";

package/src/web/components/ai-resources/mcp-group.tsx

@@ -1,4 +1,4 @@
-import { Plug, Plus, Download } from "lucide-react";
+import { Plug, Plus, Download } from "@/lib/icons";
 import {
   ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuSeparator,
 } from "@/components/ui/adaptive-context-menu";

package/src/web/components/ai-resources/new-resource-menu.tsx

@@ -1,4 +1,4 @@
-import { Plus, Hexagon, Bot, SquareTerminal, Plug, Download } from "lucide-react";
+import { Plus, Hexagon, Bot, SquareTerminal, Plug, Download } from "@/lib/icons";
 import {
   DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator,
 } from "@/components/ui/dropdown-menu";

package/src/web/components/ai-resources/resource-visuals.tsx

@@ -1,4 +1,4 @@
-import { Hexagon, Bot, SquareTerminal } from "lucide-react";
+import { Hexagon, Bot, SquareTerminal } from "@/lib/icons";
 import { cn } from "@/lib/utils";
 import type { AiResourceType, AiResourceScope } from "@/lib/api-ai-resources";
 

package/src/web/components/auth/login-screen.tsx

@@ -11,7 +11,7 @@ import {
   Bug,
   Github,
   Coffee,
-} from "lucide-react";
+} from "@/lib/icons";
 import { useSettingsStore } from "@/stores/settings-store";
 import { useIsMobile } from "@/hooks/use-is-mobile";
 import { openBugReportPopup } from "@/lib/report-bug";

package/src/web/components/auth/support-dialog.tsx

@@ -5,7 +5,7 @@
  * mobile. Adaptive shell — Dialog on desktop, BottomSheet on mobile.
  */
 import { useState } from "react";
-import { Globe, Heart, QrCode } from "lucide-react";
+import { Globe, Heart, QrCode } from "@/lib/icons";
 import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
 import { BottomSheet } from "@/components/ui/mobile-bottom-sheet";
 import { Button } from "@/components/ui/button";