@10stars/config 17.0.4 → 17.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10stars/config",
-  "version": "17.0.4",
+  "version": "17.0.5",
   "private": false,
   "bin": {
     "config": "./src/index.ts"

package/src/link-remote.ts

@@ -5,7 +5,7 @@ import { promisify } from "node:util"
 
 import type * as TF from "type-fest"
 
-import { dedupeSingletons } from "./link-packages"
+import { dedupeSingletons, linkSelf } from "./link-packages"
 
 interface Config {
   dedupeSingletons?: boolean | string[]
@@ -57,8 +57,16 @@ const tryGit = (args: string[], cwd?: string): string | null => {
   }
 }
 
-const bunInstall = (cwd: string): void =>
-  void execFileSync(`bun`, [`install`], { cwd, stdio: `inherit` })
+// --ignore-scripts: a sibling is only a dependency here, so skip its postinstall (`config prepare`)
+// — its Vanilla-Extract patch isn't needed (nothing builds it; typecheck doesn't run VE) and the
+// cross-repo `@types/*` dedupe runs once via the consumer's `dedupe` afterwards. We still restore
+// the one thing a sibling's own src needs: its self-symlink, so `<self>/src/…` self-imports resolve
+// at realpath in the flat-peer layout. (Workspace-root siblings, e.g. backend-api, get their
+// subpackage self-links from bun's own workspace linking, so linkSelf no-ops on them.)
+const bunInstall = async (cwd: string): Promise<void> => {
+  await execFileAsync(`bun`, [`install`, `--ignore-scripts`], { cwd })
+  await linkSelf(cwd)
+}
 
 const exists = (p: string): Promise<boolean> =>
   fs
@@ -136,7 +144,8 @@ const bfsSiblings = async (
         level.push(sib)
       }
     }
-    await Promise.all(level.map(visit)) // clone this level's siblings in parallel
+    // clone this level's siblings in parallel; unbounded fan-out, fine for the handful in practice
+    await Promise.all(level.map(visit))
     order.push(...level)
     frontier = level
   }
@@ -267,7 +276,7 @@ const linkRemoteFromManifest = async (cwd: string, manifestPath: string): Promis
   }
 
   // Pinned clones are mutually independent (each at a recorded SHA, no discovery), so materialize
-  // them all in parallel; leaves-first install order is still enforced below.
+  // them all in parallel; the installs below are likewise parallel and order-independent.
   await Promise.all(
     manifest.siblings.map(async (sib) => {
       const abs = path.resolve(cwd, sib.path)
@@ -281,29 +290,32 @@ const linkRemoteFromManifest = async (cwd: string, manifestPath: string): Promis
     }),
   )
 
-  installLeavesFirst(
+  await installSiblings(
     cwd,
     manifest.siblings.map((s) => path.resolve(cwd, s.path)),
   )
 }
 
 /**
- * Install siblings leaves-first (reverse of dependents-first discovery order) so a hoisted
- * sibling (e.g. `common`) is installed before a repo that links into it.
- * Assumes an acyclic, mostly-linear `file:` graph; a diamond could need a real topological sort.
+ * Install every cloned sibling, in parallel. `--ignore-scripts` (in bunInstall) removes the
+ * postinstall that used to make this order-sensitive, so ordering no longer matters: each install
+ * is independent — it resolves its own `file:` deps from their on-disk package.json and hoists into
+ * its OWN node_modules, writing nobody else's tree. (Bun's global cache is concurrency-safe.)
  */
-const installLeavesFirst = (cwd: string, siblingsInDiscoveryOrder: string[]): void => {
-  for (const abs of [...siblingsInDiscoveryOrder].reverse()) {
-    console.info(`linkRemote: bun install in ${path.relative(cwd, abs)}`)
-    bunInstall(abs)
-  }
+const installSiblings = async (cwd: string, siblings: string[]): Promise<void> => {
+  await Promise.all(
+    siblings.map(async (abs) => {
+      console.info(`linkRemote: bun install in ${path.relative(cwd, abs)}`)
+      await bunInstall(abs)
+    }),
+  )
 }
 
 /**
  * CI: materialize the transitive `file:` sibling graph that a standalone checkout lacks.
  *
  * Default (branch-first): BFS the graph, shallow single-branch clone each missing sibling at
- * its resolved ref, then `bun install` leaves-first. `--emit-manifest` records the exact
+ * its resolved ref, then `bun install --ignore-scripts` each in parallel. `--emit-manifest` records the exact
  * {repo, ref, sha, version} set (a cross-repo lockfile snapshot for revert). `--from` skips
  * branch-first and pin-clones each sibling at the manifest's recorded SHA.
  *
@@ -320,7 +332,7 @@ export const linkRemote = async (cwd: string, opts: LinkRemoteOptions = {}): Pro
     return
   }
 
-  installLeavesFirst(
+  await installSiblings(
     cwd,
     siblings.map((s) => s.abs),
   )