@multiplatform.one/cli 6.7.0 → 7.1.0

package/src/commands/adoptApp.spec.ts

@@ -0,0 +1,208 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import spawn from "nano-spawn";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { adoptApp } from "./adoptApp";
+import { cliVersion, readProvenance, writeProvenance } from "./initApp";
+
+const readJson = (path: string) => JSON.parse(readFileSync(path, "utf-8"));
+
+async function gitOut(cwd: string, args: string[]): Promise<string> {
+  const result = await spawn("git", args, { cwd });
+  return result.stdout.trim();
+}
+
+/** git repo fixture with an identity, the given files, and one commit. */
+async function makeRepo(dir: string, files: Record<string, string>): Promise<void> {
+  mkdirSync(dir, { recursive: true });
+  for (const [file, content] of Object.entries(files)) {
+    mkdirSync(dirname(join(dir, file)), { recursive: true });
+    writeFileSync(join(dir, file), content);
+  }
+  await spawn("git", ["init", "--quiet"], { cwd: dir });
+  await spawn("git", ["config", "user.email", "spec@example.com"], { cwd: dir });
+  await spawn("git", ["config", "user.name", "Spec"], { cwd: dir });
+  await spawn("git", ["add", "-A"], { cwd: dir });
+  await spawn("git", ["commit", "--quiet", "-m", "chore: fixture"], { cwd: dir });
+}
+
+describe("adoptApp", () => {
+  let sandbox: string;
+  let previousCwd: string;
+  let fixtureCount = 0;
+
+  const fixtureDir = () => join(sandbox, `fixture-${fixtureCount++}`);
+
+  beforeAll(() => {
+    sandbox = mkdtempSync(join(tmpdir(), "mpo-adopt-spec-"));
+    previousCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    process.chdir(previousCwd);
+  });
+
+  afterAll(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+  });
+
+  it("writes adopted provenance, seeds .updateignore, and commits both", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, {
+      "package.json": JSON.stringify({ name: "@easel/repo", private: true }),
+      "apps/repo/webext/manifest.ts": "// hand-copied\n",
+    });
+    process.chdir(dir);
+    // Intentionally unsorted — provenance must sort.
+    await adoptApp({ pieces: ["webext", "gnome"], yes: true });
+
+    const provenance = readJson(join(dir, ".mpo.json"));
+    expect(provenance).toEqual({
+      template: "none",
+      cliVersion: cliVersion(),
+      name: "repo", // scope stripped from package.json name
+      mpoVersion: `^${cliVersion()}`,
+      pieces: ["gnome", "webext"],
+      reconciled: false,
+    });
+    expect(readProvenance(dir)?.reconciled).toBe(false);
+
+    const updateignore = readFileSync(join(dir, ".updateignore"), "utf-8");
+    expect(updateignore).toMatch(/^#/u);
+    expect(updateignore).toContain("mpo update");
+
+    // Adoption changed NO project files and left the tree clean (committed).
+    expect(readFileSync(join(dir, "apps/repo/webext/manifest.ts"), "utf-8")).toBe(
+      "// hand-copied\n",
+    );
+    expect(await gitOut(dir, ["status", "--porcelain"])).toBe("");
+    expect(await gitOut(dir, ["log", "-1", "--format=%s"])).toContain("mpo adopt");
+  });
+
+  it("honors --name and preserves an existing .updateignore", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, {
+      "package.json": JSON.stringify({ name: "@easel/repo" }),
+      ".updateignore": "docs/\n",
+    });
+    process.chdir(dir);
+    await adoptApp({ pieces: ["webext"], name: "easel", yes: true });
+    expect(readProvenance(dir)?.name).toBe("easel");
+    expect(readFileSync(join(dir, ".updateignore"), "utf-8")).toBe("docs/\n");
+  });
+
+  it("refuses outside a git repository", async () => {
+    const dir = join(sandbox, "not-a-repo");
+    mkdirSync(dir, { recursive: true });
+    process.chdir(dir);
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(
+      /inside a git repository/u,
+    );
+  });
+
+  it("refuses a repo without commits", async () => {
+    const dir = fixtureDir();
+    mkdirSync(dir, { recursive: true });
+    await spawn("git", ["init", "--quiet"], { cwd: dir });
+    process.chdir(dir);
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(
+      /at least one commit/u,
+    );
+  });
+
+  it("refuses a dirty working tree (unstaged and staged)", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, { "package.json": JSON.stringify({ name: "dirty-demo" }) });
+    process.chdir(dir);
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "dirty-demo", changed: true }));
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(
+      /unstaged changes present/u,
+    );
+    await spawn("git", ["add", "-A"], { cwd: dir });
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(
+      /staged changes present/u,
+    );
+  });
+
+  it("refuses to adopt nothing", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, { "package.json": JSON.stringify({ name: "no-pieces" }) });
+    process.chdir(dir);
+    await expect(adoptApp({ yes: true })).rejects.toThrow(/at least one piece/u);
+    await expect(adoptApp({ pieces: [], yes: true })).rejects.toThrow(/at least one piece/u);
+  });
+
+  it("rejects unknown pieces", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, { "package.json": JSON.stringify({ name: "bogus" }) });
+    process.chdir(dir);
+    await expect(adoptApp({ pieces: ["solana" as never], yes: true })).rejects.toThrow(
+      /Unknown piece "solana"/u,
+    );
+  });
+
+  it("refuses when provenance already exists", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, {
+      "package.json": JSON.stringify({ name: "scaffolded" }),
+      ".mpo.json": JSON.stringify({
+        template: "universal",
+        cliVersion: "6.5.0",
+        name: "scaffolded",
+      }),
+    });
+    process.chdir(dir);
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(
+      /already has scaffold provenance/u,
+    );
+  });
+
+  it("refuses inside the multiplatform.one monorepo (or a fork)", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, {
+      "package.json": JSON.stringify({ name: "root" }),
+      "public/cli/package.json": JSON.stringify({ name: "@multiplatform.one/cli" }),
+    });
+    process.chdir(dir);
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(
+      /cannot run inside the multiplatform\.one monorepo/u,
+    );
+  });
+
+  it("requires a usable project name", async () => {
+    const dir = fixtureDir();
+    await makeRepo(dir, { "package.json": JSON.stringify({ name: "Bad_Name" }) });
+    process.chdir(dir);
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(/--name/u);
+    const noPkg = fixtureDir();
+    await makeRepo(noPkg, { "README.md": "no package.json here\n" });
+    process.chdir(noPkg);
+    await expect(adoptApp({ pieces: ["webext"], yes: true })).rejects.toThrow(/--name/u);
+  });
+
+  it("round-trips the reconciled flag through provenance", () => {
+    const dir = fixtureDir();
+    mkdirSync(dir, { recursive: true });
+    writeProvenance(dir, {
+      template: "none",
+      cliVersion: "6.6.0",
+      name: "flagged",
+      mpoVersion: "^6.6.0",
+      pieces: ["webext"],
+      reconciled: false,
+    });
+    expect(readJson(join(dir, ".mpo.json")).reconciled).toBe(false);
+    expect(readProvenance(dir)?.reconciled).toBe(false);
+    // Cleared flag serializes to NO field (scaffolded provenance stays lean).
+    writeProvenance(dir, {
+      template: "none",
+      cliVersion: "6.6.0",
+      name: "flagged",
+      mpoVersion: "^6.6.0",
+      pieces: ["webext"],
+    });
+    expect("reconciled" in readJson(join(dir, ".mpo.json"))).toBe(false);
+    expect(readProvenance(dir)?.reconciled).toBeUndefined();
+  });
+});

