gloomberb 0.18.2 → 0.18.4

package/src/plugins/loader.ts

@@ -1,15 +1,23 @@
 import { logFailure } from "../utils/log-failure";
 import { readdir } from "fs/promises";
-import { basename, join } from "path";
-import { existsSync, lstatSync, readFileSync, statSync } from "fs";
+import { basename, dirname, join } from "path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { getGloomberbDirs } from "../data/config/home";
 import type { GloomPlugin, PluginTarget } from "../types/plugin";
 import { debugLog } from "../utils/debug-log";
 import { reportCrash } from "../telemetry/crash-reports";
+import { VERSION } from "../version";
 import { findAbsorbedPlugin, type AbsorbedPlugin } from "./absorbed";
 import { checkPluginCompatibility, explainPluginLoadError, findMissingHostExport, pluginSourceFiles, readPluginManifest } from "./compat";
-import { installPluginDependencies, missingPluginDependencies } from "./dependencies";
-import { isLinkedPeerModule, linkHostPackages } from "./host-link";
+import {
+  describeDependencyInstalls,
+  installPluginDependencies,
+  missingPluginDependencies,
+  settleDependencyInstalls,
+} from "./dependencies";
+import { declaredPeerPlugins, describePeerLink, isLinkedPeerModule, linkHostPackages, relinkPeerPlugin } from "./host-link";
+import { refreshResolverFolders, rekeyedEntry, withoutRetryQuery } from "./peer-retry";
+import { pluginDirectoryNames } from "./plugin-names";
 import { pluginFromModule, pluginSupportsTarget } from "./plugin-export";
 
 const loaderLog = debugLog.createLogger("plugin-loader");
