@openparachute/hub 0.7.7-rc.12 → 0.7.7-rc.13

package/src/__tests__/hub-settings.test.ts

@@ -12,30 +12,38 @@ import { join } from "node:path";
 import { hubDbPath, openHubDb } from "../hub-db.ts";
 import {
   DEFAULT_MODULE_INSTALL_CHANNEL,
+  DEFAULT_ROOT_MODE,
   DEFAULT_ROOT_REDIRECT,
   FIRST_CLIENT_AUTO_APPROVE_WINDOW_MS,
   MODULE_INSTALL_CHANNELS,
+  PARACHUTE_HUB_ROOT_MODE_ENV,
   PARACHUTE_HUB_ROOT_REDIRECT_ENV,
   PARACHUTE_INSTALL_CHANNEL_ENV,
   PARACHUTE_MODULE_CHANNEL_ENV,
+  ROOT_MODES,
   SETUP_EXPOSE_MODES,
   consumeFirstClientAutoApproveWindow,
   deleteSetting,
   getHubOrigin,
   getModuleInstallChannel,
+  getRootMode,
   getRootRedirect,
   getSetting,
   isFirstClientAutoApproveWindowOpen,
   isModuleInstallChannel,
   isNotesRedirectDisabled,
+  isRootMode,
   isSafeRedirectPath,
   isSetupExposeMode,
   openFirstClientAutoApproveWindow,
+  resolveRootMode,
+  resolveRootModeDetailed,
   resolveRootRedirect,
   resolveRootRedirectDetailed,
   setHubOrigin,
   setModuleInstallChannel,
   setNotesRedirectDisabled,
+  setRootMode,
   setRootRedirect,
   setSetting,
 } from "../hub-settings.ts";
@@ -363,9 +371,9 @@ describe("hub-settings — module install channel bootstrap", () => {
       // First read with env=rc — env wins, returns "rc". DB stays empty
       // (no auto-write to DB when env is set, per the design that
       // preserves the SPA's last-write as the env-unset fallback).
-      expect(
-        getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } }),
-      ).toBe("rc");
+      expect(getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } })).toBe(
+        "rc",
+      );
       // Second read with env=latest — env wins again (would have returned
       // "rc" under the old DB-after-first-seed behavior).
       expect(
@@ -386,9 +394,9 @@ describe("hub-settings — module install channel bootstrap", () => {
     const db = openHubDb(hubDbPath(dir));
     try {
       // PARACHUTE_INSTALL_CHANNEL — canonical name (matches install.ts).
-      expect(
-        getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } }),
-      ).toBe("rc");
+      expect(getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } })).toBe(
+        "rc",
+      );
       // PARACHUTE_MODULE_CHANNEL — legacy alias, still recognized.
       const db2 = openHubDb(join(mkdtempSync(join(tmpdir(), "phub-hsalt-")), "hub.db"));
       try {
@@ -801,3 +809,99 @@ describe("hub-settings — root_redirect storage + resolution", () => {
     expect(resolveRootRedirect(null, { env })).toBe("/surface/from-env");
   });
 });
