@nativedesktop/cli 0.1.2 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativedesktop/cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "The nd CLI: dev-runs, builds, and packages NativeDesktop apps",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,6 @@
     "./config": "./src/config.ts"
   },
   "dependencies": {
-    "@nativedesktop/host": "0.1.2"
+    "@nativedesktop/host": "0.2.0"
   }
 }

package/src/package/modules.test.ts

@@ -142,4 +142,26 @@ describe("assertResolvableEntries", () => {
     writeFileSync(join(carrier, "package.json"), JSON.stringify({ name: "host-binary", files: ["bin"] }));
     expect(() => assertResolvableEntries(root, ["host-binary"])).not.toThrow();
   });
+
+  test("tolerates subpath-only exports (@nativedesktop/native's shape)", () => {
+    const root = mkdtempSync(join(tmpdir(), "nd-modules-"));
+    const headers = join(root, "node_modules", "header-carrier");
+    mkdirSync(headers, { recursive: true });
+    writeFileSync(
+      join(headers, "package.json"),
+      JSON.stringify({ name: "header-carrier", exports: { "./include/nd.h": "./include/nd.h" } }),
+    );
+    expect(() => assertResolvableEntries(root, ["header-carrier"])).not.toThrow();
+  });
+
+  test("still throws when exports declares a root entry that is missing", () => {
+    const root = mkdtempSync(join(tmpdir(), "nd-modules-"));
+    const broken = join(root, "node_modules", "needs-build-exports");
+    mkdirSync(broken, { recursive: true });
+    writeFileSync(
+      join(broken, "package.json"),
+      JSON.stringify({ name: "needs-build-exports", exports: { ".": "./dist/index.js" } }),
+    );
+    expect(() => assertResolvableEntries(root, ["needs-build-exports"])).toThrow("bun run build");
+  });
 });

package/src/package/modules.ts

@@ -10,9 +10,14 @@ interface QueueEntry {
   spec: string;
   /** Directory the spec resolves from (the requiring package's real root). */
   anchor: string;
+  /** Second anchor to try, used for peers whose consumer does not supply one. */
+  fallbackAnchor?: string;
   /** Dest-relative dir of the requiring package, for version-conflict nesting. */
   requirer?: string;
   optional: boolean;
+  /** A peerDependency: the CONSUMER's copy is the correct one, so an existing
+   * flat claim wins outright instead of nesting a second copy. */
+  peer?: boolean;
 }
 
 const skipNodeModules = (src: string) => basename(src) !== "node_modules";
@@ -63,12 +68,24 @@ export function flattenRuntimeModules({ appDir, extraRoots = [], dest }: Flatten
 
   while (queue.length) {
     const entry = queue.shift()!;
+    // A peer the app already provides is settled: taking the dependency's own
+    // copy instead is what puts two reacts in one bundle.
+    if (entry.peer && claimed.has(entry.spec)) continue;
     let root: string;
     try {
       root = packageRoot(entry.spec, entry.anchor);
     } catch (err) {
-      if (entry.optional) continue;
-      throw new Error(`nd: cannot resolve runtime dependency "${entry.spec}" from ${entry.anchor}: ${err}`);
+      if (entry.fallbackAnchor) {
+        try {
+          root = packageRoot(entry.spec, entry.fallbackAnchor);
+        } catch {
+          if (entry.optional) continue;
+          throw new Error(`nd: cannot resolve runtime dependency "${entry.spec}" from ${entry.anchor}: ${err}`);
+        }
+      } else {
+        if (entry.optional) continue;
+        throw new Error(`nd: cannot resolve runtime dependency "${entry.spec}" from ${entry.anchor}: ${err}`);
+      }
     }
 
     const existing = claimed.get(entry.spec);
@@ -94,14 +111,35 @@ export function flattenRuntimeModules({ appDir, extraRoots = [], dest }: Flatten
     for (const spec of Object.keys(pkg.dependencies ?? {})) {
       queue.push({ spec, anchor: root, requirer: destDir, optional: false });
     }
-    for (const spec of [...Object.keys(pkg.optionalDependencies ?? {}), ...Object.keys(pkg.peerDependencies ?? {})]) {
+    for (const spec of Object.keys(pkg.optionalDependencies ?? {})) {
       queue.push({ spec, anchor: root, requirer: destDir, optional: true });
     }
+    // Peers resolve from the APP, not from the package that declares them. A
+    // `file:` linked dependency living outside the app tree resolves its own
+    // peer to its own copy, and a second react in the bundle is the classic
+    // "Invalid hook call" at launch. The package's root is only the fallback,
+    // for a peer the app does not provide at all.
+    for (const spec of Object.keys(pkg.peerDependencies ?? {})) {
+      queue.push({ spec, anchor, fallbackAnchor: root, requirer: destDir, optional: true, peer: true });
+    }
   }
 
   return [...claimed.keys()];
 }
 
+/**
+ * Whether `exports` offers the package's ROOT specifier. A string is one; an
+ * object is one only through a `"."` key or the conditions shorthand (keys that
+ * are not subpaths). A subpath-only map (`{"./include/nd.h": …}`, which is what
+ * `@nativedesktop/native` publishes) declares no root entry, so failing to
+ * resolve the bare name is correct rather than a missing build.
+ */
+function declaresRootEntry(exports: unknown): boolean {
+  if (typeof exports === "string") return true;
+  if (exports === null || typeof exports !== "object") return false;
+  return Object.keys(exports).some((key) => key === "." || !key.startsWith("."));
+}
+
 /**
  * Asserts each flat package's main/exports entry resolves inside the bundle.
  * Catches a copied-but-unbuilt package (e.g. @nativedesktop/react without its
@@ -119,7 +157,7 @@ export function assertResolvableEntries(appRoot: string, names: string[]): void
         module?: string;
         exports?: unknown;
       };
-      if (pkg.main === undefined && pkg.module === undefined && pkg.exports === undefined) continue;
+      if (pkg.main === undefined && pkg.module === undefined && !declaresRootEntry(pkg.exports)) continue;
       throw new Error(
         `nd: bundled package "${name}" has no resolvable entry (its build output is missing). ` +
         `Run \`bun run build\` in ${name} and package again.`,