package/src/commands/adoptApp.ts

@@ -0,0 +1,185 @@
+/**
+ * `mpo adopt` — bring an EXISTING, never-scaffolded project under `mpo
+ * update` management. Projects like this hand-copied one or more delivery
+ * targets (webext, gnome, …) from the mpo templates and consume
+ * @multiplatform.one/* from npm, but have no .mpo.json provenance, so
+ * `mpo update` refuses to run.
+ *
+ * Adoption writes provenance ONLY (template "none" + the chosen pieces +
+ * the current CLI version) and seeds .updateignore — it never rewrites a
+ * project file. The FIRST `mpo update` afterwards reconciles the piece
+ * files against the piece templates from an empty merge base, so real
+ * diffs (and conflicts) against hand-copied files are expected there;
+ * every later update is an ordinary three-way merge.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import inquirer from "inquirer";
+import spawn from "nano-spawn";
+import {
+  INIT_APP_PIECES,
+  PROVENANCE_FILE,
+  availablePieces,
+  cliVersion,
+  normalizePieces,
+  packageJsonName,
+  pieceDescription,
+  validateName,
+  writeProvenance,
+  type InitAppPiece,
+} from "./initApp";
+
+export interface AdoptAppOptions {
+  /** Pieces the project hand-adopted (at least one is required). */
+  pieces?: InitAppPiece[];
+  /** Project name (default: package.json name, scope stripped). */
+  name?: string;
+  /** Non-interactive: never prompt (pieces must come from flags). */
+  yes?: boolean;
+}
+
+const UPDATEIGNORE_FILE = ".updateignore";
+const UPDATEIGNORE_SEED = `# .updateignore — \`mpo update\` never rewrites paths listed here.
+# One git pathspec per line; matching paths stay pinned to YOUR version
+# during template updates. Lines starting with "#" are comments.
+`;
+
+async function git(projectDir: string, args: string[]) {
+  return spawn("git", args, { cwd: projectDir });
+}
+
+/**
+ * The multiplatform.one monorepo (and its forks) is the home of the
+ * templates themselves — adopting it into consumer-project update
+ * management would be circular. It is identified by the CLI package
+ * living at public/cli.
+ */
+function isMpoMonorepo(projectDir: string): boolean {
+  try {
+    const pkg = JSON.parse(readFileSync(join(projectDir, "public/cli/package.json"), "utf-8")) as {
+      name?: string;
+    };
+    return pkg.name === "@multiplatform.one/cli";
+  } catch {
+    return false;
+  }
+}
+
+async function resolveAdoptPieces(options: AdoptAppOptions): Promise<InitAppPiece[]> {
+  if (options.pieces?.length) return normalizePieces(options.pieces, "none");
+  if (!options.yes && process.stdout.isTTY) {
+    const result = await inquirer.prompt([
+      {
+        message: "Which pieces did this project adopt? (space to toggle, enter to confirm)",
+        name: "pieces",
+        type: "checkbox",
+        choices: availablePieces("none").map((piece) => ({
+          name: `${piece} — ${pieceDescription(piece)}`,
+          value: piece,
+          checked: false,
+        })),
+        validate: (selection: unknown[]) =>
+          selection.length > 0 || "Select at least one piece — adopting nothing is meaningless",
+      },
+    ]);
+    return normalizePieces(result.pieces as string[], "none");
+  }
+  throw new Error(
+    "mpo adopt needs at least one piece " +
+      `(${INIT_APP_PIECES.map((piece) => `--${piece}`).join(", ")}) — ` +
+      "adopting nothing is meaningless",
+  );
+}
+
+export async function adoptApp(options: AdoptAppOptions = {}): Promise<void> {
+  const projectDir = await spawn("git", ["rev-parse", "--show-toplevel"], {
+    cwd: process.cwd(),
+  }).then(
+    (result) => result.stdout.trim(),
+    () => {
+      throw new Error("mpo adopt must run inside a git repository");
+    },
+  );
+
+  if (isMpoMonorepo(projectDir)) {
+    throw new Error(
+      "mpo adopt cannot run inside the multiplatform.one monorepo (or a fork of it) — " +
+        "it is for consumer projects that use @multiplatform.one/* from npm",
+    );
+  }
+  if (existsSync(join(projectDir, PROVENANCE_FILE))) {
+    throw new Error(
+      `${PROVENANCE_FILE} already exists — this project already has scaffold provenance. ` +
+        "Run `mpo update` directly.",
+    );
+  }
+  await git(projectDir, ["rev-parse", "HEAD"]).catch(() => {
+    throw new Error("mpo adopt requires at least one commit — commit your project first");
+  });
+  // Clean tree required — adoption lands as its own commit, and the next
+  // step (`mpo update`) needs a clean tree anyway.
+  await git(projectDir, ["diff", "--quiet"]).catch(() => {
+    throw new Error("mpo adopt requires a clean working tree (unstaged changes present)");
+  });
+  await git(projectDir, ["diff", "--cached", "--quiet"]).catch(() => {
+    throw new Error("mpo adopt requires a clean working tree (staged changes present)");
+  });
+
+  const rawName = options.name ?? packageJsonName(projectDir);
+  if (!rawName) {
+    throw new Error(
+      "Could not derive a project name from package.json — pass one with --name <name>",
+    );
+  }
+  let name: string;
+  try {
+    name = validateName(rawName);
+  } catch (err) {
+    throw new Error(
+      `${(err as Error).message} The name renders piece file paths (apps/<name>/…), ` +
+        "so pick the one matching your app directory: --name <name>.",
+    );
+  }
+
+  const pieces = await resolveAdoptPieces(options);
+  const currentVersion = cliVersion() ?? "0.0.0";
+
+  writeProvenance(projectDir, {
+    template: "none",
+    cliVersion: currentVersion,
+    name,
+    mpoVersion: `^${currentVersion}`,
+    pieces,
+    reconciled: false,
+  });
+  const files = [PROVENANCE_FILE];
+  if (!existsSync(join(projectDir, UPDATEIGNORE_FILE))) {
+    writeFileSync(join(projectDir, UPDATEIGNORE_FILE), UPDATEIGNORE_SEED);
+    files.push(UPDATEIGNORE_FILE);
+  }
+  await git(projectDir, ["add", "--", ...files]);
+  const committed = await git(projectDir, [
+    "commit",
+    "--quiet",
+    "-m",
+    "chore: adopt multiplatform.one tooling (mpo adopt)",
+  ]).then(
+    () => true,
+    () => {
+      console.warn("⚠️  git commit failed (missing git identity?) — provenance left staged.");
+      return false;
+    },
+  );
+
+  console.log(`\n✅ adopted ${name} (pieces: ${pieces.join(", ")}, cli ${currentVersion})`);
+  console.log(`   ${files.join(" + ")} ${committed ? "committed" : "written"} — NO project files`);
+  console.log("   were changed by adoption itself.\n");
+  console.log("Next: run `mpo update` to reconcile the piece files.");
+  console.log("   THE FIRST UPDATE SURFACES REAL DIFFS: your hand-copied piece files");
+  console.log("   are merged against the piece templates from scratch, so conflicts");
+  console.log("   there are expected — resolve the markers and commit. Later updates");
+  console.log("   are ordinary three-way merges, and re-running `mpo update` right");
+  console.log("   after a successful update makes zero changes.");
+  console.log(`Pin anything the updater must never touch in ${UPDATEIGNORE_FILE}.`);
+}

