@10stars/config 17.0.3 → 17.0.5

package/package.json

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

package/src/link-remote.ts

@@ -1,10 +1,11 @@
-import { execFileSync } from "node:child_process"
+import { execFile, execFileSync } from "node:child_process"
 import fs from "node:fs/promises"
 import path from "node:path"
+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[]
@@ -39,9 +40,14 @@ type Sibling = { abs: string; ref: string | null }
 const git = (args: string[], cwd?: string): string =>
   execFileSync(`git`, args, { cwd, encoding: `utf8` }).trim()
 
-const gitInherit = (args: string[], cwd?: string): void => {
-  execFileSync(`git`, args, { cwd, stdio: `inherit` })
-}
+const execFileAsync = promisify(execFile)
+
+// Async git so independent clones (a BFS level's siblings, or all pinned --from clones) run
+// concurrently: the sync `git` helper's execFileSync would serialize them by blocking the event
+// loop until each finishes. Output is captured (not inherited) so concurrent progress can't
+// interleave into unreadable logs; callers log one line per repo.
+const gitAsync = (args: string[], cwd?: string): Promise<unknown> =>
+  execFileAsync(`git`, args, { cwd })
 
 const tryGit = (args: string[], cwd?: string): string | null => {
   try {
@@ -51,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
@@ -107,22 +121,35 @@ const fileSiblingRoots = async (dir: string): Promise<string[]> => {
 }
 
 /**
- * BFS the transitive `file:` sibling graph from `cwd`, invoking `visit` once per newly discovered
- * sibling root in dependents-first order. Cloning inside `visit` makes that sibling's own `file:`
- * deps discoverable when it is later dequeued; a still-missing dir simply yields no children.
+ * BFS the transitive `file:` sibling graph from `cwd` in dependents-first order, invoking `visit`
+ * on each level's newly discovered siblings concurrently (`Promise.all`). Cloning a sibling in
+ * `visit` makes its own `file:` deps discoverable when the next level expands from it. Levels stay
+ * sequential (a child is only found after its parent is cloned) but siblings within a level are
+ * independent and clone in parallel. The `visited` set dedupes repos reached by more than one path,
+ * both across and within a level. Returns the deduped siblings in discovery (dependents-first) order.
  */
-const bfsSiblings = async (cwd: string, visit: (sib: string) => Promise<void>): Promise<void> => {
+const bfsSiblings = async (
+  cwd: string,
+  visit: (sib: string) => Promise<void>,
+): Promise<string[]> => {
   const visited = new Set<string>([path.resolve(cwd)])
-  const queue = [path.resolve(cwd)]
-  while (queue.length) {
-    const dir = queue.shift()!
-    for (const sib of await fileSiblingRoots(dir)) {
-      if (visited.has(sib)) continue
-      visited.add(sib)
-      await visit(sib)
-      queue.push(sib)
+  const order: string[] = []
+  let frontier = [path.resolve(cwd)]
+  while (frontier.length) {
+    const level: string[] = []
+    for (const dir of frontier) {
+      for (const sib of await fileSiblingRoots(dir)) {
+        if (visited.has(sib)) continue // dedupe repos reached via multiple file: paths
+        visited.add(sib)
+        level.push(sib)
+      }
     }
+    // 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
   }
+  return order
 }
 
 /**
@@ -160,7 +187,12 @@ const matchRemoteBranch = (url: string, candidates: string[]): string | null =>
  * `--branch`, so the `ls-remote` probe is skipped entirely when no coordinated branch is set — one
  * fewer round-trip for local/manual runs (in GitHub Actions GITHUB_REF_NAME is always set).
  */
-const cloneSibling = (url: string, repo: string, sib: string, dest: string): string | null => {
+const cloneSibling = async (
+  url: string,
+  repo: string,
+  sib: string,
+  dest: string,
+): Promise<string | null> => {
   const coordinated = [
     process.env.GITHUB_HEAD_REF, // pull_request events
     process.env.GITHUB_REF_NAME, // push events
@@ -168,7 +200,7 @@ const cloneSibling = (url: string, repo: string, sib: string, dest: string): str
   const ref = coordinated.length ? matchRemoteBranch(url, coordinated) : null
 
   console.info(`linkRemote: cloning ${repo}@${ref ?? `(default)`} -> ${dest}`)
-  gitInherit([
+  await gitAsync([
     `clone`,
     `--depth`,
     `1`,
@@ -189,11 +221,11 @@ const currentRef = (dir: string): string | null => {
   return branch === `HEAD` ? null : branch
 }
 
-const clonePinned = (url: string, sha: string, dir: string): void => {
-  gitInherit([`init`, dir])
-  gitInherit([`remote`, `add`, `origin`, url], dir)
-  gitInherit([`fetch`, `--depth`, `1`, `origin`, sha], dir) // GitHub allows fetching a reachable SHA
-  gitInherit([`checkout`, `FETCH_HEAD`], dir)
+const clonePinned = async (url: string, sha: string, dir: string): Promise<void> => {
+  await gitAsync([`init`, dir])
+  await gitAsync([`remote`, `add`, `origin`, url], dir)
+  await gitAsync([`fetch`, `--depth`, `1`, `origin`, sha], dir) // GitHub allows fetching a reachable SHA
+  await gitAsync([`checkout`, `FETCH_HEAD`], dir)
 }
 
 /**
@@ -201,19 +233,18 @@ const clonePinned = (url: string, sha: string, dir: string): void => {
  * Returns siblings in discovery (BFS) order — dependents before their dependencies.
  */
 const cloneClosureBranchFirst = async (cwd: string): Promise<Sibling[]> => {
-  const order: Sibling[] = []
-  await bfsSiblings(cwd, async (sib) => {
-    let ref: string | null
+  // Parallel visits resolve out of order; key refs by abs path and reassemble in discovery order.
+  const refs = new Map<string, string | null>()
+  const discovered = await bfsSiblings(cwd, async (sib) => {
     if (await exists(sib)) {
       console.info(`linkRemote: ${path.relative(cwd, sib)} already present; not cloning`)
-      ref = currentRef(sib)
-    } else {
-      const repo = path.basename(sib)
-      ref = cloneSibling(repoUrl(repo), repo, sib, path.relative(cwd, sib))
+      refs.set(sib, currentRef(sib))
+      return
     }
-    order.push({ abs: sib, ref })
+    const repo = path.basename(sib)
+    refs.set(sib, await cloneSibling(repoUrl(repo), repo, sib, path.relative(cwd, sib)))
   })
-  return order
+  return discovered.map((abs) => ({ abs, ref: refs.get(abs) ?? null }))
 }
 
 const writeManifest = async (cwd: string, siblings: Sibling[], out: string): Promise<void> => {
@@ -244,40 +275,47 @@ const linkRemoteFromManifest = async (cwd: string, manifestPath: string): Promis
     return
   }
 
-  for (const sib of manifest.siblings) {
-    const abs = path.resolve(cwd, sib.path)
-    if (await exists(abs)) {
-      console.info(`linkRemote --from: ${sib.path} already present; leaving as-is`)
-      continue
-    }
-    if (!sib.sha) throw new Error(`Manifest entry "${sib.repo}" has no sha to pin`)
-    console.info(`linkRemote --from: pinning ${sib.repo}@${sib.sha} -> ${sib.path}`)
-    clonePinned(repoUrl(sib.repo), sib.sha, abs)
-  }
+  // Pinned clones are mutually independent (each at a recorded SHA, no discovery), so materialize
+  // 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)
+      if (await exists(abs)) {
+        console.info(`linkRemote --from: ${sib.path} already present; leaving as-is`)
+        return
+      }
+      if (!sib.sha) throw new Error(`Manifest entry "${sib.repo}" has no sha to pin`)
+      console.info(`linkRemote --from: pinning ${sib.repo}@${sib.sha} -> ${sib.path}`)
+      await clonePinned(repoUrl(sib.repo), sib.sha, abs)
+    }),
+  )
 
-  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.
  *
@@ -294,7 +332,7 @@ export const linkRemote = async (cwd: string, opts: LinkRemoteOptions = {}): Pro
     return
   }
 
-  installLeavesFirst(
+  await installSiblings(
     cwd,
     siblings.map((s) => s.abs),
   )