+
+describe("hub-settings — root_mode storage + resolution", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "hub-settings-root-mode-"));
+  });
+  afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+  const noEnv: NodeJS.ProcessEnv = {};
+  const silent = () => {};
+
+  test("isRootMode + ROOT_MODES", () => {
+    expect(ROOT_MODES).toEqual(["redirect", "serve-app"]);
+    expect(isRootMode("redirect")).toBe(true);
+    expect(isRootMode("serve-app")).toBe(true);
+    expect(isRootMode("serveapp")).toBe(false);
+    expect(isRootMode(42)).toBe(false);
+  });
+
+  test("getRootMode round-trips serve-app via setRootMode", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      expect(getRootMode(db)).toBeNull();
+      setRootMode(db, "serve-app");
+      expect(getRootMode(db)).toBe("serve-app");
+    } finally {
+      db.close();
+    }
+  });
+
+  test("setRootMode(null) and setRootMode('redirect') both clear the row (default = absence)", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      setRootMode(db, "serve-app");
+      setRootMode(db, null);
+      expect(getRootMode(db)).toBeNull();
+      setRootMode(db, "serve-app");
+      setRootMode(db, "redirect"); // the default is stored as absence
+      expect(getRootMode(db)).toBeNull();
+      expect(getSetting(db, "root_mode")).toBeUndefined();
+    } finally {
+      db.close();
+    }
+  });
+
+  test("resolves to the redirect default when neither DB nor env is set", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      expect(resolveRootMode(db, { env: noEnv })).toBe(DEFAULT_ROOT_MODE);
+      expect(resolveRootModeDetailed(db, { env: noEnv })).toEqual({
+        value: "redirect",
+        source: "default",
+      });
+    } finally {
+      db.close();
+    }
+  });
+
+  test("env override applies when no DB row; DB overrides env (DB is tier-1)", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      const env = { [PARACHUTE_HUB_ROOT_MODE_ENV]: "serve-app" };
+      expect(resolveRootModeDetailed(db, { env })).toEqual({ value: "serve-app", source: "env" });
+      setRootMode(db, "serve-app");
+      // A DB "serve-app" over an env "redirect" resolves to db.
+      expect(
+        resolveRootModeDetailed(db, { env: { [PARACHUTE_HUB_ROOT_MODE_ENV]: "redirect" } }),
+      ).toEqual({ value: "serve-app", source: "db" });
+    } finally {
+      db.close();
+    }
+  });
+
+  test("an invalid DB row / env value is ignored → falls back to the redirect default", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      setSetting(db, "root_mode", "bogus"); // hand-edited row bypassing write validation
+      expect(resolveRootMode(db, { env: noEnv, warn: silent })).toBe("redirect");
+      expect(getRootMode(db)).toBeNull(); // getRootMode also guards the invalid value
+      const env = { [PARACHUTE_HUB_ROOT_MODE_ENV]: "nonsense" };
+      expect(resolveRootModeDetailed(db, { env, warn: silent })).toEqual({
+        value: "redirect",
+        source: "default",
+      });
+    } finally {
+      db.close();
+    }
+  });
+
+  test("a null db (no state) resolves from env / default only", () => {
+    expect(resolveRootMode(null, { env: noEnv })).toBe("redirect");
+    expect(resolveRootMode(null, { env: { [PARACHUTE_HUB_ROOT_MODE_ENV]: "serve-app" } })).toBe(
+      "serve-app",
+    );
+  });
+});

package/src/__tests__/install.test.ts

@@ -5,8 +5,11 @@ import { join } from "node:path";
 import { defaultStartLifecycleOpts, install } from "../commands/install.ts";
 import { hubDbPath, openHubDb } from "../hub-db.ts";
 import {
+  PARACHUTE_HUB_ROOT_MODE_ENV,
   PARACHUTE_HUB_ROOT_REDIRECT_ENV,
+  getRootMode,
   getRootRedirect,
+  setRootMode,
   setRootRedirect,
 } from "../hub-settings.ts";
 import { findService, upsertService } from "../services-manifest.ts";
@@ -2417,31 +2420,38 @@ describe("hub#573 — install auto-start converges on supervised detection", ()
   });
 });
 
-// hub-parity P5 (2026-07-11): `parachute install app` defaults the hub's
-// bare `/` redirect to the app's front door — SET-IF-UNSET ONLY. Every test
-// here injects `rootRedirectDb` (a hub.db opened in the same disposable
-// tempdir `makeTempPath()` already isolates) so no real
-// `~/.parachute/hub.db` is ever touched — never drive this against the
+// `parachute install app` defaults the hub's origin root to SERVE the app
+// (root_mode = serve-app) on first install — SET-IF-UNSET ONLY, and only when
+// the root behavior is entirely pristine default (no mode row/env AND no
+// redirect row/env). Supersedes the prior hub-parity P5 behavior (which wrote
+// root_redirect = /app/). Every test here injects `rootRedirectDb` (a hub.db
+// opened in the same disposable tempdir `makeTempPath()` already isolates) so no
+// real `~/.parachute/hub.db` is ever touched — never drive this against the
 // operator's live install.
-describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
-  // The write gates on `resolveRootRedirectDetailed(db).source === "default"`,
-  // which consults `PARACHUTE_HUB_ROOT_REDIRECT`. Neutralize any ambient value
-  // (Aaron's box, CI) so the default-tier tests are deterministic; the
-  // env-set test below manages its own value inside its own body.
-  let savedEnv: string | undefined;
+describe("app-only serve-app set-if-unset default", () => {
+  // The write gates on the RESOLVED mode + redirect being `default` (no DB row,
+  // no env). Neutralize any ambient PARACHUTE_HUB_ROOT_MODE / _REDIRECT (Aaron's
+  // box, CI) so the default-tier tests are deterministic; the env-set tests
+  // below manage their own values inside their own bodies.
+  let savedRedirectEnv: string | undefined;
+  let savedModeEnv: string | undefined;
   beforeEach(() => {
-    savedEnv = process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+    savedRedirectEnv = process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+    savedModeEnv = process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
     delete process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+    delete process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
   });
   afterEach(() => {
-    if (savedEnv === undefined) {
-      delete process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
-    } else {
-      process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV] = savedEnv;
+    for (const [name, saved] of [
+      [PARACHUTE_HUB_ROOT_REDIRECT_ENV, savedRedirectEnv],
+      [PARACHUTE_HUB_ROOT_MODE_ENV, savedModeEnv],
+    ] as const) {
+      if (saved === undefined) delete process.env[name];
+      else process.env[name] = saved;
     }
   });
 
-  test("fresh install (no prior root_redirect) sets it to /app/", async () => {
+  test("fresh install (pristine root) flips root_mode to serve-app", async () => {
     const { path, configDir, cleanup } = makeTempPath();
     try {
       const db = openHubDb(hubDbPath(configDir));
@@ -2458,8 +2468,10 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
           log: (l) => logs.push(l),
         });
         expect(code).toBe(0);
-        expect(getRootRedirect(db)).toBe("/app/");
-        expect(logs.join("\n")).toMatch(/front page.*now opens the app at \/app\//);
+        expect(getRootMode(db)).toBe("serve-app");
+        // The redirect row is NOT written — serve-app takes over `/` directly.
+        expect(getRootRedirect(db)).toBeNull();
+        expect(logs.join("\n")).toMatch(/front page.*now serves the Parachute app/);
       } finally {
         db.close();
       }
@@ -2468,7 +2480,7 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
     }
   });
 
-  test("a pre-set root_redirect is left alone — never clobbered", async () => {
+  test("a pre-set root_redirect is left alone — mode NOT flipped", async () => {
     const { path, configDir, cleanup } = makeTempPath();
     try {
       const db = openHubDb(hubDbPath(configDir));
@@ -2486,13 +2498,43 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
           log: (l) => logs.push(l),
         });
         expect(code).toBe(0);
-        // The operator's prior choice survives byte-for-byte.
+        // The operator's prior choice survives byte-for-byte; no mode flip.
         expect(getRootRedirect(db)).toBe("/surface/reading-room");
-        // The set-if-unset write's OWN log line (distinct from the static
-        // postInstallFooter boilerplate, which always prints "now opens the
-        // app too, unless you've already..." regardless of whether the write
-        // fired) must NOT appear — the write itself was skipped.
-        expect(logs.join("\n")).not.toMatch(/now opens the app at \/app\//);
+        expect(getRootMode(db)).toBeNull();
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("an existing install with the old /app/ redirect keeps redirecting (back-compat)", async () => {
+    // A hub that ran the PRIOR app-install code has root_redirect = /app/ in its
+    // DB (source = db → not default). Re-running `install app` must NOT flip it
+    // to serve-app — it keeps 302-ing to /app/, exactly as before. This is the
+    // "existing installs unchanged" guarantee.
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        setRootRedirect(db, "/app/");
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        expect(getRootMode(db)).toBeNull();
+        expect(getRootRedirect(db)).toBe("/app/");
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
       } finally {
         db.close();
       }
@@ -2501,7 +2543,7 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
     }
   });
 
-  test("installing a different module never touches root_redirect", async () => {
+  test("installing a different module never touches the root settings", async () => {
     const { path, configDir, cleanup } = makeTempPath();
     try {
       const db = openHubDb(hubDbPath(configDir));
@@ -2518,6 +2560,7 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
         });
         expect(code).toBe(0);
         expect(getRootRedirect(db)).toBeNull();
+        expect(getRootMode(db)).toBeNull();
       } finally {
         db.close();
       }
@@ -2526,13 +2569,12 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
     }
   });
 
-  test("an ENV-configured redirect (no DB row) is left alone — never clobbered (N1)", async () => {
+  test("an ENV-configured redirect (no DB row) is left alone — no mode flip (N1)", async () => {
     // Container deploys pin the landing page via PARACHUTE_HUB_ROOT_REDIRECT,
-    // not a DB row. Gating on `getRootRedirect(db) === null` (DB only) would
-    // miss this and write `/app/`, which — since the DB row wins over env on
-    // read — silently overrides their configured landing. The fix gates on
-    // `resolveRootRedirectDetailed(db).source === "default"`, which sees the
-    // env tier. So: env set → no DB row written.
+    // not a DB row. Flipping to serve-app would silently override their
+    // configured landing (serve-app wins over redirect at `/`). The gate reads
+    // the RESOLVED redirect source; with the env set that's `env`, not
+    // `default`, so we leave it alone.
     const { path, configDir, cleanup } = makeTempPath();
     const prevEnv = process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
     try {
@@ -2551,9 +2593,10 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
           log: (l) => logs.push(l),
         });
         expect(code).toBe(0);
-        // No DB row written — the env-configured landing survives.
+        // No mode row written — the env-configured landing survives.
+        expect(getRootMode(db)).toBeNull();
         expect(getRootRedirect(db)).toBeNull();
-        expect(logs.join("\n")).not.toMatch(/now opens the app at \/app\//);
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
       } finally {
         db.close();
       }
@@ -2567,6 +2610,43 @@ describe("app-only root-redirect set-if-unset (hub-parity P5)", () => {
     }
   });
 
+  test("an ENV-configured mode (no DB row) is left alone — no clobber", async () => {
+    // PARACHUTE_HUB_ROOT_MODE=redirect on a container that deliberately wants
+    // the redirect front door. The gate sees the resolved mode source as `env`,
+    // not `default`, so it does NOT write a serve-app row.
+    const { path, configDir, cleanup } = makeTempPath();
+    const prevEnv = process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
+    try {
+      process.env[PARACHUTE_HUB_ROOT_MODE_ENV] = "redirect";
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        expect(getRootMode(db)).toBeNull();
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      if (prevEnv === undefined) {
+        delete process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
+      } else {
+        process.env[PARACHUTE_HUB_ROOT_MODE_ENV] = prevEnv;
+      }
+      cleanup();
+    }
+  });
+
   test("production gate: without rootRedirectDb + a tempdir manifestPath, the write is skipped (not attempted)", async () => {
     // Mirrors the existing `guidanceProbeAllowed` discriminant elsewhere in
     // install.ts: a test with a tempdir manifestPath and no explicit opt-in

package/src/__tests__/root-serve.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Tests for `src/root-serve.ts` — serving the Parachute app AT the origin root
+ * (`root_mode = serve-app`).
+ *
+ * Covers `serveAppAtRoot` (the static file-or-SPA-shell decision, Accept-gated,
+ * reserved-prefix-guarded, traversal-guarded) and `makeAppDistResolver` (success
+ * memoization + failure NON-caching for dynamic recovery).
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { makeAppDistResolver, serveAppAtRoot } from "../root-serve.ts";
+
+let dist: string;
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "phub-root-serve-"));
+  dist = join(root, "dist");
+  mkdirSync(join(dist, "assets"), { recursive: true });
+  writeFileSync(join(dist, "index.html"), "<!doctype html><title>App</title>");
+  writeFileSync(join(dist, "assets", "index-abc.js"), "console.log('app')");
+  writeFileSync(join(dist, "manifest.webmanifest"), '{"name":"Parachute"}');
+  writeFileSync(join(dist, "sw.js"), "self.addEventListener('install',()=>{})");
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+function get(pathname: string, accept?: string): Request {
+  return new Request(`http://localhost${pathname}`, {
+    method: "GET",
+    headers: accept ? { accept } : {},
+  });
+}
+
+describe("serveAppAtRoot", () => {
+  test("serves index.html at `/`", async () => {
+    const res = serveAppAtRoot(dist, get("/", "text/html"), "/");
+    expect(res).not.toBeNull();
+    expect(res?.headers.get("content-type")).toContain("text/html");
+    expect(await res?.text()).toContain("<title>App</title>");
+  });
+
+  test("serves an existing asset with an inferred content-type", async () => {
+    const res = serveAppAtRoot(dist, get("/assets/index-abc.js", "*/*"), "/assets/index-abc.js");
+    expect(res).not.toBeNull();
+    expect(res?.headers.get("content-type") ?? "").toMatch(/javascript/);
+    expect(await res?.text()).toContain("console.log");
+  });
+
+  test("serves the PWA manifest with the application/manifest+json override", () => {
+    const res = serveAppAtRoot(dist, get("/manifest.webmanifest", "*/*"), "/manifest.webmanifest");
+    expect(res).not.toBeNull();
+    expect(res?.headers.get("content-type")).toBe("application/manifest+json");
+  });
+
+  test("serves the service worker as a real file (not the SPA shell)", async () => {
+    const res = serveAppAtRoot(dist, get("/sw.js", "*/*"), "/sw.js");
+    expect(res).not.toBeNull();
+    expect(await res?.text()).toContain("addEventListener");
+  });
+
+  test("SPA fallback: an unclaimed HTML deep link gets index.html", async () => {
+    const res = serveAppAtRoot(dist, get("/some/app/route", "text/html"), "/some/app/route");
+    expect(res).not.toBeNull();
+    expect(await res?.text()).toContain("<title>App</title>");
+  });
+
+  test("non-HTML unclaimed request → null (branded 404 tail)", () => {
+    expect(serveAppAtRoot(dist, get("/nope.json", "application/json"), "/nope.json")).toBeNull();
+    // A missing asset fetched with Accept: */* is not an HTML navigation → null.
+    expect(serveAppAtRoot(dist, get("/assets/missing.js", "*/*"), "/assets/missing.js")).toBeNull();
+  });
+
+  test("non-GET → null (a non-GET unclaimed path keeps its default)", () => {
+    const post = new Request("http://localhost/", {
+      method: "POST",
+      headers: { accept: "text/html" },
+    });
+    expect(serveAppAtRoot(dist, post, "/")).toBeNull();
+  });
+
+  test("reserved hub/protocol prefixes keep the branded 404 even for HTML nav", () => {
+    for (const p of ["/api/bogus", "/oauth/typo", "/.well-known/nope"]) {
+      expect(serveAppAtRoot(dist, get(p, "text/html"), p)).toBeNull();
+    }
+  });
+
+  test("path traversal cannot escape dist", () => {
+    // A crafted encoded traversal joins outside dist → falls through (null).
+    const p = "/assets/..%2f..%2f..%2fetc%2fpasswd";
+    expect(serveAppAtRoot(dist, get(p, "*/*"), p)).toBeNull();
+  });
+
+  test("a resolved dist whose index.html vanished → null (no broken shell)", () => {
+    rmSync(join(dist, "index.html"));
+    expect(serveAppAtRoot(dist, get("/", "text/html"), "/")).toBeNull();
+  });
+
+  test("malformed percent-encoding → null (no URIError thrown → branded 404, not 500)", () => {
+    // decodeURIComponent throws URIError on a bad escape; the guard must swallow
+    // it and fall through so the dispatch never 500s on a garbage asset URL.
+    for (const p of ["/assets/%ZZ", "/foo%", "/%E0%A4%A", "/bar%2"]) {
+      expect(() => serveAppAtRoot(dist, get(p, "*/*"), p)).not.toThrow();
+      expect(serveAppAtRoot(dist, get(p, "*/*"), p)).toBeNull();
+    }
+    // Even an HTML navigation with bad encoding falls through (redirect-mode
+    // parity) rather than shelling.
+    expect(serveAppAtRoot(dist, get("/foo%", "text/html"), "/foo%")).toBeNull();
+  });
+});
+
+describe("makeAppDistResolver", () => {
+  test("returns the resolved dist and memoizes a success", () => {
+    let calls = 0;
+    const resolve = makeAppDistResolver(() => {
+      calls++;
+      return dist;
+    });
+    expect(resolve()).toBe(dist);
+    expect(resolve()).toBe(dist);
+    expect(calls).toBe(1); // success cached — only resolved once
+  });
+
+  test("does NOT cache a failure — recovers once the app is installed", () => {
+    let installed = false;
+    const resolve = makeAppDistResolver(() => {
+      if (!installed) throw new Error("not installed");
+      return dist;
+    });
+    expect(resolve()).toBeNull(); // not installed yet
+    expect(resolve()).toBeNull(); // still probing, still null
+    installed = true;
+    expect(resolve()).toBe(dist); // picked up without a restart
+  });
+});