@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/plugins/builtin/world-venue-map/scope.ts

@@ -0,0 +1,63 @@
+import { useMemo } from "react";
+import { useAppSelector, usePaneInstance } from "../../../state/app/context";
+import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
+import { usePluginPaneState } from "../../../public/react";
+import type { PaneInstanceConfig } from "../../../types/config";
+import { parseLayerTokens, LAYERS_SETTING_KEY } from "./layers";
+import { isLocalGeoLayer, type GeoScope } from "./local-layers";
+
+/**
+ * Pane state a ticker source may publish beside `cursorSymbol`: the group the
+ * selected company belongs to, which a linked map can widen to. TheBuildout
+ * publishes the theme its table lists.
+ */
+export const GEO_SCOPE_STATE_KEY = "geoScope";
+
+type GeoScopeMode = "company" | "theme";
+
+function publishedScope(value: unknown): GeoScope | null {
+  if (!value || typeof value !== "object") return null;
+  const { key, label } = value as Partial<GeoScope>;
+  return typeof key === "string" && key && typeof label === "string" ? { key, label } : null;
+}
+
+/** A map with one of the app's own layers on can be linked to a list's or a scanner's selection. */
+export function mapFollowsTicker(pane: PaneInstanceConfig): boolean {
+  return parseLayerTokens(pane.settings?.[LAYERS_SETTING_KEY]).some(isLocalGeoLayer);
+}
+
+export interface LinkedGeoScope {
+  /** What the map's own layers show; null shows everything. */
+  scope: GeoScope | null;
+  /** The company the link resolves to. */
+  company: GeoScope | null;
+  /** The group its source publishes for that company. */
+  theme: GeoScope | null;
+  mode: GeoScopeMode;
+  setMode: (mode: GeoScopeMode) => void;
+}
+
+/**
+ * What a linked map narrows its own layers to: the company the link resolves
+ * to, or the theme its source publishes once the pane is switched to it (and
+ * whenever there is no company). An unlinked map has neither and shows
+ * everything.
+ */
+export function useLinkedGeoScope(enabled: boolean): LinkedGeoScope {
+  const instance = usePaneInstance();
+  const linked = enabled && (instance?.binding?.kind === "follow" || instance?.binding?.kind === "fixed");
+  const sourceId = linked && instance?.binding?.kind === "follow" ? instance.binding.sourceInstanceId : null;
+  const published = useAppSelector((state) => (sourceId ? state.paneState[sourceId]?.[GEO_SCOPE_STATE_KEY] ?? null : null));
+  const { symbol } = usePaneTickerIdentity();
+  const [mode, setMode] = usePluginPaneState<GeoScopeMode>("geoScopeMode", "company");
+  const theme = linked ? publishedScope(published) : null;
+  const companySymbol = linked ? symbol : null;
+  const themeKey = theme?.key ?? null;
+  const themeLabel = theme?.label ?? "";
+  return useMemo(() => {
+    const company = companySymbol ? { key: `company:${companySymbol}`, label: companySymbol } : null;
+    const group = themeKey ? { key: themeKey, label: themeLabel } : null;
+    const scope = mode === "theme" ? group ?? company : company ?? group;
+    return { scope, company, theme: group, mode, setMode };
+  }, [companySymbol, mode, setMode, themeKey, themeLabel]);
+}

package/src/plugins/builtin/yield-curve/client.ts

@@ -1,7 +1,6 @@
 import { apiClient } from "../../../api-client";
 import type { SwapCurvePayload, SwapTenor } from "../../../api-client/swap-curve";
-import { isPermanentClientError } from "../../../api-client/errors";
-import { createPluginCache, type PluginCacheResult } from "../../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure, type PluginCacheResult } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { validateSwapCurve } from "./swaps-model";
 import { loadCurveData, type CurveData, type CurveId } from "./curves";