package/src/commands/initApp.spec.ts

@@ -203,6 +203,77 @@ describe("initApp generator", () => {
     });
   });
 
+  describe("pieces-only template (adopted-project baselines)", () => {
+    const name = "adopt-base";
+    let root: string;
+
+    beforeAll(async () => {
+      await initApp(name, {
+        template: "none",
+        skipInstall: true,
+        skipGit: true,
+        version: "6.6.0",
+        yes: true,
+        pieces: ["webext"],
+      });
+      root = join(sandbox, name);
+    });
+
+    it("overlays ONLY the piece fragments (no base template)", () => {
+      for (const file of [
+        `apps/${name}/vite.config.webext.ts`,
+        `apps/${name}/webext/manifest.ts`,
+        `apps/${name}/webext/background/main.ts`,
+        `apps/${name}/package.json`,
+        ".gitignore",
+        "README.md",
+        "package.json",
+      ]) {
+        expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+      }
+      // Base-template content must NOT leak in.
+      for (const file of [
+        "pnpm-workspace.yaml",
+        "tsconfig.base.json",
+        `features/${name}`,
+        "packages/config",
+        `apps/${name}/routes`,
+        `apps/${name}/vite.config.ts`,
+      ]) {
+        expect(existsSync(join(root, file)), `unexpected ${file}`).toBe(false);
+      }
+    });
+
+    it("creates partial targets from the fragments alone", () => {
+      // Root package.json = the webext fragment only — no template fields.
+      const rootPkg = readJson(join(root, "package.json"));
+      expect(Object.keys(rootPkg)).toEqual(["scripts"]);
+      expect(rootPkg.scripts["build:webext"]).toBe(`pnpm --filter @app/${name} build:webext`);
+      const manifest = readFileSync(join(root, `apps/${name}/webext/manifest.ts`), "utf-8");
+      expect(manifest).toContain('const DISPLAY_NAME = "AdoptBase"');
+      expect(manifest).not.toMatch(/__NAME(_PASCAL|_APPID)?__/u);
+    });
+
+    it("records template none in provenance", () => {
+      const provenance = readJson(join(root, ".mpo.json"));
+      expect(provenance.template).toBe("none");
+      expect(provenance.pieces).toEqual(["webext"]);
+      expect("reconciled" in provenance).toBe(false);
+      expect(readProvenance(root)?.template).toBe("none");
+    });
+
+    it("refuses a pieces-only scaffold without pieces", async () => {
+      await expect(
+        initApp("no-pieces-base", {
+          template: "none",
+          skipInstall: true,
+          skipGit: true,
+          yes: true,
+        }),
+      ).rejects.toThrow(/at least one piece/u);
+    });
+  });
+
   it("rejects invalid names", async () => {
     await expect(
       initApp("Bad Name", { template: "app", skipInstall: true, yes: true }),
@@ -360,6 +431,26 @@ describe("initApp generator", () => {
         expect(readme).toContain("## Keycloak auth");
       });
 
+      // Two measured first-boot failures, both cheap to reintroduce. The
+      // keycloak image ships /opt/keycloak/data (keycloak-owned) and no
+      // h2/ subdirectory: a named volume mounted at data/h2 materializes
+      // root-owned, and Keycloak (uid 1000) dies with H2 90028 on a FRESH
+      // volume — it reads like corruption and survives `down -v`, because
+      // the wipe recreates the same root-owned mount point. And a
+      // hardcoded 8080 collides with whatever already owns the most
+      // contested dev port; a yaml !override in a second compose file is
+      // not a safe alternative (compose versions without the tag drop the
+      // whole ports list silently — container healthy, unreachable).
+      it("keeps the dev keycloak bootable: data/ volume, parameterized port", () => {
+        const compose = readFileSync(join(root, "docker/compose.keycloak.yaml"), "utf-8");
+        expect(compose).toContain('"${KEYCLOAK_HTTP_PORT:-8080}:8080"');
+        expect(
+          compose,
+          "volume mounts data/, which the image ships with keycloak ownership",
+        ).toMatch(/^\s*- keycloak:\/opt\/keycloak\/data$/mu);
+        expect(compose).not.toMatch(/^\s*- keycloak:\/opt\/keycloak\/data\/h2$/mu);
+      });
+
       it("records pieces sorted in provenance", () => {
         expect(readJson(join(root, ".mpo.json")).pieces).toEqual(["frappe", "keycloak"]);
       });
@@ -386,18 +477,14 @@ describe("initApp generator", () => {
           `apps/${name}/vite.config.gnome.ts`,
           `apps/${name}/gnome/main.tsx`,
           `apps/${name}/gnome/polyfills.ts`,
+          `apps/${name}/gnome/anchor.tsx`,
           `apps/${name}/gnome/tamagui-barrel.ts`,
           `apps/${name}/gnome/shims/components.ts`,
           `apps/${name}/gnome/shims/theme.ts`,
           `apps/${name}/gnome/shims/forms.ts`,
+          `apps/${name}/gnome/shims/frappe-ui.ts`,
           `apps/${name}/gnome/shims/one.ts`,
           `apps/${name}/gnome/shims/empty-module.ts`,
-          `apps/${name}/src-tauri/tauri.conf.json`,
-          `apps/${name}/src-tauri/Cargo.toml`,
-          `apps/${name}/src-tauri/src/main.rs`,
-          `apps/${name}/src-tauri/src/lib.rs`,
-          `apps/${name}/src-tauri/capabilities/default.json`,
-          `apps/${name}/src-tauri/icons/icon.icns`,
           `apps/${name}/vite.config.vscode.ts`,
           `apps/${name}/vscode/extension/index.ts`,
           `apps/${name}/vscode/webview/main.tsx`,
@@ -406,27 +493,43 @@ describe("initApp generator", () => {
           `apps/${name}/vscode/manifest.ts`,
           `apps/${name}/vite.config.webext.ts`,
           `apps/${name}/webext/manifest.ts`,
+          `apps/${name}/src-tauri/tauri.conf.json`,
+          `apps/${name}/src-tauri/Cargo.toml`,
+          `apps/${name}/src-tauri/build.rs`,
+          `apps/${name}/src-tauri/src/main.rs`,
+          `apps/${name}/src-tauri/src/lib.rs`,
+          `apps/${name}/src-tauri/capabilities/default.json`,
+          `apps/${name}/src-tauri/icons/icon.icns`,
           "docker/compose.frappe.yaml",
           "docker/compose.keycloak.yaml",
         ]) {
           expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
         }
-        const tauriConf = readJson(join(root, `apps/${name}/src-tauri/tauri.conf.json`));
-        expect(tauriConf.productName).toBe(name);
-        expect(tauriConf.identifier).toBe("com.fulldemo.app");
         const rootPkg = readJson(join(root, "package.json"));
         for (const script of [
           "gnome",
           "gnome:capture",
-          "tauri:dev",
-          "tauri:build",
           "build:vscode",
           "build:webext",
+          "tauri:dev",
+          "tauri:build",
         ]) {
           expect(rootPkg.scripts[script], `root script ${script}`).toBeDefined();
         }
       });
 
+      // Tauri and GNOME are peer desktop targets — the kitchen sink proves
+      // they co-select: one scaffold carries both the src-tauri webview
+      // shell and the GTK/GJS gnome target side by side.
+      it("keeps tauri and gnome as co-selected desktop targets", () => {
+        expect(existsSync(join(root, `apps/${name}/src-tauri/tauri.conf.json`))).toBe(true);
+        expect(existsSync(join(root, `apps/${name}/vite.config.gnome.ts`))).toBe(true);
+        const appPkg = readJson(join(root, `apps/${name}/package.json`));
+        expect(appPkg.scripts["tauri:dev"]).toBe("tauri dev");
+        expect(appPkg.devDependencies["@tauri-apps/cli"]).toBeDefined();
+        expect(appPkg.scripts.gnome).toBeDefined();
+      });
+
       // The GNOME target is the only piece that rewires module resolution
       // rather than just adding files, and both halves of that rewiring
       // fail silently if they drift. A shim that imports the bare barrel
@@ -435,7 +538,7 @@ describe("initApp generator", () => {
       // error. And the react-gnome packages are the runtime: without them
       // the entry resolves nothing at all.
       it("wires the gnome target without aliasing a shim back to itself", () => {
-        const aliased = ["components", "theme", "forms"] as const;
+        const aliased = ["components", "theme", "forms", "frappe-ui"] as const;
         for (const barrel of aliased) {
           const shim = readFileSync(join(root, `apps/${name}/gnome/shims/${barrel}.ts`), "utf-8");
           expect(shim, `${barrel} shim must deep-import, never the bare barrel`).not.toMatch(
@@ -463,6 +566,43 @@ describe("initApp generator", () => {
         expect(firstImport).toBe(`import "./polyfills";`);
       });
 
+      // The other half of that rewiring, and the half that fails most
+      // quietly. `@multiplatform.one/platform` ships its GNOME flags as
+      // `index.gnome.ts`, and the ONLY thing that selects that file is
+      // `.gnome.*` sitting ahead of react-gnome's `.native.*` in
+      // resolve.extensions. Drop the registration and a scaffolded project
+      // still builds, still runs, and reports `isGnome: false` forever.
+      it("registers .gnome.* ahead of .native.* so isGnome resolves", () => {
+        const config = readFileSync(join(root, `apps/${name}/vite.config.gnome.ts`), "utf-8");
+        expect(config, "gnomePlatformExtensions must be imported").toMatch(
+          /import\s*\{[^}]*\bgnomePlatformExtensions\b[^}]*\}\s*from\s*"@multiplatform\.one\/vite-plugin-gnome"/u,
+        );
+        expect(config, ".gnome.* must be registered ahead of .native.*").toMatch(
+          /extensions:\s*\[\s*\.\.\.gnomePlatformExtensions\s*,\s*\.\.\.gnomeExtensions\s*,?\s*\]/u,
+        );
+      });
+
+      // The @react-gnome aliases must not assume the scope sits in the
+      // app's OWN node_modules: the scaffold's .npmrc sets
+      // node-linker=hoisted, so every dependency hoists to the workspace
+      // root, the app-local dir never exists, and every alias points at a
+      // nonexistent path (measured — the build fails resolving the
+      // renderer). require.resolve cannot do the lookup either, because
+      // the @react-gnome export maps hide package.json; the config walks
+      // up to whichever node_modules holds the scope. And the registry
+      // tarballs ship dist ONLY (files: ["dist", …]), so the renderer
+      // alias needs a dist fallback when there is no src checkout.
+      it("finds @react-gnome by walking up, with a dist fallback for registry tarballs", () => {
+        const config = readFileSync(join(root, `apps/${name}/vite.config.gnome.ts`), "utf-8");
+        expect(config, "walk-up helper must exist").toContain("function reactGnomeScopeDir()");
+        expect(config, "aliases must use the walk-up, not the app-local dir").toMatch(
+          /gnomeLinkedAliases\(reactGnomeScopeDir\(\)\)/u,
+        );
+        expect(config, "renderer alias needs the dist fallback").toContain(
+          "renderer/dist/index.js",
+        );
+      });
+
       it("leaves no template placeholders anywhere", () => {
         const binary = new Set([".woff2", ".png", ".ico", ".icns"]);
         const walk = (dir: string): string[] =>