@10stars/config 17.0.1 → 17.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10stars/config",
-  "version": "17.0.1",
+  "version": "17.0.3",
   "private": false,
   "bin": {
     "config": "./src/index.ts"
@@ -30,7 +30,7 @@
     "oxfmt": "0.58.0",
     "oxlint": "^1.73.0",
     "oxlint-tsgolint": "^0.24.0",
-    "tsx": "^4.23.0",
+    "tsx": "^4.23.1",
     "type-fest": "^5.8.0",
     "typescript": "7.0.2"
   }

package/src/index.ts

@@ -4,7 +4,7 @@ import fs from "node:fs/promises"
 import path from "node:path"
 
 import { resetColorIndex } from "./colors"
-import { checkIsMonorepo, dedupeSingletons, linkPackages } from "./link-packages"
+import { checkIsMonorepo, dedupeSingletons, linkPackages, linkSelf } from "./link-packages"
 import { dedupeRemote, linkRemote } from "./link-remote"
 import { setupOverrides } from "./manage-overrides"
 import { runConcurrently, type CommandConfig } from "./runner"
@@ -47,6 +47,8 @@ const actions = {
     action: async () => {
       const veInstalled = await patchVanillaExtract(cwd) // patch VE before the CI guard: builds (incl. CI) need the `css.ts`-only filter in node_modules
 
+      await linkSelf(cwd) // before the CI guard: CI app builds also self-import `<pkg>/src/…`
+
       if (process.env.CI) return
 
       // we must copy it first, because the following steps might have formatting cmds

package/src/link-packages.ts

@@ -1,8 +1,20 @@
+import { execFile } 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"
 
+const execFileAsync = promisify(execFile)
+
+// bun materializes a `file:.` self-dep sibling as a dir of self-referential symlinks (name -> name)
+// over a nested node_modules; `fs.rm(recursive)` follows that into an ELOOP and hangs. Coreutils
+// `rm -rf` uses cycle-detecting fts and clears it instantly. Windows keeps fs.rm (force skips ELOOP).
+const removeDir = async (dir: string) => {
+  if (process.platform === `win32`) return fs.rm(dir, { recursive: true, force: true })
+  await execFileAsync(`rm`, [`-rf`, dir])
+}
+
 const symlink = async (pathTarget: string, pathSymlink: string) => {
   const stats = await fs.lstat(pathSymlink).catch(() => null)
   if (!stats) return
@@ -12,12 +24,39 @@ const symlink = async (pathTarget: string, pathSymlink: string) => {
     if (pathTarget === symlinkRealpath) return
   }
 
-  if (stats.isDirectory()) await fs.rm(pathSymlink, { recursive: true })
+  if (stats.isDirectory()) await removeDir(pathSymlink)
   else await fs.unlink(pathSymlink)
 
   await fs.symlink(pathTarget, pathSymlink)
 }
 
+/**
+ * Create `node_modules/<self-name> -> <repo root>` so a single-package repo can import its own
+ * files by package name (`frontend-toolkit/src/…`) at runtime — replacing the old `file:.`
+ * self-dependency. A `file:.` self-dep makes bun's file: resolver recurse over the package's whole
+ * subtree on every consumer's install (multi-minute CPU spin, then a stack-overflow crash). This
+ * runs in postinstall (after `bun install`), so bun never resolves a self-dep, yet every tool
+ * (bun/node, Vite, Ladle, Vitest) still resolves self-imports via node_modules. tsconfig `paths`
+ * cover the same specifiers for typecheck. Unlike `symlink()` above this CREATES the link when
+ * absent (there's no self-dep for `bun install` to have materialized first). Skips workspace roots
+ * (their subpackages are separate) and unnamed packages.
+ */
+export const linkSelf = async (cwd: string) => {
+  const pkgJson: TF.PackageJson = await import(path.join(cwd, `package.json`)).catch(() => null)
+  if (!pkgJson?.name || pkgJson.workspaces) return
+
+  const pathSymlink = path.join(cwd, `node_modules`, pkgJson.name)
+  await fs.mkdir(path.dirname(pathSymlink), { recursive: true })
+  const relTarget = path.relative(path.dirname(pathSymlink), cwd) // `..` (bare) / `../..` (scoped)
+
+  const stats = await fs.lstat(pathSymlink).catch(() => null)
+  if (stats?.isSymbolicLink() && (await fs.realpath(pathSymlink).catch(() => null)) === cwd) return
+  if (stats?.isDirectory()) await removeDir(pathSymlink)
+  else if (stats) await fs.unlink(pathSymlink)
+
+  await fs.symlink(relTarget, pathSymlink)
+}
+
 export const checkIsMonorepo = async (pathPkg: string) => {
   const pkgJson = await import(path.join(pathPkg, `package.json`))
   return Boolean(pkgJson.workspaces)

package/src/link-remote.ts

@@ -126,23 +126,15 @@ const bfsSiblings = async (cwd: string, visit: (sib: string) => Promise<void>):
 }
 
 /**
- * Branch-first: current PR branch, then push branch, then `develop`, then `production`. A single
- * `ls-remote --heads` lists every head in one network round-trip; candidates are matched locally
- * (avoids one request per ref). A non-zero exit means the repo is unreadable (private + missing/
- * unauthorized clone token → "Repository not found") — surfaced immediately rather than masquerading
- * as "No branch found".
+ * The first of `candidates` (priority order) that exists as a branch on the remote, else null.
+ * Queries only those specific refs in one `ls-remote` — no full head listing. A non-zero exit means
+ * the repo is unreadable (private + missing/unauthorized clone token → "Repository not found") —
+ * surfaced immediately rather than masquerading as a missing branch.
  */
-const resolveRef = (url: string, repo: string): string => {
-  const candidates = [
-    process.env.GITHUB_HEAD_REF, // pull_request events
-    process.env.GITHUB_REF_NAME, // push events
-    `develop`,
-    `production`,
-  ].filter((v): v is string => Boolean(v))
-
-  let heads: string
+const matchRemoteBranch = (url: string, candidates: string[]): string | null => {
+  let out: string
   try {
-    heads = git([`ls-remote`, `--heads`, url])
+    out = git([`ls-remote`, url, ...candidates.map((c) => `refs/heads/${c}`)])
   } catch (err) {
     const stderr = (err as { stderr?: string | Buffer })?.stderr
     throw new Error(
@@ -151,18 +143,41 @@ const resolveRef = (url: string, repo: string): string => {
         `with contents:read.\n${(stderr ?? (err as Error)?.message ?? ``).toString().trim()}`,
     )
   }
-
-  // Each line is "<sha>\trefs/heads/<branch>"; a branch may itself contain slashes (e.g. alice/x).
+  // Lines are "<sha>\trefs/heads/<branch>"; a branch may itself contain slashes (e.g. alice/x).
   const present = new Set(
-    heads
+    out
       .split(`\n`)
       .map((line) => line.split(`refs/heads/`)[1])
       .filter(Boolean),
   )
-  for (const ref of candidates) if (present.has(ref)) return ref
-  throw new Error(
-    `No branch found for ${repo}; tried: ${candidates.join(`, `)} (repo reachable, refs absent)`,
-  )
+  return candidates.find((c) => present.has(c)) ?? null
+}
+
+/**
+ * Clone a missing sibling as a flat peer, returning the branch it landed on. Prefers a branch
+ * matching the consumer's coordinated branch (PR head, then push branch) when the sibling has one;
+ * otherwise clones the sibling's own default branch directly. A default-branch clone needs no
+ * `--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 coordinated = [
+    process.env.GITHUB_HEAD_REF, // pull_request events
+    process.env.GITHUB_REF_NAME, // push events
+  ].filter((v): v is string => Boolean(v))
+  const ref = coordinated.length ? matchRemoteBranch(url, coordinated) : null
+
+  console.info(`linkRemote: cloning ${repo}@${ref ?? `(default)`} -> ${dest}`)
+  gitInherit([
+    `clone`,
+    `--depth`,
+    `1`,
+    `--single-branch`,
+    ...(ref ? [`--branch`, ref] : []),
+    url,
+    sib,
+  ])
+  return ref ?? currentRef(sib)
 }
 
 const headSha = (dir: string): string | null => tryGit([`rev-parse`, `HEAD`], dir)
@@ -194,10 +209,7 @@ const cloneClosureBranchFirst = async (cwd: string): Promise<Sibling[]> => {
       ref = currentRef(sib)
     } else {
       const repo = path.basename(sib)
-      const url = repoUrl(repo)
-      ref = resolveRef(url, repo)
-      console.info(`linkRemote: cloning ${repo}@${ref} -> ${path.relative(cwd, sib)}`)
-      gitInherit([`clone`, `--depth`, `1`, `--single-branch`, `--branch`, ref, url, sib])
+      ref = cloneSibling(repoUrl(repo), repo, sib, path.relative(cwd, sib))
     }
     order.push({ abs: sib, ref })
   })

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

@@ -22,15 +22,29 @@ 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`)
-  const glob = new Bun.Glob(`**/@vanilla-extract/integration/dist/*.js`)
+
+  // 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$/
+  const findFiles = async (dir: string, out: string[] = []): Promise<string[]> => {
+    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)
+    }
+    return out
+  }
 
   let integrationFound = false
   let definitionFound = false
   const patched: string[] = []
 
-  for await (const rel of glob.scan({ cwd: nodeModules, onlyFiles: true })) {
+  for (const file of await findFiles(nodeModules)) {
     integrationFound = true
-    const file = path.join(nodeModules, rel)
     const content = await fs.readFile(file, `utf8`)
 
     if (content.includes(PATCHED)) {
@@ -41,7 +55,7 @@ export const patchVanillaExtract = async (cwd: string): Promise<boolean> => {
 
     definitionFound = true
     await fs.writeFile(file, content.replaceAll(ORIGINAL, PATCHED))
-    patched.push(rel)
+    patched.push(path.relative(nodeModules, file))
   }
 
   if (!integrationFound) return false // VE not installed here