@@ -31,7 +39,7 @@ export interface LoadedExternalPlugin {
   commit?: string;
   /** `owner/repo` of the checkout's GitHub origin; usage counts trust only gloom-sh's. */
   repo?: string;
-  /** A symlink to a local checkout (`gloomberb plugin link`) rather than a clone. */
+  /** A symlink to a local checkout (`gloom plugin link`) rather than a clone. */
   linked?: boolean;
   /**
    * The plugin's logo as a `data:` URL (plugin-icon.ts), for the desktop and
@@ -67,8 +75,8 @@ export function getPluginCacheDir(): string {
  * Whether a directory inside the plugins folder is a plugin at all.
  *
  * Dot-directories are bookkeeping, not plugins: the desktop bundle cache used
- * to be written to `plugins/.cache`, and it showed up in `gloomberb plugins`
- * as an installed plugin and in `gloomberb update` as a repo to pull. The
+ * to be written to `plugins/.cache`, and it showed up in `gloom plugins`
+ * as an installed plugin and in `gloom update` as a repo to pull. The
  * cache has moved out, but old installs still have that directory, so this
  * stays as the single rule every reader shares.
  */
@@ -176,7 +184,7 @@ export function findAbsorbedCheckout(pluginDir: string): AbsorbedPlugin | null {
 
 function skipsAbsorbedCheckout(pluginDir: string, absorbed: AbsorbedPlugin | null = findAbsorbedCheckout(pluginDir)): boolean {
   if (!absorbed) return false;
-  loaderLog.debug(`Skipped ${basename(pluginDir)}: ${absorbed.name} is built into Gloomberb now`);
+  loaderLog.debug(`Skipped ${basename(pluginDir)}: ${absorbed.name} is built into Gloom now`);
   return true;
 }
 
@@ -243,6 +251,119 @@ function hasStaleModules(pluginDir: string, commit: string | null): boolean {
   }
 }
 
+/**
+ * The entry a plugin was imported from on a retry, by plugin folder. A later
+ * load of the same plugin that is not fresh imports it from there again, so
+ * it gets the modules that loaded instead of the failed ones.
+ */
+const retriedEntries = new Map<string, string>();
+
+/** Plugin folders whose recovery 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. */
+let loadsInFlight = 0;
+
+/**
+ * Whether this process is the first to load plugins since this version was
+ * installed, null until the first full load records it. Read from a marker
+ * in the plugin cache, which the first startup load of a new version writes.
+ */
+let firstLaunchOfVersion: boolean | null = null;
+
+function recordLaunchedVersion(): void {
+  if (firstLaunchOfVersion !== null) return;
+  const marker = join(PLUGIN_CACHE_DIR, "loaded-version");
+  try {
+    const previous = existsSync(marker) ? readFileSync(marker, "utf-8").trim() : null;
+    firstLaunchOfVersion = previous !== VERSION;
+    if (firstLaunchOfVersion) {
+      mkdirSync(PLUGIN_CACHE_DIR, { recursive: true });
+      writeFileSync(marker, VERSION);
+    }
+  } catch (error) {
+    logFailure("plugin-loader", "Recording the loaded version failed")(error);
+  }
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+/** The sibling plugin a failed import named, when the plugin declares it as a peer. */
+function failedPeer(pluginDir: string, specifier: string | undefined): string | null {
+  if (!specifier) return null;
+  return declaredPeerPlugins(pluginDir).find((peer) => specifier === peer || specifier.startsWith(`${peer}/`)) ?? null;
+}
+
+/**
+ * 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.
+ */
+function describePeerFailure(pluginDir: string, peer: string, relinked: string, retry: string): string {
+  const link = describePeerLink(pluginDir, peer);
+  const now = Date.now();
+  const installs = describeDependencyInstalls(now);
+  const fields = [
+    `retry=${retry}`,
+    `peer=${peer}`,
+    `dir=${link.directory ?? "missing"}`,
+    `link=${link.link}${link.target ? `->${link.target}` : ""}${link.linked ? "" : "(not-resolving)"}`,
+    `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}`] : []),
+  ];
+  return fields.join(" ");
+}
+
+type PeerRetry =
+  | { module: unknown; detail: string }
+  | { error: unknown; detail: string };
+
+/**
+ * The import that failed on `peer`, once more after linking the sibling
+ * again: past Bun's cached view of the plugin's folders and under new module
+ * keys (see peer-retry.ts), so it really resolves the sibling again rather
+ * than replaying the failure.
+ */
+async function retryPeerImport(pluginDir: string, entryFile: string, peer: string): Promise<PeerRetry> {
+  // A `bun install` still running in the plugin or the sibling prunes the
+  // link it is about to need.
+  const peerDirs = pluginDirectoryNames(peer).map((name) => join(dirname(pluginDir), name));
+  await settleDependencyInstalls([pluginDir, ...peerDirs], 15_000);
+  // Windows refuses a new junction where one is still being deleted until
+  // every handle on the old one closes; that passes in moments.
+  const attempts = [relinkPeerPlugin(pluginDir, peer)];
+  for (const delayMs of [250, 1_000]) {
+    if (!attempts.at(-1)!.startsWith("failed")) break;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    attempts.push(relinkPeerPlugin(pluginDir, peer));
+  }
+  const relinked = attempts.join(",");
+  // An install that finished during the wait pruned `gloomberb` and `react`
+  // as well. After the sibling's own relink, so `relinked` says what that did.
+  linkHostPackages(pluginDir);
+  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") };
+  }
+  try {
+    const module = await import(specifier);
+    retriedEntries.set(pluginDir, specifier);
+    return { module, detail: describePeerFailure(pluginDir, peer, relinked, "loaded") };
+  } catch (error) {
+    return { error, detail: describePeerFailure(pluginDir, peer, relinked, "failed") };
+  }
+}
+
 /**
  * Loads one plugin directory. Never throws: a broken plugin comes back with
  * `error` set. Null for a folder that is not a plugin, and for a leftover
@@ -253,6 +374,19 @@ export async function loadExternalPlugin(
   pluginDir: string,
   target: PluginTarget = "cli",
   options: LoadExternalPluginOptions = {},
+): Promise<LoadedExternalPlugin | null> {
+  loadsInFlight += 1;
+  try {
+    return await loadPluginDirectory(pluginDir, target, options);
+  } finally {
+    loadsInFlight -= 1;
+  }
+}
+
+async function loadPluginDirectory(
+  pluginDir: string,
+  target: PluginTarget,
+  options: LoadExternalPluginOptions,
 ): Promise<LoadedExternalPlugin | null> {
   const directory = basename(pluginDir);
   missingHostExportFailures.delete(directory);
@@ -303,9 +437,68 @@ export async function loadExternalPlugin(
   const restart = hasStaleModules(pluginDir, commit) ? { needsRestart: true } : {};
   if (!importedCommits.has(pluginDir)) importedCommits.set(pluginDir, commit);
 
+  const failed = (err: unknown, retry?: Extract<PeerRetry, { error: unknown }>): LoadedExternalPlugin => {
+    const message = errorMessage(err);
+    let detail: string | undefined;
+    if (retry) {
+      // As plain text: escaping would double a Windows path's backslashes,
+      // and the home folder would no longer be recognized to remove.
+      const retryMessage = withoutRetryQuery(errorMessage(retry.error));
+      detail = retryMessage === message ? retry.detail : `${retry.detail} retry-error=${retryMessage.slice(0, 200)}`;
+      // The sibling is installed and linked, and a second import that
+      // looked again still failed. A new process imports everything fresh,
+      // so the plugin asks for a restart, and the report says why it got here.
+      const unresolved = unresolvedSpecifier(err, message);
+      if (unresolved && isLinkedPeerModule(pluginDir, unresolved)) {
+        loaderLog.info(`${directory} loads after a restart: ${message} [${detail}]`);
+        reportCrash(err, { kind: "plugin", plugin: directory, detail });
+        return { ...base, plugin: placeholder, needsRestart: true };
+      }
+    }
+    // An update that links against modules this process imported at the old
+    // commit, which Bun keeps until a restart. The row already asks for one,
+    // and the next launch imports everything fresh; a plugin that is really
+    // broken fails there, and is reported there. A host export the running
+    // Gloomberb lacks is a different failure and stays one.
+    if (restart.needsRestart && !findMissingHostExport(message) && STALE_LINK_FAILURE.test(message)) {
+      loaderLog.info(`${directory} loads after a restart: ${message}`);
+      return { ...base, plugin: placeholder, needsRestart: true };
+    }
+    loaderLog.error(`Failed to load plugin from ${pluginDir}: ${err}${detail ? ` [${detail}]` : ""}`);
+    reportCrash(err, { kind: "plugin", plugin: directory, ...(detail ? { detail } : {}) });
+    if (findMissingHostExport(message)) missingHostExportFailures.add(directory);
+    return {
+      ...base,
+      ...restart,
+      plugin: placeholder,
+      error: explainPluginLoadError(message),
+    };
+  };
+
+  let module: unknown;
   try {
-    const specifier = options.fresh ? `${entryFile}?reload=${Date.now()}` : entryFile;
-    const plugin = pluginFromModule(await import(specifier));
+    const retried = options.fresh ? undefined : retriedEntries.get(pluginDir);
+    module = await import(retried ?? (options.fresh ? `${entryFile}?reload=${Date.now()}` : entryFile));
+  } catch (err) {
+    // A sibling plugin it imports that did not resolve: not linked yet, or
+    // its link was being rewritten. Bun keeps that failure for the process,
+    // so the plugin is linked and imported again in a way that looks again.
+    const peer = failedPeer(pluginDir, unresolvedSpecifier(err, errorMessage(err)));
+    if (!peer) return failed(err);
+    const retry = await retryPeerImport(pluginDir, entryFile, peer);
+    if ("error" in retry) return failed(err, retry);
+    // Loaded, but the failure it recovered from is still a bug somewhere:
+    // the report carries the link state that explains it.
+    loaderLog.info(`Loaded ${directory} on a second import: ${errorMessage(err)} [${retry.detail}]`);
+    if (!reportedRecoveries.has(pluginDir)) {
+      reportedRecoveries.add(pluginDir);
+      reportCrash(err, { kind: "plugin", plugin: directory, detail: retry.detail });
+    }
+    module = retry.module;
+  }
+
+  try {
+    const plugin = pluginFromModule(module);
     if (!plugin) {
       const error = "Plugin did not export a valid GloomPlugin (missing id or name).";
       reportCrash(error, { kind: "plugin", plugin: directory });
@@ -325,33 +518,7 @@ export async function loadExternalPlugin(
     loaderLog.info(`Loaded external plugin: ${plugin.id} v${plugin.version ?? "0.0.0"}`);
     return { ...base, ...restart, plugin };
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    // A sibling plugin it imports that is linked now but was not when this
-    // process first resolved it. Bun keeps that failure until a restart, which
-    // is all the plugin needs: not a crash.
-    const unresolved = unresolvedSpecifier(err, message);
-    if (unresolved && isLinkedPeerModule(pluginDir, unresolved)) {
-      loaderLog.info(`${directory} loads after a restart: ${message}`);
-      return { ...base, plugin: placeholder, needsRestart: true };
-    }
-    // An update that links against modules this process imported at the old
-    // commit, which Bun keeps until a restart. The row already asks for one,
-    // and the next launch imports everything fresh; a plugin that is really
-    // broken fails there, and is reported there. A host export the running
-    // Gloomberb lacks is a different failure and stays one.
-    if (restart.needsRestart && !findMissingHostExport(message) && STALE_LINK_FAILURE.test(message)) {
-      loaderLog.info(`${directory} loads after a restart: ${message}`);
-      return { ...base, plugin: placeholder, needsRestart: true };
-    }
-    loaderLog.error(`Failed to load plugin from ${pluginDir}: ${err}`);
-    reportCrash(err, { kind: "plugin", plugin: directory });
-    if (findMissingHostExport(message)) missingHostExportFailures.add(directory);
-    return {
-      ...base,
-      ...restart,
-      plugin: placeholder,
-      error: explainPluginLoadError(message),
-    };
+    return failed(err);
   }
 }
 
@@ -382,6 +549,7 @@ export async function listPluginDirectories(pluginsDir: string = PLUGINS_DIR): P
 }
 
 export async function loadExternalPlugins(target: PluginTarget = "cli"): Promise<LoadedExternalPlugin[]> {
+  recordLaunchedVersion();
   const results: LoadedExternalPlugin[] = [];
   for (const pluginDir of await listPluginDirectories()) {
     const loaded = await loadExternalPlugin(pluginDir, target);
@@ -399,7 +567,7 @@ function isSymlink(path: string): boolean {
   }
 }
 
-/** A linked plugin (`gloomberb plugin link`) is a symlink, which `readdir` does not report as a directory. */
+/** A linked plugin (`gloom plugin link`) is a symlink, which `readdir` does not report as a directory. */
 export function isDirectoryOrLink(entry: { isDirectory(): boolean; isSymbolicLink(): boolean }, path: string): boolean {
   if (entry.isDirectory()) return true;
   if (!entry.isSymbolicLink()) return false;

package/src/plugins/manager-node.ts

@@ -6,7 +6,7 @@ import type { PluginTarget } from "../types/plugin";
 /**
  * The plugin manager for a process that can run git and bun: the terminal,
  * and the desktop's Bun side on behalf of its view. Wraps the installer so
- * the marketplace and `gloomberb install` do exactly the same thing, and
+ * the marketplace and `gloom install` do exactly the same thing, and
  * turns its failures into results the pane can show next to the row.
  */
 
@@ -41,7 +41,7 @@ export function createNodePluginManager(target: PluginTarget, hooks: NodePluginM
   }
 
   return {
-    // Through the registry, like `gloomberb install`: a plugin that builds on
+    // Through the registry, like `gloom install`: a plugin that builds on
     // another brings it along instead of failing to load without it.
     install: (repo, pin) => attempt(async () => (await installer()).installListedPlugin(repo, { quiet: true, ...(pin ? { pin } : {}) })),
     update: (directory, pin) => attempt(async () => (await installer()).updatePlugin(directory, { quiet: true, pin })),

package/src/plugins/marketplace/deactivation.ts

@@ -0,0 +1,22 @@
+import type { PluginRegistry } from "../registry";
+import { logFailure } from "../../utils/log-failure";
+
+// unregister removes the registration even when cleanup throws. A later
+// no-op cannot confirm that its background work stopped. Keep that uncertainty
+// with this runtime, across pane remounts, until a fresh registry starts.
+const failedStops = new WeakMap<PluginRegistry, Set<string>>();
+
+export function deactivatePluginForRemoval(registry: PluginRegistry, pluginId: string): void {
+  const failure = "Plugin could not be stopped. Restart before removing it.";
+  if (failedStops.get(registry)?.has(pluginId)) throw new Error(failure);
+  if (!registry.allPlugins.has(pluginId)) return;
+  try {
+    registry.unregister(pluginId);
+  } catch (error) {
+    const failed = failedStops.get(registry) ?? new Set<string>();
+    failed.add(pluginId);
+    failedStops.set(registry, failed);
+    logFailure("plugin-removal", "Plugin cleanup before removal failed")(error);
+    throw new Error(failure);
+  }
+}

package/src/plugins/marketplace/model.ts

@@ -72,7 +72,7 @@ export interface InstalledPlugin {
   path?: string;
   /** Checked-out commit, when the install is a git checkout. */
   commit?: string;
-  /** A dev link (`gloomberb plugin link`) rather than a clone. */
+  /** A dev link (`gloom plugin link`) rather than a clone. */
   linked?: boolean;
   /** Set when the plugin is installed but cannot run on this renderer. */
   unsupportedTarget?: PluginTarget;
@@ -180,7 +180,7 @@ function isFeatured(id: string, bundled: boolean, feedFeatured: boolean | undefi
  * plugin can be installed but inert because this renderer cannot run it. The
  * merge keeps all three visible rather than showing whichever list is handy.
  */
-/** The folder `gloomberb install owner/repo` creates, which is the repository name. */
+/** The folder `gloom install owner/repo` creates, which is the repository name. */
 function repoDirectory(repo: string | undefined): string | null {
   const name = repo?.split("/")[1]?.replace(/\.git$/, "");
   return name ? name.toLowerCase() : null;

package/src/plugins/marketplace/packs.ts

@@ -37,7 +37,7 @@ export const STARTER_PACKS: readonly StarterPack[] = [
   {
     id: "everything",
     name: "Everything",
-    tagline: "Every research plugin on, as Gloomberb ships.",
+    tagline: "Every research plugin on, as Gloom ships.",
     plugins: PACK_PLUGIN_IDS,
   },
   {

package/src/plugins/ownership.ts

@@ -110,7 +110,7 @@ export function builtinPluginGroupMembers(pluginId: string): readonly string[] |
 /**
  * `disabledPlugins` after switching plugins on or off in one go, or null when
  * nothing changes. A retired group id switches every member, the way
- * `gloomberb plugin enable|disable` does. Changes apply in order, so a later
+ * `gloom plugin enable|disable` does. Changes apply in order, so a later
  * one wins for a plugin two groups share.
  */
 export function applyPluginToggles(

package/src/plugins/peer-retry.ts

@@ -0,0 +1,155 @@
+import { readdirSync, readFileSync, type Dirent } from "fs";
+import { dirname, extname, isAbsolute, join, relative } from "path";
+
+/**
+ * A second import of a plugin whose first one failed on a sibling plugin it
+ * imports (IBKR Gateway imports Interactive Brokers), that really looks again.
+ *
+ * Bun keeps both halves of that failure for the rest of the process. Its
+ * resolver remembers each folder it read, so `node_modules` stays without the
+ * sibling after the link is made. And the module that failed stays failed
+ * under its path, so importing the entry again, even under a fresh query,
+ * reaches the same error through the entry's own `./plugin` import. Until
+ * now only a restart cleared it, which is why the gateway failed on a launch
+ * and worked on the next one.
+ *
+ * The retry undoes both. It makes Bun read the plugin's folders again (a
+ * lookup that misses in a folder Bun had read drops that folder from its
+ * cache), and it imports every file of the plugin under a new module key, so
+ * nothing from the failed attempt is reused. Imports that leave the plugin,
+ * the sibling's files included, resolve to the same modules as always, so the
+ * plugin shares the sibling's state as on a normal load.
+ */
+
+/** The query that gives a plugin's files their new module keys. */
+const RETRY_PARAM = "gloom-plugin-retry";
+const RETRY_QUERY = new RegExp(`[?&]${RETRY_PARAM}=(\\d+)(?:&|$)`);
+const SOURCE_LOADERS: Readonly<Record<string, "ts" | "tsx" | "js" | "jsx">> = {
+  ".ts": "ts",
+  ".mts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".jsx": "jsx",
+};
+/** A file name that is never there: looking it up is what clears a folder. */
+const MISSING_FILE = "./.gloom-resolver-refresh";
+const SKIPPED_FOLDERS = new Set(["node_modules", ".git", "dist"]);
+
+/**
+ * `text` without the retry query Bun puts in the paths of a retried import's
+ * errors, so the retry's error reads like the first import's.
+ */
+export function withoutRetryQuery(text: string): string {
+  return text.replace(new RegExp(`[?&]${RETRY_PARAM}=\\d+`, "g"), "");
+}
+
+/** The plugin folder each retry imports from, by retry number. */
+const retryRoots = new Map<number, string>();
+let retries = 0;
+let installed = false;
+
+function isInside(root: string, path: string): boolean {
+  const inside = relative(root, path);
+  return !!inside && !inside.startsWith("..") && !isAbsolute(inside);
+}
+
+/** The plugin's own folders, without dependencies or build output. */
+function sourceFolders(dir: string, out: string[] = [], depth = 0): string[] {
+  out.push(dir);
+  if (depth > 8) return out;
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    // Intentional ignore: a folder that cannot be listed has nothing Bun could have cached.
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory() && !SKIPPED_FOLDERS.has(entry.name)) sourceFolders(join(dir, entry.name), out, depth + 1);
+  }
+  return out;
+}
+
+/**
+ * Makes Bun read the plugin's folders and its links to `peers` from disk
+ * again. Bun drops a folder from its resolver cache when a lookup in it
+ * misses, so this looks up a file that is not there in each one. The
+ * bundler shares the cache, which is why the desktop's compile of the same
+ * plugin failed in the same session too.
+ */
+export function refreshResolverFolders(pluginDir: string, peers: readonly string[]): void {
+  const modules = join(pluginDir, "node_modules");
+  const folders = [...sourceFolders(pluginDir), modules];
+  for (const peer of peers) {
+    if (peer.startsWith("@")) folders.push(join(modules, peer.split("/")[0]!));
+    folders.push(join(modules, peer));
+  }
+  for (const folder of folders) {
+    try {
+      Bun.resolveSync(MISSING_FILE, folder);
+    } catch {
+      // Intentional ignore: the miss is what drops the folder from the cache.
+    }
+  }
+}
+
+/**
+ * The plugin's file at `path` (with the retry query), its relative imports
+ * of other source files in the plugin given the same query, so they load
+ * under new keys as well. Imports that leave the plugin keep their keys.
+ */
+function rekeyedSource(path: string): { contents: string; loader: "ts" | "tsx" | "js" | "jsx" } {
+  const match = RETRY_QUERY.exec(path);
+  const file = match ? path.slice(0, match.index) : path;
+  const loader = SOURCE_LOADERS[extname(file).toLowerCase()] ?? "js";
+  let contents = readFileSync(file, "utf8");
+  const root = match ? retryRoots.get(Number(match[1])) : undefined;
+  if (!match || !root) return { contents, loader };
+  const retry = Number(match[1]);
+  const specifiers = new Set(
+    new Bun.Transpiler({ loader }).scanImports(contents)
+      .map((entry) => entry.path)
+      .filter((specifier) => (specifier.startsWith("./") || specifier.startsWith("../")) && !specifier.includes("?")),
+  );
+  for (const specifier of specifiers) {
+    let target: string;
+    try {
+      target = Bun.resolveSync(specifier, dirname(file));
+    } catch {
+      // Intentional ignore: left as written, the import fails the way it would have.
+      continue;
+    }
+    if (!isInside(root, target) || !SOURCE_LOADERS[extname(target).toLowerCase()]) continue;
+    const rekeyed = `${specifier}?${RETRY_PARAM}=${retry}`;
+    for (const quote of ["\"", "'", "`"]) {
+      contents = contents.split(`${quote}${specifier}${quote}`).join(`${quote}${rekeyed}${quote}`);
+    }
+  }
+  return { contents, loader };
+}
+
+function installRekeyingLoader(): boolean {
+  if (installed) return true;
+  if (typeof Bun === "undefined" || typeof Bun.plugin !== "function") return false;
+  Bun.plugin({
+    name: "gloomberb-plugin-retry",
+    setup(build) {
+      build.onLoad({ filter: RETRY_QUERY }, (args) => rekeyedSource(args.path));
+    },
+  });
+  installed = true;
+  return true;
+}
+
+/**
+ * The specifier that imports `entryFile` and the rest of its plugin under
+ * new module keys, or null when this process cannot register the loader that
+ * does it. The same specifier imports the same modules again.
+ */
+export function rekeyedEntry(entryFile: string, pluginDir: string): string | null {
+  if (!installRekeyingLoader()) return null;
+  retries += 1;
+  retryRoots.set(retries, pluginDir);
+  return `${entryFile}?${RETRY_PARAM}=${retries}`;
+}

package/src/plugins/registry/contributions.ts

@@ -11,6 +11,7 @@ import type {
   TickerAction,
   TickerResearchTabDef,
 } from "../../types/plugin";
+import { withFunctionShortcutArgument } from "../shortcut-argument";
 
 export interface ContextMenuProviderEntry {
   pluginId: string;
@@ -89,7 +90,8 @@ export class RegistryContributions {
   }
 
   registerPaneTemplate(pluginId: string, template: PaneTemplateDef, replace = false): () => void {
-    return this.paneTemplatesMap.register(pluginId, template.id, template, replace);
+    const registered = withFunctionShortcutArgument(template, this.panesMap.get(template.paneId));
+    return this.paneTemplatesMap.register(pluginId, template.id, registered, replace);
   }
 
   registerCommand(pluginId: string, command: CommandDef): void {

package/src/plugins/registry/index.ts

@@ -69,6 +69,7 @@ import {
   bindPluginContextNamespaces,
   createPluginPaneSettingsState,
   createPluginResumeState,
+  resumeStateKey,
   type NamespacedPluginContext,
 } from "./plugin-state";
 import { createPluginSetupCommand, isPluginConfigured } from "./setup-command";
@@ -405,18 +406,18 @@ export class PluginRegistry implements PluginRuntimeAccess {
 
   getResumeState<T = unknown>(pluginId: string, key: string, schemaVersion?: number): T | null {
     const stateId = this.stateNamespace(pluginId);
-    return this.persistence.pluginState.get<T>(stateId, `resume:${key}`, schemaVersion)?.value ?? null;
+    return this.persistence.pluginState.get<T>(stateId, resumeStateKey(key), schemaVersion)?.value ?? null;
   }
 
   setResumeState(pluginId: string, key: string, value: unknown, schemaVersion?: number): void {
     const stateId = this.stateNamespace(pluginId);
-    this.persistence.pluginState.set(stateId, `resume:${key}`, value, schemaVersion);
+    this.persistence.pluginState.set(stateId, resumeStateKey(key), value, schemaVersion);
     this.resumeStateListeners.emit(stateId, key);
   }
 
   deleteResumeState(pluginId: string, key: string): void {
     const stateId = this.stateNamespace(pluginId);
-    this.persistence.pluginState.delete(stateId, `resume:${key}`);
+    this.persistence.pluginState.delete(stateId, resumeStateKey(key));
     this.resumeStateListeners.emit(stateId, key);
   }
 

package/src/plugins/registry/plugin-state.ts

@@ -4,6 +4,9 @@ import type { LayoutConfig } from "../../types/config";
 import type { GloomPluginContext, PluginPaneSettingsState, PluginResumeState } from "../../types/plugin";
 import { deletePluginPaneStateValue, setPluginPaneStateValue } from "../../layout/pane-state";
 
+/** Where a plugin's resume state (`ctx.resume`) is kept in the device's plugin state store. */
+export const resumeStateKey = (key: string) => `resume:${key}`;
+
 export class RegistryResumeStateListeners {
   private listeners = new Map<string, Set<() => void>>();
 

package/src/plugins/seed-notice.ts

@@ -0,0 +1,20 @@
+import type { PluginSeedNotice } from "./extracted-plugins";
+
+/**
+ * What the launch's plugin seed could not install, said once the app is up.
+ * The seed runs before the app renders (in the terminal's process, or the
+ * desktop's Bun process, which hands it to its main window), so it leaves the
+ * notice here and the app takes it.
+ */
+let pending: PluginSeedNotice | null = null;
+
+export function setPluginSeedNotice(notice: PluginSeedNotice | null): void {
+  pending = notice;
+}
+
+/** The notice, once: a second call returns null. */
+export function takePluginSeedNotice(): PluginSeedNotice | null {
+  const notice = pending;
+  pending = null;
+  return notice;
+}