@@ -52,12 +51,11 @@ export interface SavedCopyAnswer<T> {
 const curveKey = (curve: CurveId, requestedDate: string) => `${curve}:${requestedDate || "latest"}`;
 /**
  * A copy is the saved one by where it came from, whatever its failure said. A
- * refusal asking again will not change (access denied, an unknown curve) is
- * said rather than covered by the copy, as `loadCloudResource` does.
+ * refusal (access denied, an unknown curve) or a reply that fails validation
+ * is said rather than covered by the copy, as `loadCloudResource` does.
  */
 function answer<T>(result: PluginCacheResult<T>): SavedCopyAnswer<T> {
-  const saved = result.source === "stale-fallback";
-  if (saved && isPermanentClientError(result.error)) throw result.error;
+  const saved = savedCopyForTransientFailure(result).source === "stale-fallback";
   return { data: result.data, savedAt: saved ? result.fetchedAt : null };
 }
 

package/src/plugins/builtin/yield-curve/curves.ts

@@ -44,7 +44,12 @@ export function curveOption(id: CurveId): CurveOption {
   return CURVE_OPTIONS.find((option) => option.id === id) ?? CURVE_OPTIONS[0]!;
 }
 
-/** `GC`, `GC 2026-01-02`, `GC JGB`, `GC TIPS 2024-01-02`: a curve word and a date, either order. */
+/**
+ * `GC`, `GC 2026-01-02`, `GC JGB`, `GC TIPS 2024-01-02`: a curve word and a
+ * date, either order. Words with no digit are no date: one that names no
+ * curve (`GC world`, `GC "South Africa"`) lists the curves and points at the
+ * world tab, which has the other countries' government yields.
+ */
 export function parseCurveArgument(value: unknown, now = new Date()): { curve: CurveId | null; date: string } {
   const words = typeof value === "string" ? value.trim().split(/\s+/).filter(Boolean) : [];
   let curve: CurveId | null = null;
@@ -54,7 +59,16 @@ export function parseCurveArgument(value: unknown, now = new Date()): { curve: C
     if (match && !curve) curve = match.id;
     else rest.push(word);
   }
-  return { curve, date: yieldCurveDate(rest.join(" ") || null, now) };
+  const text = rest.join(" ");
+  if (text && !/\d/.test(text) && text.toLowerCase() !== "latest") throw new Error(unknownCurveMessage(text));
+  return { curve, date: yieldCurveDate(text || null, now) };
+}
+
+/** `Unknown curve "world"`, with the curves there are and where the rest of the world's yields are. */
+export function unknownCurveMessage(word: string): string {
+  const names = CURVE_OPTIONS.map((option) => option.aliases[0]);
+  return `Unknown curve "${word}"; the curves are ${names.slice(0, -1).join(", ")} and ${names.at(-1)}. `
+    + "Other countries' government bond yields are on the world tab: gloom fn GC --tab world.";
 }
 
 /**

package/src/plugins/builtin/yield-curve/headless.ts

@@ -3,8 +3,8 @@ import type {
   HeadlessPaneDefinition,
 } from "../../../types/plugin";
 import {
-  compareDate, curveCutoff, CURVE_OPTIONS, curveIdOf, curveOption, curveSpreadFigures, curveTenorMove, loadComparePoints,
-  parseCompareInput, parseCurveArgument, type CurveData, type CurveId,
+  compareDate, curveCutoff, curveIdOf, curveOption, curveSpreadFigures, curveTenorMove, loadComparePoints,
+  parseCompareInput, parseCurveArgument, unknownCurveMessage, type CurveData, type CurveId,
 } from "./curves";
 import { yieldTenorRows, type YieldLookbackCurves } from "./chart";
 import { curveAsOf, type YieldPoint, yieldCurveErrors } from "./treasury-data";
@@ -194,7 +194,7 @@ export function createYieldCurveHeadless(
       const argument = parseCurveArgument(args.argument);
       const optionCurve = args.options.curve == null || args.options.curve === "" ? null : curveIdOf(args.options.curve);
       if (args.options.curve && !optionCurve) {
-        throw new Error(`Unknown curve ${String(args.options.curve)}; use ${CURVE_OPTIONS.map((option) => option.aliases[0]).join(", ")}.`);
+        throw new Error(unknownCurveMessage(String(args.options.curve)));
       }
       const curve = optionCurve ?? argument.curve ?? "us";
       const requestedDate = args.options.date != null ? yieldCurveDate(args.options.date, new Date(), "--date") : argument.date;

package/src/plugins/bundle.ts

@@ -1,10 +1,16 @@
 import { mkdir } from "fs/promises";
-import { join } from "path";
+import { basename, join } from "path";
 
 import { explainPluginLoadError } from "./compat";
 import { hostPublicModules } from "./host-link";
 import { resolvePluginBrowserEntry, resolvePluginEntry } from "./loader";
+import { siblingImportsBundlerPlugin } from "./peer-imports";
 import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS, importPluginHostModule } from "./host-modules";
+import {
+  PLUGIN_PROCESS_IDENTIFIER,
+  pluginProcessDeclaration,
+  pluginProcessModuleSource,
+} from "./plugin-process";
 
 /**
  * Compiles an external plugin for a renderer that cannot read the filesystem.
@@ -90,6 +96,7 @@ export interface BundlePluginResult {
 function createSharedModuleResolver(
   exportNamesFor: (specifier: string) => Promise<readonly string[]>,
   onShared?: (specifier: string) => void,
+  options: { providesProcess?: boolean } = {},
 ): import("bun").BunPlugin {
   const namespace = "gloom-host";
   const shared = new Set<string>(SHARED_SPECIFIERS);
@@ -118,6 +125,19 @@ function createSharedModuleResolver(
         contents: buildSharedModuleSource(args.path, await exportNamesFor(args.path)),
         loader: "js",
       }));
+
+      if (!options.providesProcess) return;
+      // `import process from "node:process"` reads the same shim as the bare
+      // global. Bun's own browser stand-in has no default export, so without
+      // this such a plugin did not compile for the desktop at all.
+      build.onResolve({ filter: /^(?:node:)?process$/ }, () => ({
+        path: "process",
+        namespace: "gloom-process",
+      }));
+      build.onLoad({ filter: /.*/, namespace: "gloom-process" }, () => ({
+        contents: pluginProcessModuleSource(),
+        loader: "js",
+      }));
     },
   };
 }
