@10stars/config 17.0.4 → 17.0.6

package/package.json

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

package/src/index.ts

@@ -3,11 +3,11 @@ import { execSync } from "node:child_process"
 import fs from "node:fs/promises"
 import path from "node:path"
 
-import { resetColorIndex } from "./colors"
-import { checkIsMonorepo, dedupeSingletons, linkPackages, linkSelf } from "./link-packages"
-import { dedupeRemote, linkRemote } from "./link-remote"
+import { checkIsMonorepo, dedupeSingletons, linkPackages, linkSelf } from "./linking/link-packages"
+import { dedupeRemote, linkRemote } from "./linking/link-remote"
 import { setupOverrides } from "./manage-overrides"
-import { runConcurrently, type CommandConfig } from "./runner"
+import { resetColorIndex } from "./run/colors"
+import { runConcurrently, type CommandConfig } from "./run/runner"
 import { setupSideEffects } from "./vanilla-extract/manage-side-effects"
 import { patchVanillaExtract } from "./vanilla-extract/patch-vanilla-extract"
 import { setupVSCode } from "./vscode-config"

package/src/{link-remote.ts → linking/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),
   )

package/src/vanilla-extract/patch-vanilla-extract.ts

@@ -23,18 +23,32 @@ const PATCHED = String.raw`/(?:^|[/\\])css\.(js|cjs|mjs|jsx|ts|tsx)(\?used)?$/`
 export const patchVanillaExtract = async (cwd: string): Promise<boolean> => {
   const nodeModules = path.join(cwd, `node_modules`)
 
-  // Recursively collect `@vanilla-extract/integration/dist/*.js` WITHOUT following directory
-  // symlinks. A `file:` self-dep (e.g. frontend-toolkit's `frontend-toolkit: file:.` creates
-  // node_modules/frontend-toolkit -> .) makes symlink-following recurse forever — Bun.Glob does,
-  // even with `followSymlinks: false`. A linked sibling patches its own VE during its own install,
-  // and this repo's own copy is hoisted as a real dir, so real-dir-only recursion is sufficient.
-  const integrationDist = /[/\\]@vanilla-extract[/\\]integration[/\\]dist[/\\][^/\\]+\.js$/
+  // Collect every real `@vanilla-extract/integration/dist/*.js`. VE always sits directly under a
+  // `node_modules` dir, so we read each node_modules' own integration/dist and recurse ONLY into
+  // *nested* node_modules — never into package source trees. (A flat hoisted tree is hundreds of
+  // packages; recursing each one's dist/esm/cjs/… was the bulk of the old cost.) Symlinks are
+  // skipped: a `file:` self-dep links node_modules/<pkg> -> repo root, so following links recurses
+  // forever — also why Bun.Glob (which follows links even with `followSymlinks: false`) can't be
+  // used. A linked sibling patches its own VE during its own install; this repo's copy is hoisted
+  // as a real dir, so real-dir-only descent finds every copy that this install must patch.
   const findFiles = async (dir: string, out: string[] = []): Promise<string[]> => {
+    const distDir = path.join(dir, `@vanilla-extract`, `integration`, `dist`)
+    for (const entry of await fs.readdir(distDir, { withFileTypes: true }).catch(() => [])) {
+      if (entry.isFile() && entry.name.endsWith(`.js`)) out.push(path.join(distDir, entry.name))
+    }
+
     for (const entry of await fs.readdir(dir, { withFileTypes: true }).catch(() => [])) {
-      if (entry.isSymbolicLink()) continue
-      const full = path.join(dir, entry.name)
-      if (entry.isDirectory()) await findFiles(full, out)
-      else if (entry.isFile() && integrationDist.test(full)) out.push(full)
+      if (entry.isSymbolicLink() || !entry.isDirectory()) continue
+      const pkgDir = path.join(dir, entry.name)
+      if (entry.name.startsWith(`@`)) {
+        // scoped packages nest a level deeper: node_modules/@scope/<pkg>/node_modules
+        for (const scoped of await fs.readdir(pkgDir, { withFileTypes: true }).catch(() => [])) {
+          if (scoped.isSymbolicLink() || !scoped.isDirectory()) continue
+          await findFiles(path.join(pkgDir, scoped.name, `node_modules`), out)
+        }
+      } else {
+        await findFiles(path.join(pkgDir, `node_modules`), out)
+      }
     }
     return out
   }