gloomberb 0.13.3 → 0.14.0

package/src/plugins/host-link.ts

@@ -1,6 +1,9 @@
 import { existsSync, lstatSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from "fs";
 import { dirname, join, resolve } from "path";
 
+import { installPluginHostResolver } from "./host-resolver";
+import { isPluginPackageName, pluginDirectoryNames } from "./plugin-names";
+
 /**
  * External plugins live in `~/.gloomberb/plugins/<name>/`, outside any
  * `node_modules` chain that could reach the running Gloomberb install. Left
@@ -16,6 +19,10 @@ import { dirname, join, resolve } from "path";
  * Links are rebuilt after every install and update, because `bun install`
  * prunes entries it does not know about, and repaired at load time so a plugin
  * copied in by hand still works.
+ *
+ * A compiled or packaged host has no package directory to link to. It serves
+ * the same modules from inside the process instead (see host-resolver.ts),
+ * and this reports that as `provider: "process"` rather than as an error.
  */
 
 const LINKED_PACKAGES = ["gloomberb", "react", "react-dom"] as const;
@@ -76,16 +83,18 @@ function linkPeerPlugins(pluginDir: string, pluginsDir: string): string[] {
   let peers: string[] = [];
   try {
     const pkg = JSON.parse(require("fs").readFileSync(join(pluginDir, "package.json"), "utf-8"));
-    peers = Object.keys(pkg.peerDependencies ?? {}).filter((name) => name.startsWith("gloomberb-"));
+    peers = Object.keys(pkg.peerDependencies ?? {}).filter(isPluginPackageName);
   } catch {
     return linked;
   }
 
   for (const peer of peers) {
-    // Installed directories are named after the repository, which is the package
-    // name for every plugin in the registry.
-    const target = join(pluginsDir, peer);
-    if (!existsSync(target)) continue;
+    // Declared by package name, installed under a directory named for the repo:
+    // the two disagree while the plugin is mid-rename.
+    const target = pluginDirectoryNames(peer)
+      .map((name) => join(pluginsDir, name))
+      .find((candidate) => existsSync(candidate));
+    if (!target) continue;
     const linkPath = join(pluginDir, "node_modules", peer);
     if (alreadyLinked(linkPath, target)) {
       linked.push(peer);
@@ -108,9 +117,23 @@ function linkPeerPlugins(pluginDir: string, pluginsDir: string): string[] {
 export interface HostLinkResult {
   linked: string[];
   skipped: string[];
+  /**
+   * How the plugin reaches `gloomberb/*` and `react`: symlinks into a package
+   * directory, or the host process answering the imports itself.
+   */
+  provider: "symlink" | "process";
   error?: string;
 }
 
+export interface HostLinkOptions {
+  /**
+   * Registers the in-process resolver when there is no package root. Tests
+   * stub this: the real one changes how `react` resolves for the whole
+   * process, which is the point in a packaged host and a hazard in a test run.
+   */
+  installResolver?: () => boolean;
+}
+
 /**
  * Points `<pluginDir>/node_modules/{gloomberb,react,react-dom}` at the running
  * install. Safe to call repeatedly.
@@ -119,13 +142,29 @@ export function linkHostPackages(
   pluginDir: string,
   hostRoot = findHostPackageRoot(),
   pluginsDir = dirname(pluginDir),
+  options: HostLinkOptions = {},
 ): HostLinkResult {
-  if (!hostRoot) return { linked: [], skipped: [...LINKED_PACKAGES], error: "Could not locate the Gloomberb install." };
-
-  const modulesDir = join(pluginDir, "node_modules");
   const linked: string[] = [];
   const skipped: string[] = [];
 
+  if (!hostRoot) {
+    // Peers still need their links: a sibling plugin is a directory the
+    // resolver knows nothing about.
+    const peers = linkPeerPlugins(pluginDir, pluginsDir);
+    const installResolver = options.installResolver ?? installPluginHostResolver;
+    if (installResolver()) {
+      return { linked: peers, skipped: [...LINKED_PACKAGES], provider: "process" };
+    }
+    return {
+      linked: peers,
+      skipped: [...LINKED_PACKAGES],
+      provider: "process",
+      error: "Could not locate the Gloomberb install.",
+    };
+  }
+
+  const modulesDir = join(pluginDir, "node_modules");
+
   for (const pkg of LINKED_PACKAGES) {
     const target = linkTarget(hostRoot, pkg);
     if (!target) {
@@ -148,11 +187,11 @@ export function linkHostPackages(
       linked.push(pkg);
     } catch (err) {
       skipped.push(pkg);
-      if (pkg === "gloomberb") return { linked, skipped, error: String(err) };
+      if (pkg === "gloomberb") return { linked, skipped, provider: "symlink", error: String(err) };
     }
   }
 
   linked.push(...linkPeerPlugins(pluginDir, pluginsDir));
 
-  return { linked, skipped };
+  return { linked, skipped, provider: "symlink" };
 }

package/src/plugins/host-module-imports.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { bundleExternalPlugin, hostExportNames } from "./bundle";
+import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS } from "./host-contract";
+import { importAllPluginHostModules, importPluginHostModule } from "./host-module-imports";
+
+describe("plugin host module imports", () => {
+  test("has a host module for every shared specifier", async () => {
+    const registry = await importAllPluginHostModules();
+
+    expect(Object.keys(registry).sort()).toEqual([...SHARED_SPECIFIERS].sort());
+    for (const specifier of SHARED_SPECIFIERS) {
+      expect(await importPluginHostModule(specifier)).toBeTruthy();
+    }
+  });
+
+  test("discovers export names through host-local imports", async () => {
+    const names = await hostExportNames("gloomberb/ui");
+
+    expect(names).toContain("Box");
+    expect(names).toContain("Text");
+  });
+
+  test("discovers and bundles shared modules from a Bun compiled executable", () => {
+    const entry = join(import.meta.dir, `.compiled-host-module-entry-${process.pid}.ts`);
+    const outfile = join(import.meta.dir, `.compiled-host-module-entry-${process.pid}.exe`);
+    writeFileSync(entry, `
+      import { mkdtempSync, rmSync, writeFileSync } from "fs";
+      import { tmpdir } from "os";
+      import { join } from "path";
+      import { bundleExternalPlugin, hostExportNames } from "./bundle";
+      import { importAllPluginHostModules } from "./host-module-imports";
+
+      const pluginDir = mkdtempSync(join(tmpdir(), "gloom-compiled-plugin-"));
+      try {
+        writeFileSync(join(pluginDir, "package.json"), JSON.stringify({ name: "compiled-plugin", main: "index.tsx" }));
+        writeFileSync(join(pluginDir, "index.tsx"), [
+          "import { Box } from \\\"gloomberb/ui\\\";",
+          "export default { id: \\\"compiled-plugin\\\", name: \\\"Compiled plugin\\\", version: \\\"1.0.0\\\", Box };",
+          "",
+        ].join("\\n"));
+        const hostModules = await importAllPluginHostModules();
+        const names = await hostExportNames("gloomberb/ui");
+        const result = await bundleExternalPlugin(pluginDir, join(pluginDir, "out"));
+        const code = await Bun.file(result.outputPath).text();
+        console.log(JSON.stringify({
+          importMetaDir: import.meta.dir,
+          hostModuleCount: Object.keys(hostModules).length,
+          names,
+          shared: result.shared,
+          hasHostRegistry: code.includes(${JSON.stringify(PLUGIN_HOST_GLOBAL)}),
+        }));
+      } finally {
+        rmSync(pluginDir, { recursive: true, force: true });
+      }
+    `);
+
+    try {
+      const build = Bun.spawnSync(
+        [process.execPath, "build", "--compile", entry, "--outfile", outfile],
+        { cwd: join(import.meta.dir, "../.."), stdout: "pipe", stderr: "pipe" },
+      );
+      if (build.exitCode !== 0) {
+        throw new Error(`compiled test fixture failed to build:\n${build.stdout.toString()}\n${build.stderr.toString()}`);
+      }
+
+      const run = Bun.spawnSync([outfile], { stdout: "pipe", stderr: "pipe" });
+      if (run.exitCode !== 0) {
+        throw new Error(`compiled test fixture failed to run:\n${run.stdout.toString()}\n${run.stderr.toString()}`);
+      }
+      const result = JSON.parse(run.stdout.toString()) as {
+        importMetaDir: string;
+        hostModuleCount: number;
+        names: string[];
+        shared: string[];
+        hasHostRegistry: boolean;
+      };
+
+      // Bun's embedded filesystem is `B:/~BUN/root` on Windows and `/$bunfs/root`
+      // elsewhere; either one proves the code ran from inside the executable.
+      expect(result.importMetaDir.replaceAll("\\", "/")).toMatch(/\/(~BUN|\$bunfs)\/root$/i);
+      expect(result.hostModuleCount).toBe(SHARED_SPECIFIERS.length);
+      expect(result.names).toContain("Box");
+      expect(result.shared).toEqual(["gloomberb/ui"]);
+      expect(result.hasHostRegistry).toBe(true);
+    } finally {
+      rmSync(entry, { force: true });
+      rmSync(outfile, { force: true });
+    }
+  });
+});

package/src/plugins/host-module-imports.ts

@@ -0,0 +1,73 @@
+import { SHARED_SPECIFIERS, type SharedSpecifier } from "./host-contract";
+
+type HostModuleImporter = () => Promise<object>;
+
+/**
+ * The host's canonical implementation for every public shared-module
+ * specifier. Resolve Gloomberb's own modules relative to this file: a
+ * Bun-compiled host has no filesystem package root from which
+ * `import("gloomberb/ui")` can be resolved.
+ */
+const HOST_MODULE_IMPORTERS = {
+  "react": () => import("react"),
+  "react/jsx-runtime": () => import("react/jsx-runtime"),
+  "react/jsx-dev-runtime": () => import("react/jsx-dev-runtime"),
+  "gloomberb/types/plugin": () => import("../types/plugin"),
+  "gloomberb/types/persistence": () => import("../types/persistence"),
+  "gloomberb/types/broker": () => import("../types/broker"),
+  "gloomberb/types/config": () => import("../types/config"),
+  "gloomberb/types/data-provider": () => import("../types/data-provider"),
+  "gloomberb/types/financials": () => import("../types/financials"),
+  "gloomberb/types/instrument": () => import("../types/instrument"),
+  "gloomberb/types/ticker": () => import("../types/ticker"),
+  "gloomberb/types/trading": () => import("../types/trading"),
+  "gloomberb/ui": () => import("../ui"),
+  "gloomberb/components": () => import("../components"),
+  "gloomberb/theme": () => import("../theme/colors"),
+  "gloomberb/capabilities": () => import("../capabilities"),
+  "gloomberb/utils": () => import("../public/utils"),
+  "gloomberb/react": () => import("../public/react"),
+  "gloomberb/broker": () => import("../public/broker"),
+  "gloomberb/dialog": () => import("../ui/dialog"),
+  "gloomberb/market-data": () => import("../public/market-data"),
+  "gloomberb/time-series": () => import("../public/time-series"),
+  "gloomberb/layout": () => import("../public/layout"),
+  "gloomberb/quotes": () => import("../public/quotes"),
+  "gloomberb/tickers": () => import("../public/tickers"),
+  "gloomberb/i18n": () => import("../public/i18n"),
+} satisfies Record<SharedSpecifier, HostModuleImporter>;
+
+/**
+ * Public exports the host serves to plugins running in its own Bun process,
+ * but never to a browser renderer: `gloomberb/remote` reads the data
+ * directory, so a renderer bundle that imports it is meant to fail to compile.
+ */
+export const NATIVE_HOST_MODULE_IMPORTERS: Readonly<Record<string, HostModuleImporter>> = {
+  "gloomberb/remote": () => import("../public/remote"),
+};
+
+/**
+ * Every specifier the Bun process can hand a plugin directly, shared and
+ * native alike. This is what the runtime resolver publishes when the host has
+ * no package directory for a symlink to point at.
+ */
+export const PLUGIN_HOST_RESOLVER_IMPORTERS: Readonly<Record<string, HostModuleImporter>> = {
+  ...HOST_MODULE_IMPORTERS,
+  ...NATIVE_HOST_MODULE_IMPORTERS,
+};
+
+/** Import one host module without depending on bare Gloomberb package resolution. */
+export async function importPluginHostModule(specifier: string): Promise<object> {
+  if (!(SHARED_SPECIFIERS as readonly string[]).includes(specifier)) {
+    throw new Error(`Unknown plugin host module: ${specifier}`);
+  }
+  return HOST_MODULE_IMPORTERS[specifier as SharedSpecifier]();
+}
+
+/** Import the complete registry from the same map used by the bundler. */
+export async function importAllPluginHostModules(): Promise<Readonly<Record<SharedSpecifier, object>>> {
+  const entries = await Promise.all(
+    SHARED_SPECIFIERS.map(async (specifier) => [specifier, await importPluginHostModule(specifier)] as const),
+  );
+  return Object.fromEntries(entries) as Record<SharedSpecifier, object>;
+}

package/src/plugins/host-modules.ts

@@ -1,4 +1,5 @@
 import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS } from "./host-contract";
+import { importAllPluginHostModules } from "./host-module-imports";
 
 /**
  * Publishes the host's shared modules for compiled plugin bundles to read.
@@ -13,57 +14,7 @@ export async function installPluginHostModules(): Promise<void> {
   const globals = globalThis as Record<string, unknown>;
   if (globals[PLUGIN_HOST_GLOBAL]) return;
 
-  const [
-    react,
-    jsxRuntime,
-    typesPlugin,
-    typesPersistence,
-    ui,
-    components,
-    theme,
-    capabilities,
-    utils,
-    pluginReact,
-    broker,
-    dialog,
-    marketData,
-    timeSeries,
-  ] = await Promise.all([
-    import("react"),
-    import("react/jsx-runtime"),
-    // Type-only modules still need an entry: a plugin may import a runtime
-    // value from them, and a missing key throws a clearer error than undefined.
-    import("../types/plugin"),
-    import("../types/persistence"),
-    import("../ui"),
-    import("../components"),
-    import("../theme/colors"),
-    import("../capabilities"),
-    import("../public/utils"),
-    import("../public/react"),
-    import("../public/broker"),
-    import("../ui/dialog"),
-    import("../public/market-data"),
-    import("../public/time-series"),
-  ]);
-
-  const registry: Record<string, unknown> = {
-    "react": react,
-    "react/jsx-runtime": jsxRuntime,
-    "react/jsx-dev-runtime": jsxRuntime,
-    "gloomberb/types/plugin": typesPlugin,
-    "gloomberb/types/persistence": typesPersistence,
-    "gloomberb/ui": ui,
-    "gloomberb/components": components,
-    "gloomberb/theme": theme,
-    "gloomberb/capabilities": capabilities,
-    "gloomberb/utils": utils,
-    "gloomberb/react": pluginReact,
-    "gloomberb/broker": broker,
-    "gloomberb/dialog": dialog,
-    "gloomberb/market-data": marketData,
-    "gloomberb/time-series": timeSeries,
-  };
+  const registry = await importAllPluginHostModules();
 
   for (const specifier of SHARED_SPECIFIERS) {
     if (!registry[specifier]) throw new Error(`Plugin host registry is missing "${specifier}"`);

package/src/plugins/host-resolver.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import { rmSync, writeFileSync } from "fs";
+import { join } from "path";
+
+import { PLUGIN_HOST_RESOLVER_IMPORTERS } from "./host-module-imports";
+import { SHARED_SPECIFIERS } from "./host-contract";
+import { pluginHostResolverSpecifiers } from "./host-resolver";
+
+/**
+ * The resolver is what lets the compiled terminal binary and the packaged
+ * desktop app load an external plugin at all. Neither has a Gloomberb
+ * package on disk for host-link.ts to symlink, so without it every plugin's
+ * `gloomberb/*` import failed and the panes that moved out of this
+ * repository disappeared on upgrade.
+ *
+ * It cannot be exercised in this process: registering it rewires how `react`
+ * resolves for every test file that follows. So the test compiles a small
+ * host into an executable, which has no package root, and loads a plugin
+ * from a temporary directory through the real loader.
+ */
+describe("plugin host resolver", () => {
+  test("covers every shared specifier and the native-only exports", () => {
+    const specifiers = pluginHostResolverSpecifiers();
+
+    for (const specifier of SHARED_SPECIFIERS) expect(specifiers).toContain(specifier);
+    expect(specifiers).toContain("gloomberb/remote");
+    expect(Object.keys(PLUGIN_HOST_RESOLVER_IMPORTERS).sort()).toEqual([...specifiers].sort());
+  });
+
+  test("covers every runtime export of the package that a plugin can import", async () => {
+    // A new entry in package.json `exports` that the resolver does not know
+    // about resolves from a source install and fails from a packaged one.
+    // Only the app entry and the test harness are deliberately left out.
+    const pkg = await Bun.file(join(import.meta.dir, "../../package.json")).json() as { exports: Record<string, string> };
+    const exported = Object.keys(pkg.exports)
+      .filter((key) => key !== "." && key !== "./package.json" && key !== "./test-support")
+      .map((key) => `gloomberb/${key.slice(2)}`)
+      .sort();
+
+    const served = pluginHostResolverSpecifiers().filter((specifier) => specifier.startsWith("gloomberb/")).sort();
+
+    expect(served).toEqual(exported);
+  });
+
+  test("loads an external plugin from a Bun compiled executable with no package root", () => {
+    const entry = join(import.meta.dir, `.compiled-host-resolver-entry-${process.pid}.ts`);
+    const outfile = join(import.meta.dir, `.compiled-host-resolver-entry-${process.pid}.exe`);
+    writeFileSync(entry, `
+      import { findHostPackageRoot } from "./host-link";
+      import { isPluginHostResolverInstalled } from "./host-resolver";
+      import { smokePluginHostLoad } from "./host-smoke";
+
+      const hostRoot = findHostPackageRoot();
+      await smokePluginHostLoad();
+      console.log(JSON.stringify({
+        importMetaDir: import.meta.dir,
+        hostRoot,
+        resolverInstalled: isPluginHostResolverInstalled(),
+      }));
+    `);
+
+    try {
+      // The same flags as scripts/build.ts. `--production` is what makes the
+      // host's React a production build, whose jsx-dev-runtime has no
+      // `jsxDEV`; without `--compile-autoload-package-json` the executable
+      // cannot resolve a plugin dependency that publishes an `exports` map.
+      const build = Bun.spawnSync(
+        [
+          process.execPath, "build", "--compile", "--production", "--compile-autoload-package-json",
+          entry, "--outfile", outfile,
+        ],
+        { cwd: join(import.meta.dir, "../.."), stdout: "pipe", stderr: "pipe" },
+      );
+      if (build.exitCode !== 0) {
+        throw new Error(`compiled test fixture failed to build:\n${build.stdout.toString()}\n${build.stderr.toString()}`);
+      }
+
+      const run = Bun.spawnSync([outfile], { stdout: "pipe", stderr: "pipe" });
+      if (run.exitCode !== 0) {
+        throw new Error(`compiled test fixture failed to run:\n${run.stdout.toString()}\n${run.stderr.toString()}`);
+      }
+      const result = JSON.parse(run.stdout.toString()) as {
+        importMetaDir: string;
+        hostRoot: string | null;
+        resolverInstalled: boolean;
+      };
+
+      expect(result.importMetaDir.replaceAll("\\", "/")).toMatch(/\/(~BUN|\$bunfs)\/root$/i);
+      expect(result.hostRoot).toBeNull();
+      expect(result.resolverInstalled).toBe(true);
+    } finally {
+      rmSync(entry, { force: true });
+      rmSync(outfile, { force: true });
+    }
+  });
+});

package/src/plugins/host-resolver.ts

@@ -0,0 +1,102 @@
+import { PLUGIN_HOST_RESOLVER_IMPORTERS } from "./host-module-imports";
+
+/**
+ * Serves `gloomberb/*` and `react` to external plugins from inside the
+ * process when there is no Gloomberb package on disk to symlink.
+ *
+ * The terminal imports a plugin straight from `~/.gloomberb/plugins`, and the
+ * plugin's `import { Box } from "gloomberb/ui"` has to resolve to the running
+ * host. A source install (npm, a checkout) has a package directory, and
+ * host-link.ts points `node_modules/gloomberb` at it. The compiled terminal
+ * binary from the install script and the packaged desktop app have no such
+ * directory: their `import.meta.dir` is Bun's embedded filesystem or a
+ * bundle folder with no package.json above it. There, every external plugin
+ * failed to load with "Cannot find module 'gloomberb/utils'", which turned
+ * the extraction of built-in panes into losing them.
+ *
+ * A Bun runtime plugin answers those specifiers with the host's own modules,
+ * already loaded in this process, so a plugin gets the same React instance
+ * and the same stateful `gloomberb/*` modules the app uses. It is installed
+ * once and only when the symlink route is unavailable: with a package root,
+ * the host's own `react` import resolves by name at runtime, and answering
+ * it from a virtual module that itself imports `react` would never settle.
+ */
+
+const RESOLVER_NAME = "gloomberb-plugin-host";
+const JSX_DEV_RUNTIME = "react/jsx-dev-runtime";
+const JSX_RUNTIME = "react/jsx-runtime";
+
+let installed = false;
+
+type JsxFactory = (type: unknown, props: unknown, key?: unknown) => unknown;
+
+/**
+ * A packaged host is built with `--production`, so its React is the
+ * production build, whose `react/jsx-dev-runtime` exports `jsxDEV` as
+ * undefined. A plugin's `.tsx` is transpiled when it is imported, and unless
+ * the user's shell says NODE_ENV=production that transform calls `jsxDEV`.
+ * The first render then throws "jsxDEV is not a function". Answer it with the
+ * production `jsx`, which builds the same elements without the dev checks.
+ */
+async function jsxDevRuntimeExports(): Promise<Record<string, unknown>> {
+  const dev = { ...(await PLUGIN_HOST_RESOLVER_IMPORTERS[JSX_DEV_RUNTIME]!()) } as Record<string, unknown>;
+  if (typeof dev.jsxDEV === "function") return dev;
+  const prod = (await PLUGIN_HOST_RESOLVER_IMPORTERS[JSX_RUNTIME]!()) as { jsx: JsxFactory };
+  return { ...dev, jsxDEV: (type: unknown, props: unknown, key?: unknown) => prod.jsx(type, props, key) };
+}
+
+/** True when this process can register runtime resolvers. */
+function hasBunRuntimePlugins(): boolean {
+  return typeof Bun !== "undefined" && typeof Bun.plugin === "function";
+}
+
+/**
+ * Registers the resolver. Returns true when plugins in this process resolve
+ * host modules through it, false when the caller should fall back to symlinks.
+ */
+export function installPluginHostResolver(): boolean {
+  if (installed) return true;
+  if (!hasBunRuntimePlugins()) return false;
+
+  const resolving = new Set<string>();
+
+  Bun.plugin({
+    name: RESOLVER_NAME,
+    setup(build) {
+      for (const [specifier, importer] of Object.entries(PLUGIN_HOST_RESOLVER_IMPORTERS)) {
+        build.module(specifier, async () => {
+          // A host that still resolves this name from the filesystem would
+          // re-enter here and hang; fail loudly instead.
+          if (resolving.has(specifier)) {
+            throw new Error(`The plugin host resolver was asked for "${specifier}" while loading it.`);
+          }
+          resolving.add(specifier);
+          try {
+            // Spread the namespace: `loader: "object"` reads own enumerable
+            // properties, and a module namespace's live bindings are exactly
+            // that. Values keep their identity, so `React` is the host's.
+            const exports = specifier === JSX_DEV_RUNTIME
+              ? await jsxDevRuntimeExports()
+              : { ...(await importer()) };
+            return { exports, loader: "object" };
+          } finally {
+            resolving.delete(specifier);
+          }
+        });
+      }
+    },
+  });
+
+  installed = true;
+  return true;
+}
+
+/** Whether the resolver is serving host modules in this process. */
+export function isPluginHostResolverInstalled(): boolean {
+  return installed;
+}
+
+/** The specifiers the resolver answers, for diagnostics. */
+export function pluginHostResolverSpecifiers(): string[] {
+  return Object.keys(PLUGIN_HOST_RESOLVER_IMPORTERS);
+}

package/src/plugins/host-smoke.ts

@@ -0,0 +1,103 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { loadExternalPlugin } from "./loader";
+
+/**
+ * The plugin the smoke writes: one import from each kind of module a real
+ * plugin uses. `react` and the JSX runtime have to be the host's own
+ * instance, `gloomberb/ui` is shared state, `gloomberb/types/config` is a
+ * value from a module that used to be bundled from the package directory,
+ * and `smoke-dep` stands in for a dependency `bun install` put in the
+ * plugin's own `node_modules`.
+ */
+const SMOKE_PLUGIN_SOURCE = `
+import React from "react";
+import { Box, Text } from "gloomberb/ui";
+import { formatNumber } from "gloomberb/utils";
+import { TICKER_RESEARCH_PANE_ID } from "gloomberb/types/config";
+import { platform } from "smoke-dep";
+
+function Probe() {
+  return <Box><Text>{formatNumber(1)}</Text></Box>;
+}
+
+export default {
+  id: "smoke-plugin-host",
+  name: "Plugin host smoke",
+  version: "0.0.0",
+  probe() {
+    const element = <Probe />;
+    const tree = Probe();
+    return {
+      react: typeof React.createElement === "function" && typeof React.useState === "function",
+      jsx: typeof element.type === "function" && tree != null && typeof tree === "object" && "type" in tree,
+      paneId: TICKER_RESEARCH_PANE_ID,
+      platform,
+    };
+  },
+};
+`;
+
+/**
+ * A dependency whose `exports` map picks the entry by condition, as
+ * `youtubei.js`, `meriyah`, and `@earendil-works/pi-ai` do. A standalone
+ * executable that does not read package.json at runtime cannot resolve it
+ * at all, and one that resolves it with the wrong conditions lands on the
+ * browser build.
+ */
+const SMOKE_DEPENDENCY_PACKAGE = {
+  name: "smoke-dep",
+  version: "1.0.0",
+  type: "module",
+  exports: {
+    ".": {
+      node: { import: "./node.js", default: "./node.js" },
+      browser: "./browser.js",
+      default: "./browser.js",
+    },
+  },
+};
+
+interface SmokeProbe {
+  react: boolean;
+  jsx: boolean;
+  paneId: string;
+  platform: string;
+}
+
+/**
+ * Writes the plugin to a temporary directory, loads it through the real
+ * loader, and throws with the loader's own error when it does not come up.
+ */
+export async function smokePluginHostLoad(): Promise<void> {
+  const pluginDir = mkdtempSync(join(tmpdir(), "gloomberb-plugin-host-smoke-"));
+  try {
+    writeFileSync(join(pluginDir, "package.json"), JSON.stringify({ name: "smoke-plugin-host", main: "index.tsx" }));
+    writeFileSync(join(pluginDir, "index.tsx"), SMOKE_PLUGIN_SOURCE);
+
+    const dependencyDir = join(pluginDir, "node_modules", "smoke-dep");
+    mkdirSync(dependencyDir, { recursive: true });
+    writeFileSync(join(dependencyDir, "package.json"), JSON.stringify(SMOKE_DEPENDENCY_PACKAGE));
+    writeFileSync(join(dependencyDir, "node.js"), "export const platform = \"node\";\n");
+    writeFileSync(join(dependencyDir, "browser.js"), "export const platform = \"browser\";\n");
+
+    const loaded = await loadExternalPlugin(pluginDir, "tui");
+    if (!loaded) throw new Error("The smoke plugin directory was not recognised as a plugin.");
+    if (loaded.error) throw new Error(`The smoke plugin failed to load: ${loaded.error}`);
+
+    const probe = (loaded.plugin as unknown as { probe?: () => SmokeProbe }).probe?.();
+    if (!probe) throw new Error("The smoke plugin loaded without its probe export.");
+    if (!probe.react) throw new Error("The smoke plugin did not receive a working React.");
+    if (!probe.jsx) throw new Error("The smoke plugin's JSX did not compile against the host runtime.");
+    if (probe.paneId !== "ticker-research") {
+      throw new Error(`The smoke plugin read "${probe.paneId}" from gloomberb/types/config.`);
+    }
+    if (probe.platform !== "node") {
+      throw new Error(`The smoke plugin's dependency resolved to its "${probe.platform}" entry instead of "node".`);
+    }
+  } finally {
+    rmSync(pluginDir, { recursive: true, force: true });
+  }
+}