@@ -144,6 +164,11 @@ export async function bundleExternalPlugin(
      */
     minify?: boolean;
     define?: Record<string, string>;
+    /**
+     * Named in the errors the browser's `process` stand-in throws. Defaults to
+     * the plugin's folder name.
+     */
+    pluginName?: string;
     /**
      * `bun` compiles the native entry the terminal imports instead. Only the
      * registry check uses it, to cover the native half of a plugin that has
@@ -161,7 +186,16 @@ export async function bundleExternalPlugin(
 
   await mkdir(outDir, { recursive: true });
 
+  // The browser has no `process`, which the terminal gives every plugin. Each
+  // bundle gets its own stand-in (see plugin-process.ts); a bundle compiled
+  // for Bun runs where the real one exists.
+  const providesProcess = (options.target ?? "browser") === "browser";
+  const pluginName = options.pluginName ?? basename(pluginDir);
+
   const shared = new Set<string>();
+  // A sibling plugin it imports is compiled from the sibling's folder, as
+  // the loader imports it, not through the plugin's link (peer-imports.ts).
+  const siblings = siblingImportsBundlerPlugin(pluginDir);
   const result = await Bun.build({
     entrypoints: [entry],
     outdir: outDir,
@@ -174,12 +208,19 @@ export async function bundleExternalPlugin(
     // `errors`. Returning it lets the check below report what actually broke,
     // such as an import this host version does not export.
     throw: false,
-    ...(options.define ? { define: options.define } : {}),
+    // The more specific `process.env.NODE_ENV` a caller defines still wins,
+    // so dead branches keyed on it stay dropped.
+    define: {
+      ...(providesProcess ? { process: PLUGIN_PROCESS_IDENTIFIER } : {}),
+      ...options.define,
+    },
     plugins: [
       createSharedModuleResolver(
         options.exportNamesFor ?? hostExportNames,
         (specifier) => shared.add(specifier),
+        { providesProcess },
       ),
+      ...(siblings ? [siblings] : []),
     ],
   });
 
@@ -188,6 +229,15 @@ export async function bundleExternalPlugin(
   const output = result.outputs.find((entryOutput) => entryOutput.kind === "entry-point");
   if (!output) throw new Error(`Bundling ${pluginDir} produced no entry point`);
 
+  // Only a bundle that reads `process` carries the stand-in, so the rest of
+  // the plugins the web app serves stay as small as they were.
+  if (providesProcess) {
+    const code = await Bun.file(output.path).text();
+    if (code.includes(PLUGIN_PROCESS_IDENTIFIER)) {
+      await Bun.write(output.path, pluginProcessDeclaration(pluginName) + code);
+    }
+  }
+
   return {
     outputPath: output.path,
     shared: [...shared].sort(),

package/src/plugins/catalog-browser.ts

@@ -43,7 +43,7 @@ import { ipoCalendarPlugin } from "./builtin/ipo-calendar";
 import { clinicalTrialsPlugin } from "./builtin/clinical-trials";
 import { commentLettersPlugin } from "./builtin/comment-letters";
 import { openFdaPlugin } from "./builtin/openfda";
-import { browserGloomberbCloudPlugin } from "./builtin/cloud/browser";
+import { gloomberbCloudPlugin } from "./builtin/cloud";
 import { changelogModule } from "./builtin/changelog";
 import { roadmapModule } from "./builtin/roadmap";
 import { chartComposerModule } from "./builtin/chart-composer";
@@ -298,7 +298,7 @@ const browserEarningsPlugin = composeBuiltinPlugin({
  * browser-safe public API are absent rather than registered behind stubs.
  */
 export const browserBuiltinPlugins: readonly GloomPlugin[] = [
-  browserGloomberbCloudPlugin,
+  gloomberbCloudPlugin,
   browserPortfolioPlugin,
   browserTickerCorePlugin,
   browserOptionsVolatilityPlugin,

package/src/plugins/catalog-cli.ts

@@ -0,0 +1,20 @@
+import type { CliCommandDef } from "../types/plugin";
+import { fearGreedPluginMeta, newsPluginMeta, notesPluginMeta, portfolioPluginMeta } from "./builtin/builtin-plugin-meta";
+import { ALERTS_PLUGIN_ID } from "./builtin/alerts/constants";
+import { alertsCliCommand } from "./builtin/alerts/cli";
+import { fearGreedCliCommand } from "./builtin/fear-greed/cli";
+import { rssCliCommand } from "./builtin/news/wire/rss/cli";
+import { notesCliCommand } from "./builtin/notes/cli";
+import { portfolioCliCommand } from "./builtin/portfolio-list/cli/portfolio-command";
+import { watchlistCliCommand } from "./builtin/portfolio-list/cli/watchlist-command";
+
+/** Command definitions shared with the plugins, without loading their pane components. */
+export function getBuiltinCliCommands(): { pluginId: string; commands: CliCommandDef[] }[] {
+  return [
+    { pluginId: portfolioPluginMeta.id, commands: [portfolioCliCommand, watchlistCliCommand] },
+    { pluginId: newsPluginMeta.id, commands: [rssCliCommand] },
+    { pluginId: notesPluginMeta.id, commands: [notesCliCommand] },
+    { pluginId: fearGreedPluginMeta.id, commands: [fearGreedCliCommand] },
+    { pluginId: ALERTS_PLUGIN_ID, commands: [alertsCliCommand] },
+  ];
+}

package/src/plugins/host-link.ts

@@ -225,6 +225,8 @@ export interface PeerLinkState {
   target: string | null;
   /** The link resolves to the sibling's folder. */
   linked: boolean;
+  /** Why reading through the link failed, when it did: it can be in place and still not lead anywhere. */
+  resolveError?: string;
   /** Links this process wrote at that path, and when it last did. */
   writes: number;
   lastWriteAt?: number;
@@ -272,11 +274,21 @@ export function describePeerLink(pluginDir: string, peer: string, pluginsDir: st
     link = stats.isSymbolicLink() ? (process.platform === "win32" ? "junction" : "symlink") : "file";
   }
   const isLinkType = link === "junction" || link === "symlink";
+  const linked = directory !== null && alreadyLinked(linkPath, join(pluginsDir, directory));
+  let resolveError: string | undefined;
+  if (isLinkType && !linked) {
+    try {
+      statSync(linkPath);
+    } catch (error) {
+      resolveError = errorCode(error);
+    }
+  }
   return {
     ...base,
     link,
     target: isLinkType ? describeTarget(linkPath, pluginsDir) : null,
-    linked: directory !== null && alreadyLinked(linkPath, join(pluginsDir, directory)),
+    linked,
+    ...(resolveError ? { resolveError } : {}),
   };
 }
 

package/src/plugins/installer.ts

@@ -7,6 +7,7 @@ import { findAbsorbedPlugin, type AbsorbedPlugin } from "./absorbed";
 import type { PluginPin } from "./marketplace/store";
 import { bunCommand, recordDependencyInstall } from "./dependencies";
 import { linkHostPackages, missingPeerPlugins } from "./host-link";
+import { importSiblingsFromTheirFolders } from "./peer-imports";
 import {
   findAbsorbedCheckout,
   getPluginsDir,
@@ -42,7 +43,7 @@ function ensurePluginsDir() {
   }
 }
 
-const GITHUB_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const GITHUB_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/;
 const COMMIT_PATTERN = /^[0-9a-f]{7,40}$/i;
 
 export function validatePluginDirectoryName(name: string): string {
@@ -114,6 +115,13 @@ interface RunResult {
   stderr: string;
 }
 
+/** Resolves git before a command changes into a plugin checkout. */
+function gitExecutable(): string {
+  const executable = Bun.which("git");
+  if (!executable) throw Object.assign(new Error(gitMissingMessage()), { code: "ENOENT" });
+  return executable;
+}
+
 /**
  * Runs a command without blocking the event loop: a fetch or `bun install`
  * takes seconds, and the terminal UI and the desktop's Bun process keep
@@ -128,7 +136,7 @@ function run(
   env?: NodeJS.ProcessEnv,
 ): Promise<RunResult> {
   return new Promise((resolveRun, reject) => {
-    const child = spawn(command, args, { cwd, env, stdio: ["ignore", output.stdout, output.stderr] });
+    const child = spawn(command === "git" ? gitExecutable() : command, args, { cwd, env, stdio: ["ignore", output.stdout, output.stderr] });
     let stdout = "";
     let stderr = "";
     child.stdout?.setEncoding("utf-8").on("data", (chunk: string) => { stdout += chunk; });
@@ -141,7 +149,13 @@ function run(
 /** Whether a `git` command is on the PATH; plugins from GitHub need one to install or update. */
 export function gitInstalled(): boolean {
   if (typeof Bun !== "undefined") return Bun.which("git") !== null;
-  return gitSucceeds(["--version"], process.cwd());
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    // Intentional ignore: a git that does not start is the answer this asks for.
+    return false;
+  }
 }
 
 /** What a plugin install says when there is no git to run: what to install, then to try again. */
@@ -171,14 +185,9 @@ async function git(args: string[], cwd: string, quiet: boolean, failure: string)
   return result.stdout.trim();
 }
 
-function isOnBranch(dir: string): boolean {
-  try {
-    execFileSync("git", ["symbolic-ref", "-q", "HEAD"], { cwd: dir, stdio: "ignore" });
-    return true;
-  } catch {
-    // Intentional ignore: Detached HEAD is expected after a pinned install.
-    return false;
-  }
+/** False on a detached HEAD, which a pinned install leaves. */
+function isOnBranch(dir: string): Promise<boolean> {
+  return gitSucceedsAsync(["symbolic-ref", "-q", "HEAD"], dir);
 }
 
 function pinMatches(commit: string | null, expected: string | undefined): boolean {
@@ -208,27 +217,27 @@ async function checkoutCommit(targetDir: string, commit: string, quiet: boolean)
   await git(["checkout", "--detach", "--force", commit], targetDir, quiet, `Could not check out ${commit.slice(0, 7)}`);
 }
 
-function gitSucceeds(args: string[], cwd: string): boolean {
-  try {
-    execFileSync("git", args, { cwd, stdio: "ignore" });
-    return true;
-  } catch {
-    // Intentional ignore: Non-ancestor and shallow histories use package versions and commit dates instead.
-    return false;
-  }
+
+/*
+ * The update path runs in the app (the terminal, the desktop's Bun process),
+ * where a sync git call holds the thread for the whole process start: tens of
+ * milliseconds each on Windows, several per plugin. These never block it.
+ */
+async function gitSucceedsAsync(args: string[], cwd: string): Promise<boolean> {
+  const result = await run("git", args, cwd, { stdout: "pipe", stderr: "pipe" })
+    .catch(logFailure("plugin-installer", "Could not run git", null));
+  return result?.code === 0;
 }
 
-function gitOutput(args: string[], cwd: string): string | null {
-  try {
-    return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString("utf-8").trim();
-  } catch {
-    // Intentional ignore: Shallow or manifest-free checkouts may lack historical metadata.
-    return null;
-  }
+/** Null when git fails: shallow or manifest-free checkouts may lack historical metadata. */
+async function gitOutputAsync(args: string[], cwd: string): Promise<string | null> {
+  const result = await run("git", args, cwd, { stdout: "pipe", stderr: "pipe" })
+    .catch(logFailure("plugin-installer", "Could not run git", null));
+  return result?.code === 0 ? result.stdout.trim() : null;
 }
 
-function versionAt(dir: string, commit: string): string | null {
-  const text = gitOutput(["show", `${commit}:package.json`], dir);
+async function versionAt(dir: string, commit: string): Promise<string | null> {
+  const text = await gitOutputAsync(["show", `${commit}:package.json`], dir);
   if (!text) return null;
   try {
     const version = JSON.parse(text).version;
@@ -247,15 +256,15 @@ function versionAt(dir: string, commit: string): string | null {
  * it; otherwise the versions the two commits declare decide, then, when
  * those match, their commit dates.
  */
-export function describeOlderCommit(dir: string, installed: string, candidate: string, label = candidate.slice(0, 7)): string | null {
-  if (installed === candidate || gitSucceeds(["merge-base", "--is-ancestor", installed, candidate], dir)) return null;
-  const installedVersion = versionAt(dir, installed);
-  const byVersion = compareSemver(versionAt(dir, candidate), installedVersion);
+export async function describeOlderCommit(dir: string, installed: string, candidate: string, label = candidate.slice(0, 7)): Promise<string | null> {
+  if (installed === candidate || await gitSucceedsAsync(["merge-base", "--is-ancestor", installed, candidate], dir)) return null;
+  const installedVersion = await versionAt(dir, installed);
+  const byVersion = compareSemver(await versionAt(dir, candidate), installedVersion);
   const older = () => `the registry's ${label} is older than the installed ${byVersion ? installedVersion : installed.slice(0, 7)}`;
-  if (gitSucceeds(["merge-base", "--is-ancestor", candidate, installed], dir)) return older();
+  if (await gitSucceedsAsync(["merge-base", "--is-ancestor", candidate, installed], dir)) return older();
   if (byVersion !== null && byVersion !== 0) return byVersion < 0 ? older() : null;
-  const candidateTime = Number(gitOutput(["show", "-s", "--format=%ct", candidate], dir));
-  const installedTime = Number(gitOutput(["show", "-s", "--format=%ct", installed], dir));
+  const candidateTime = Number(await gitOutputAsync(["show", "-s", "--format=%ct", candidate], dir));
+  const installedTime = Number(await gitOutputAsync(["show", "-s", "--format=%ct", installed], dir));
   return candidateTime > 0 && installedTime > 0 && candidateTime < installedTime ? older() : null;
 }
 
@@ -296,6 +305,9 @@ async function readPluginExport(targetDir: string): Promise<Pick<GloomPlugin, "i
   if (missingPeerPlugins(targetDir).length > 0) return null;
   const entryFile = await resolvePluginEntry(targetDir);
   if (!entryFile) return null;
+  // The siblings from their folders, as the loader imports them, so the
+  // modules this caches are the ones a load in this process reuses.
+  importSiblingsFromTheirFolders(targetDir);
   // Fresh so an update is validated against the new code, not the module Bun
   // cached when the previous version loaded.
   const plugin = pluginFromModule(await import(`${entryFile}?validate=${Date.now()}`));
@@ -403,19 +415,29 @@ export interface PluginUpdateResult extends PluginDirectoryInfo {
   kept?: string;
 }
 
+function githubRepoFromUrl(url: string): string | null {
+  const match = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(url.trim());
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+
 /** `owner/repo` from the checkout's origin remote, or null for anything that is not a GitHub clone. */
 export function readPluginRemote(pluginDir: string): string | null {
   try {
-    const url = execFileSync("git", ["config", "--get", "remote.origin.url"], { cwd: pluginDir, stdio: ["ignore", "pipe", "ignore"] })
-      .toString("utf-8").trim();
-    const match = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(url);
-    return match ? `${match[1]}/${match[2]}` : null;
+    return githubRepoFromUrl(execFileSync(gitExecutable(), ["config", "--get", "remote.origin.url"], { cwd: pluginDir, stdio: ["ignore", "pipe", "ignore"] })
+      .toString("utf-8"));
   } catch {
     // Intentional ignore: Hand-copied plugins and local repositories may have no origin remote.
     return null;
   }
 }
 
+/** `readPluginRemote` without holding the thread, for the app's own update check. */
+export async function readPluginRemoteAsync(pluginDir: string): Promise<string | null> {
+  // No origin remote (a hand-copied plugin, a local repository) is a failed git, and no repo.
+  const url = await gitOutputAsync(["config", "--get", "remote.origin.url"], pluginDir);
+  return url ? githubRepoFromUrl(url) : null;
+}
+
 /** The sha from `git ls-remote origin HEAD`; null when the answer is not one. */
 export function parseRemoteHead(output: string): string | null {
   const sha = output.trim().split(/\s+/)[0] ?? "";
@@ -439,7 +461,7 @@ export async function readPluginRemoteHead(name: string): Promise<string | null>
   if (!existsSync(join(dir, ".git"))) return null;
   if (lstatSync(dir, { throwIfNoEntry: false })?.isSymbolicLink()) return null;
   try {
-    const { stdout } = await execFile("git", ["ls-remote", "origin", "HEAD"], {
+    const { stdout } = await execFile(gitExecutable(), ["ls-remote", "origin", "HEAD"], {
       cwd: dir,
       timeout: REMOTE_HEAD_TIMEOUT_MS,
       env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "echo" },
@@ -500,7 +522,7 @@ export async function updatePlugin(name: string, options: PluginInstallOptions =
     const commit = await fetchPin(targetDir, pin, quiet);
     // Updates only move forward: a checkout installed from the default
     // branch can be ahead of the tag the registry reviewed.
-    const kept = before ? describeOlderCommit(targetDir, before, commit, pin.ref ?? commit.slice(0, 7)) : null;
+    const kept = before ? await describeOlderCommit(targetDir, before, commit, pin.ref ?? commit.slice(0, 7)) : null;
     if (kept) {
       if (!quiet) console.log(cliStyles.muted(`Kept ${name}: ${kept}.`));
       return { ...describe(targetDir, name, null), before, changed: false, kept };
@@ -510,7 +532,7 @@ export async function updatePlugin(name: string, options: PluginInstallOptions =
     // Not in the registry, so there is nothing reviewed to land on: follow the
     // remote's default branch, whether the checkout is on a branch or detached
     // from an earlier pin.
-    if (isOnBranch(targetDir)) {
+    if (await isOnBranch(targetDir)) {
       await git(["pull", "--ff-only"], targetDir, quiet, `Failed to update ${name}`);
     } else {
       await git(["fetch", "--depth", "1", "origin", "HEAD"], targetDir, quiet, `Failed to fetch ${name}`);

package/src/plugins/loader.ts

@@ -15,8 +15,10 @@ import {
   missingPluginDependencies,
   settleDependencyInstalls,
 } from "./dependencies";
-import { declaredPeerPlugins, describePeerLink, isLinkedPeerModule, linkHostPackages, relinkPeerPlugin } from "./host-link";
+import { declaredPeerPlugins, describePeerLink, installedPeerPlugins, isLinkedPeerModule, linkHostPackages, relinkPeerPlugin } from "./host-link";
+import { importSiblingsFromTheirFolders } from "./peer-imports";
 import { refreshResolverFolders, rekeyedEntry, withoutRetryQuery } from "./peer-retry";
+import { redirectionGuard } from "./redirection-guard";
 import { pluginDirectoryNames } from "./plugin-names";
 import { pluginFromModule, pluginSupportsTarget } from "./plugin-export";
 
@@ -258,7 +260,7 @@ function hasStaleModules(pluginDir: string, commit: string | null): boolean {
  */
 const retriedEntries = new Map<string, string>();
 
-/** Plugin folders whose recovery this process already reported; once is enough to explain it. */
+/** Plugin folders whose recovery, or link that did not resolve, this process already reported; once is enough to explain it. */
 const reportedRecoveries = new Set<string>();
 
 /** Loads running now, which a crash report counts: two at once share the links they rewrite. */
@@ -299,30 +301,55 @@ function failedPeer(pluginDir: string, specifier: string | undefined): string |
 /**
  * The state of the link to `peer` and around it, for the crash report of an
  * import that failed on it: whether the sibling's folder is there, what the
- * link is and where it points, whether the retry rewrote it, how often this
- * process wrote it before, which `bun install` runs this process made, how
- * many loads ran at once, and whether this is the first launch of the version.
+ * link is and where it points, why reading through it failed, whether the
+ * retry rewrote it, how often this process wrote it before, which `bun
+ * install` runs this process made, how many loads ran at once, whether this
+ * is the first launch of the version, and on Windows whether this process
+ * may follow a junction (redirection-guard.ts). `how` leads: the retry's
+ * outcome, or how a plugin that loaded imported the sibling.
  */
-function describePeerFailure(pluginDir: string, peer: string, relinked: string, retry: string): string {
+function describePeerLinkState(pluginDir: string, peer: string, how: string, relinked?: string): string {
   const link = describePeerLink(pluginDir, peer);
   const now = Date.now();
   const installs = describeDependencyInstalls(now);
+  const guard = redirectionGuard();
   const fields = [
-    `retry=${retry}`,
+    how,
     `peer=${peer}`,
     `dir=${link.directory ?? "missing"}`,
     `link=${link.link}${link.target ? `->${link.target}` : ""}${link.linked ? "" : "(not-resolving)"}`,
-    `relinked=${relinked}`,
+    ...(link.resolveError ? [`link-stat=${link.resolveError}`] : []),
+    ...(relinked ? [`relinked=${relinked}`] : []),
     `link-writes=${link.writes}${link.lastWriteAt ? `@${((now - link.lastWriteAt) / 1000).toFixed(1)}s` : ""}`,
     ...(link.lastError ? [`link-error=${link.lastError}`] : []),
     `installs=${installs.length > 0 ? installs.slice(0, 4).join(",") : "none"}`,
     `loads=${loadsInFlight}`,
     `first-launch=${firstLaunchOfVersion === null ? "unknown" : firstLaunchOfVersion ? "yes" : "no"}`,
     ...(typeof Bun !== "undefined" ? [`bun=${Bun.version}`] : []),
+    ...(guard ? [`redirection-guard=${guard}`] : []),
   ];
   return fields.join(" ");
 }
 
+/**
+ * Reports, once per plugin and process, a plugin that loaded while its link
+ * to a sibling it imports does not resolve. The import itself went to the
+ * sibling's folder (peer-imports.ts), so nothing failed; the report says the
+ * link would have failed it, and why, which is how the first launch after an
+ * update looks when the old failure is gone.
+ */
+function reportUnresolvedSiblingLinks(pluginDir: string, directory: string): void {
+  if (reportedRecoveries.has(pluginDir)) return;
+  for (const { peer } of installedPeerPlugins(pluginDir)) {
+    if (describePeerLink(pluginDir, peer).linked) continue;
+    reportedRecoveries.add(pluginDir);
+    const detail = describePeerLinkState(pluginDir, peer, "peer-import=folder");
+    loaderLog.info(`Loaded ${directory} with ${peer} read from its folder; the link to it does not resolve [${detail}]`);
+    reportCrash(new Error(`Loaded ${directory} past a link to ${peer} that does not resolve`), { kind: "plugin", plugin: directory, detail });
+    return;
+  }
+}
+
 type PeerRetry =
   | { module: unknown; detail: string }
   | { error: unknown; detail: string };
@@ -353,14 +380,14 @@ async function retryPeerImport(pluginDir: string, entryFile: string, peer: strin
   refreshResolverFolders(pluginDir, [peer]);
   const specifier = rekeyedEntry(entryFile, pluginDir);
   if (!specifier) {
-    return { error: new Error("This process cannot import a plugin again."), detail: describePeerFailure(pluginDir, peer, relinked, "unavailable") };
+    return { error: new Error("This process cannot import a plugin again."), detail: describePeerLinkState(pluginDir, peer, "retry=unavailable", relinked) };
   }
   try {
     const module = await import(specifier);
     retriedEntries.set(pluginDir, specifier);
-    return { module, detail: describePeerFailure(pluginDir, peer, relinked, "loaded") };
+    return { module, detail: describePeerLinkState(pluginDir, peer, "retry=loaded", relinked) };
   } catch (error) {
-    return { error, detail: describePeerFailure(pluginDir, peer, relinked, "failed") };
+    return { error, detail: describePeerLinkState(pluginDir, peer, "retry=failed", relinked) };
   }
 }
 
@@ -475,6 +502,10 @@ async function loadPluginDirectory(
     };
   };
 
+  // A sibling it imports is read from the sibling's folder, not through the
+  // link just made: a process can be unable to follow that link at all.
+  importSiblingsFromTheirFolders(pluginDir);
+
   let module: unknown;
   try {
     const retried = options.fresh ? undefined : retriedEntries.get(pluginDir);
@@ -496,6 +527,7 @@ async function loadPluginDirectory(
     }
     module = retry.module;
   }
+  reportUnresolvedSiblingLinks(pluginDir, directory);
 
   try {
     const plugin = pluginFromModule(module);