rvlib-shipkit 0.38.0 → 1.0.0

package/src/ts/config.ts

@@ -12,6 +12,7 @@
 // skip entries are repo-relative dir prefixes; the defaults below always apply.
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
+import { gitRoot } from '../core/git-root.ts'
 
 export type RvtPackage = {
    name: string // package.json "name" — the import root for files inside
@@ -35,78 +36,12 @@ export const ARTIFACT_SKIP = ['dist', 'build', 'cjs', 'out']
 export const DEFAULT_SKIP = [...ALWAYS_SKIP, ...ARTIFACT_SKIP]
 
 export function findRepoRoot(cwd: string = process.cwd()): string {
-   const p = Bun.spawnSync(['git', 'rev-parse', '--show-toplevel'], { cwd, stdout: 'pipe', stderr: 'ignore' })
-   const out = p.exitCode === 0 ? p.stdout.toString().trim() : ''
-   return out !== '' ? out : cwd
+   return gitRoot(cwd)?.top ?? cwd
 }
 
-// tsconfig files are JSONC: strip comments and trailing commas.
-//
-// A quote-aware scanner rather than regexes, because tsconfig is the one
-// dialect where the regex version is guaranteed to be wrong: `"src/**/*"` is
-// a `/*` with its own `*/`, so a block-comment regex eats an arbitrary span of
-// a perfectly valid file. Measured across ~/dev, the regex version THREW on 8
-// real tsconfigs (this repo's included) and silently rewrote `"src/**/*.ts"`
-// to `"src*.ts"` in 8 more. This parser gates typecheck AND publish, so it
-// does not get to be loose.
-export function parseJsonc(text: string): unknown {
-   let out = ''
-   let i = 0
-   while (i < text.length) {
-      const c = text[i]!
-      if (c === '"') {
-         out += c
-         i++
-         while (i < text.length) {
-            const s = text[i]!
-            out += s
-            i++
-            if (s === '\\') { out += text[i] ?? ''; i++; continue }
-            if (s === '"') break
-         }
-         continue
-      }
-      if (c === '/' && text[i + 1] === '/') { while (i < text.length && text[i] !== '\n') i++; continue }
-      if (c === '/' && text[i + 1] === '*') {
-         i += 2
-         while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++
-         i += 2
-         continue
-      }
-      out += c
-      i++
-   }
-   return JSON.parse(dropTrailingCommas(out))
-}
+import { parseJsonc } from './jsonc.ts'
 
-/** a comma before the next `}` or `]`, outside any string, is dropped */
-function dropTrailingCommas(text: string): string {
-   let out = ''
-   let i = 0
-   let pendingComma = -1 // index in `out` of a comma awaiting its next token
-   while (i < text.length) {
-      const c = text[i]!
-      if (c === '"') {
-         if (pendingComma >= 0) pendingComma = -1
-         out += c
-         i++
-         while (i < text.length) {
-            const s = text[i]!
-            out += s
-            i++
-            if (s === '\\') { out += text[i] ?? ''; i++; continue }
-            if (s === '"') break
-         }
-         continue
-      }
-      if (c === ',') { pendingComma = out.length; out += c; i++; continue }
-      if ((c === '}' || c === ']') && pendingComma >= 0) out = out.slice(0, pendingComma) + out.slice(pendingComma + 1)
-      if (!/\s/.test(c)) pendingComma = -1
-      out += c
-      i++
-   }
-   return out
-}
+export { parseJsonc }
 
 function rootsFromTsconfig(root: string): string[] {
    for (const name of ['tsconfig.base.json', 'tsconfig.json']) {

package/src/ts/jsonc.ts

@@ -0,0 +1,69 @@
+// tsconfig files are JSONC: strip comments and trailing commas. Its own module
+// with no disk access, so a caller that parses a tsconfig it was handed never
+// imports the loader in ts/config.ts (core/raw-access.ts).
+//
+// A quote-aware scanner rather than regexes, because tsconfig is the one
+// dialect where the regex version is guaranteed to be wrong: `"src/**/*"` is
+// a `/*` with its own `*/`, so a block-comment regex eats an arbitrary span of
+// a perfectly valid file. Measured across ~/dev, the regex version THREW on 8
+// real tsconfigs (this repo's included) and silently rewrote `"src/**/*.ts"`
+// to `"src*.ts"` in 8 more. This parser gates typecheck AND publish, so it
+// does not get to be loose.
+export function parseJsonc(text: string): unknown {
+   let out = ''
+   let i = 0
+   while (i < text.length) {
+      const c = text[i]!
+      if (c === '"') {
+         out += c
+         i++
+         while (i < text.length) {
+            const s = text[i]!
+            out += s
+            i++
+            if (s === '\\') { out += text[i] ?? ''; i++; continue }
+            if (s === '"') break
+         }
+         continue
+      }
+      if (c === '/' && text[i + 1] === '/') { while (i < text.length && text[i] !== '\n') i++; continue }
+      if (c === '/' && text[i + 1] === '*') {
+         i += 2
+         while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++
+         i += 2
+         continue
+      }
+      out += c
+      i++
+   }
+   return JSON.parse(dropTrailingCommas(out))
+}
+
+/** a comma before the next `}` or `]`, outside any string, is dropped */
+function dropTrailingCommas(text: string): string {
+   let out = ''
+   let i = 0
+   let pendingComma = -1 // index in `out` of a comma awaiting its next token
+   while (i < text.length) {
+      const c = text[i]!
+      if (c === '"') {
+         if (pendingComma >= 0) pendingComma = -1
+         out += c
+         i++
+         while (i < text.length) {
+            const s = text[i]!
+            out += s
+            i++
+            if (s === '\\') { out += text[i] ?? ''; i++; continue }
+            if (s === '"') break
+         }
+         continue
+      }
+      if (c === ',') { pendingComma = out.length; out += c; i++; continue }
+      if ((c === '}' || c === ']') && pendingComma >= 0) out = out.slice(0, pendingComma) + out.slice(pendingComma + 1)
+      if (!/\s/.test(c)) pendingComma = -1
+      out += c
+      i++
+   }
+   return out
+}

package/src/ts/lex.ts

@@ -0,0 +1,143 @@
+// a small TypeScript lexer for guards that read source as TEXT: comments
+// dropped, every string literal and template chunk pulled out as data, and the
+// code left with a `\0<index>\0` placeholder where each one stood. It is not a
+// parser. It knows the four things that make a naive regex lie: comments,
+// template `${…}` nesting, regex literals, and an apostrophe inside JSX text.
+//
+// The constraint a reader breaks first: a `/` is a regex only where an
+// expression can start, which is read off the last significant code character.
+
+export type Lexed = {
+    /** the source without comments, each literal replaced by `\0<i>\0` */
+    code: string
+    /** the literal texts, escapes resolved, a template's chunks one entry each */
+    strings: string[]
+    /** per entry of `strings`: true for a template chunk, false for a quoted literal */
+    template: boolean[]
+}
+
+const SIMPLE_ESCAPES: Record<string, string> = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', '0': '\0' }
+
+/** the escape at src[j] (the backslash): the text it stands for, and its length */
+function unescapeAt(src: string, j: number): [string, number] {
+    const c = src[j + 1] ?? ''
+    if (c in SIMPLE_ESCAPES) return [SIMPLE_ESCAPES[c]!, 2]
+    if (c === 'x' && /^[\da-f]{2}$/i.test(src.slice(j + 2, j + 4))) return [String.fromCharCode(parseInt(src.slice(j + 2, j + 4), 16)), 4]
+    if (c === 'u' && src[j + 2] === '{') {
+        const end = src.indexOf('}', j + 3)
+        const cp = parseInt(src.slice(j + 3, end), 16)
+        if (end > 0 && Number.isFinite(cp)) return [String.fromCodePoint(cp), end - j + 1]
+    }
+    if (c === 'u' && /^[\da-f]{4}$/i.test(src.slice(j + 2, j + 6))) return [String.fromCharCode(parseInt(src.slice(j + 2, j + 6), 16)), 6]
+    if (c === '\n') return ['', 2]
+    return [c, 2]
+}
+
+const REGEX_BEFORE = new Set(['', '(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';', '+', '-', '*', '%', '<', '>', '~', '^'])
+const REGEX_AFTER_WORD = /(?:^|[^\w$.])(?:return|typeof|case|do|else|in|of|void|yield|await|delete|throw|new)$/
+
+export function lexSource(src: string, o: { jsx?: boolean } = {}): Lexed {
+    const strings: string[] = []
+    const template: boolean[] = []
+    let code = ''
+    let i = 0
+    const put = (text: string, isTemplate: boolean): void => { strings.push(text); template.push(isTemplate); code += `\0${strings.length - 1}\0` }
+    const lastSignificant = (): string => { const t = code.trimEnd(); return t.at(-1) ?? '' }
+
+    /** code until the `}` closing a `${`, at brace depth 0 */
+    const codeUntilClose = (): void => {
+        let depth = 0
+        while (i < src.length) {
+            const ch = src[i]!
+            if (ch === '}' && depth === 0) { i++; return }
+            if (ch === '{') depth++
+            if (ch === '}') depth--
+            if (!step()) { code += ch; i++ }
+        }
+    }
+
+    const readTemplate = (): void => {
+        i++ // the opening backtick
+        let text = ''
+        while (i < src.length && src[i] !== '`') {
+            if (src[i] === '\\') { const [t, n] = unescapeAt(src, i); text += t; i += n; continue }
+            if (src[i] === '$' && src[i + 1] === '{') {
+                put(text, true)
+                text = ''
+                i += 2
+                code += '${'
+                codeUntilClose()
+                code += '}'
+                continue
+            }
+            text += src[i]
+            i++
+        }
+        i++ // the closing backtick
+        put(text, true)
+    }
+
+    /** one lexical element that is not plain code; false when src[i] is plain */
+    const step = (): boolean => {
+        const ch = src[i]!
+        const next = src[i + 1]
+        if (ch === '/' && next === '/') {
+            while (i < src.length && src[i] !== '\n') i++
+            return true
+        }
+        if (ch === '/' && next === '*') {
+            const end = src.indexOf('*/', i + 2)
+            i = end < 0 ? src.length : end + 2
+            return true
+        }
+        if (ch === '`') { code += '`'; readTemplate(); return true }
+        if (ch === "'" || ch === '"') {
+            // an apostrophe right after a letter is JSX text (`don't`), never a
+            // string: in code a literal never follows an identifier character
+            if (o.jsx === true && /[\p{L}\d]/u.test(src[i - 1] ?? '')) return false
+            let j = i + 1
+            let text = ''
+            while (j < src.length && src[j] !== ch && src[j] !== '\n') {
+                if (src[j] === '\\') { const [t, n] = unescapeAt(src, j); text += t; j += n; continue }
+                text += src[j]
+                j++
+            }
+            put(text, false)
+            i = j + 1
+            return true
+        }
+        if (ch === '/') {
+            const last = lastSignificant()
+            // `</tag>` and `<Tag />` are markup, never a regex
+            if (o.jsx === true && (code.endsWith('<') || next === '>')) return false
+            if (!REGEX_BEFORE.has(last) && !REGEX_AFTER_WORD.test(code.trimEnd())) return false
+            let j = i + 1
+            let inClass = false
+            while (j < src.length && src[j] !== '\n') {
+                if (src[j] === '\\') { j += 2; continue }
+                if (src[j] === '[') inClass = true
+                else if (src[j] === ']') inClass = false
+                else if (src[j] === '/' && !inClass) break
+                j++
+            }
+            j++
+            while (j < src.length && /[a-z]/.test(src[j]!)) j++
+            code += '/re/'
+            i = j
+            return true
+        }
+        return false
+    }
+
+    while (i < src.length) {
+        if (!step()) { code += src[i]; i++ }
+    }
+    return { code, strings, template }
+}
+
+/** the JSX text runs of lexed code: what sits between a tag or an `{…}`
+ *  expression and the next one. A run that reads as code (an assignment, a
+ *  statement end, a logical operator) is code between two tags, and is left out */
+export function jsxTexts(code: string): string[] {
+    return [...code.matchAll(/[>}]([^<>{}\0]*)[<{]/g)].map((m) => m[1]!).filter((t) => /\p{L}/u.test(t) && !/[=;]|&&|\|\||\breturn\b/.test(t))
+}

package/src/ts/rename.ts

@@ -1,9 +1,10 @@
-// Rename / move a file or folder AND update every exact occurrence of its
-// repo-relative path across all tracked + untracked source files.
-//
-// Assumes non-relative import paths with explicit extensions, e.g.
-//   import { X } from 'src/foo/bar.ts'
-// so the exact path string is a reliable search key.
+// Rename / move a file or folder AND update every reference to it across all
+// tracked + untracked source files: every exact occurrence of its repo-relative
+// path (or package-name path), and every RELATIVE import in a code file that
+// resolves to what moves. A relative specifier only means something from the
+// file that writes it, so each one is resolved from its importer and written
+// again from where both ends land: an importer of the moved file, and the moved
+// file's own imports of what stays behind.
 //
 // Modes:
 //   file -> file path            renames the file
@@ -13,6 +14,10 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs'
 import { basename, dirname, extname, join, relative, resolve } from 'path'
 import { canonicalSpecifier, isSkipped, loadConfig, toPosix, type RvtConfig } from 'rvlib-shipkit/src/ts/config.ts'
+import { extractSpecs } from 'rvlib-shipkit/src/ts/source-graph.ts'
+import { gitBin } from '../core/git-bin.ts'
+
+const CODE_RE = /\.[cm]?[jt]sx?$/
 
 const BINARY_EXTS = new Set([
    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.tiff',
@@ -93,9 +98,37 @@ export function runRename(srcArg: string, dstArg: string, opts: { apply?: boolea
 
    const pkgDirs = cfg.packages.map((p) => p.dir)
    // scan all tracked + untracked (non-ignored) files
-   const ls = Bun.spawnSync(['git', 'ls-files', '-co', '--exclude-standard', '-z'], { cwd: repoRoot })
+   const ls = Bun.spawnSync([gitBin(), 'ls-files', '-co', '--exclude-standard', '-z'], { cwd: repoRoot })
    const allFiles = ls.stdout.toString().split('\u0000').filter(Boolean)
 
+   const movedTo = (rel: string): string | null =>
+      rel === srcRel ? dstRel : srcIsFolder && rel.startsWith(`${srcRel}/`) ? `${dstRel}${rel.slice(srcRel.length)}` : null
+   const isFile = (rel: string): boolean => {
+      try { return statSync(join(repoRoot, rel)).isFile() } catch { return false }
+   }
+   const rewriteFile = (file: string, content: string): { text: string; count: number } => {
+      const rel = CODE_RE.test(file) ? relativeRewrites(file, content, movedTo, isFile) : new Map<string, string>()
+      if (rel.size === 0) return scanPairs(content, pairs)
+      // the relative specifiers this move retargets are set aside while the
+      // path scan runs, so the two rewrites can never compound on one string
+      let masked = content
+      let relCount = 0
+      const holes: string[] = []
+      for (const [from, to] of rel) {
+         for (const q of ["'", '"']) {
+            const parts = masked.split(`${q}${from}${q}`)
+            if (parts.length === 1) continue
+            relCount += parts.length - 1
+            masked = parts.join(`\u0000mv${holes.length}\u0000`)
+            holes.push(`${q}${to}${q}`)
+         }
+      }
+      const scanned = scanPairs(masked, pairs)
+      let text = scanned.text
+      holes.forEach((h, i) => { text = text.split(`\u0000mv${i}\u0000`).join(h) })
+      return { text, count: scanned.count + relCount }
+   }
+
    const hits: { file: string; count: number }[] = []
    let totalRefs = 0
    for (const file of allFiles) {
@@ -109,7 +142,7 @@ export function runRename(srcArg: string, dstArg: string, opts: { apply?: boolea
       }
       const nul = content.indexOf('\u0000')
       if (nul !== -1 && nul < 4096) continue // cheap binary sniff
-      const count = scanPairs(content, pairs).count
+      const count = rewriteFile(file, content).count
       if (count > 0) {
          hits.push({ file, count })
          totalRefs += count
@@ -140,12 +173,12 @@ export function runRename(srcArg: string, dstArg: string, opts: { apply?: boolea
       for (const h of hits) {
          const full = join(repoRoot, h.file)
          const before = readFileSync(full, 'utf8')
-         const after = scanPairs(before, pairs).text
+         const after = rewriteFile(h.file, before).text
          if (after !== before) writeFileSync(full, after)
       }
       const dstDir = dirname(dstAbs)
       if (!existsSync(dstDir)) mkdirSync(dstDir, { recursive: true })
-      const mv = Bun.spawnSync(['git', 'mv', srcAbs, dstAbs], { cwd: repoRoot, stdout: 'pipe', stderr: 'pipe' })
+      const mv = Bun.spawnSync([gitBin(), 'mv', srcAbs, dstAbs], { cwd: repoRoot, stdout: 'pipe', stderr: 'pipe' })
       if (mv.exitCode !== 0) renameSync(srcAbs, dstAbs) // untracked file: plain fs move
    }
 
@@ -179,6 +212,36 @@ export function renameCli(argv: string[]): number {
    return 0
 }
 
+/** the relative specifiers of one code file that this move retargets, each
+ *  mapped to the specifier that names the same file after the move, written in
+ *  the same style (explicit extension, `.js` for a `.ts` file, no extension, or
+ *  a folder's index) */
+function relativeRewrites(file: string, content: string, movedTo: (rel: string) => string | null, isFile: (rel: string) => boolean): Map<string, string> {
+   const out = new Map<string, string>()
+   const fromAfter = movedTo(file) ?? file
+   for (const spec of new Set(extractSpecs(content))) {
+      if (!spec.startsWith('./') && !spec.startsWith('../')) continue
+      const base = toPosix(join(dirname(file), spec))
+      const forms: [string, (p: string) => string][] = [
+         [base, (p) => p],
+         [base.replace(/\.js$/, '.ts'), (p) => p.replace(/\.ts$/, '.js')],
+         [`${base}.ts`, (p) => p.replace(/\.ts$/, '')],
+         [`${base}.tsx`, (p) => p.replace(/\.tsx$/, '')],
+         [`${base}/index.ts`, (p) => p.replace(/\/index\.ts$/, '')],
+         [`${base}/index.tsx`, (p) => p.replace(/\/index\.tsx$/, '')],
+      ]
+      const hit = forms.find(([candidate]) => isFile(candidate))
+      if (hit == null) continue
+      const [target, restyle] = hit
+      const targetAfter = movedTo(target) ?? target
+      if (targetAfter === target && fromAfter === file) continue
+      let next = toPosix(relative(dirname(fromAfter), restyle(targetAfter)))
+      if (!next.startsWith('../')) next = `./${next}`
+      if (next !== spec) out.set(spec, next)
+   }
+   return out
+}
+
 // simultaneous multi-needle replace: earliest match wins (longest needle on a
 // tie) and the scan continues PAST the replacement — sequential split/join
 // would let one pair's output feed the next (the package form is a substring

package/src/ts/source-graph.ts

@@ -32,7 +32,23 @@ export function crawlSources(cfg: RvtConfig, dir: string, out: string[]): void {
 // strip comments (line comments only when preceded by whitespace, so
 // 'http://...' survives) and type-only import/export statements, then extract
 // the remaining runtime specifiers
-export function extractSpecs(content: string): string[] {
+export function extractSpecs(content: string, o: { dynamic?: boolean } = {}): string[] {
+   const memo = o.dynamic === false ? staticSpecs : allSpecs
+   const hit = memo.get(content)
+   if (hit != null) return [...hit]
+   const specs = scanSpecs(content, o)
+   if (memo.size >= SPECS_MEMO_MAX) memo.clear()
+   memo.set(content, specs)
+   return [...specs]
+}
+
+/** extractSpecs is a pure function of the text, and every gate asks it of the
+ *  same check closures again, so the answer is remembered per text */
+const allSpecs = new Map<string, string[]>()
+const staticSpecs = new Map<string, string[]>()
+const SPECS_MEMO_MAX = 4000
+
+function scanSpecs(content: string, o: { dynamic?: boolean }): string[] {
    // template-literal content is text, a codegen emitting import lines inside
    // a backtick block is not an import of this module. single-line templates
    // strip in place, multiline ones blank via the shared mask (null mask =
@@ -40,9 +56,11 @@ export function extractSpecs(content: string): string[] {
    const rawLines = content.split('\n')
    const mask = templateLineMask(rawLines)
    const demasked = mask == null ? content : rawLines.map((l, i) => (mask[i] ? '' : l)).join('\n')
+   // ONE left to right pass over both comment shapes: whichever opens first
+   // owns the text, so a `/*` inside a line comment ("src/*") never starts a
+   // block comment that swallows the imports below it
    const cleaned = demasked
-      .replace(/\/\*[\s\S]*?\*\//g, '')
-      .replace(/(^|\s)\/\/[^\n]*/g, '$1')
+      .replace(/\/\*[\s\S]*?\*\/|(^|\s)\/\/[^\n]*/g, (m, lead: string | undefined) => (m.startsWith('/*') ? '' : lead ?? ''))
       .replace(/`(?:\\.|[^`\\\n])*`/g, '``')
       .replace(/\b(?:import|export)\s+type\s[^'"]*?from\s*(['"])[^'"\n]*\1/g, '')
    const specs: string[] = []
@@ -57,7 +75,9 @@ export function extractSpecs(content: string): string[] {
    }
    for (const re of [
       /\bimport\s*['"]([^'"\n]+)['"]/g, // side-effect import
-      /\b(?:import|require)\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g, // dynamic import / require
+      // dynamic import / require. `dynamic: false` leaves them out: what a
+      // module's LOAD runs, not what a function it exports may run later
+      ...(o.dynamic === false ? [] : [/\b(?:import|require)\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g]),
    ]) {
       for (const m of cleaned.matchAll(re)) {
          if (m[1] != null) specs.push(m[1])
@@ -120,13 +140,13 @@ export function buildSourceGraph(cfg: RvtConfig = loadConfig()): SourceGraph {
  * the transitive import closure of `entries`, entries included, WITHOUT
  * crawling the repo: files are read only as the walk reaches them.
  *
- * This is what puts a unit's own code in its cache key. A check that imports a
+ * This is what puts a check's own code in its cache key. A check that imports a
  * shared helper carries that helper's identity, so fixing the helper moves the
  * check's key. An entry that does not exist is dropped: the caller already
- * knows a missing declared path makes a unit uncacheable, and a throw here
+ * knows a missing declared path makes a check uncacheable, and a throw here
  * would turn a stale declaration into a dead gate.
  */
-export function importClosure(cfg: RvtConfig, entries: string[]): string[] {
+export function importClosure(cfg: RvtConfig, entries: string[], o: { dynamic?: boolean } = {}): string[] {
    const probe = new Map<string, boolean>()
    const has = (p: string): boolean => {
       let r = probe.get(p)
@@ -147,7 +167,7 @@ export function importClosure(cfg: RvtConfig, entries: string[]): string[] {
       } catch {
          continue
       }
-      for (const spec of extractSpecs(content)) {
+      for (const spec of extractSpecs(content, o)) {
          const target = resolveSpec(cfg, file, spec, has)
          if (target == null || seen.has(target)) continue
          seen.add(target)

package/src/ts/tsconfig-projects.ts

@@ -1,101 +1,10 @@
-// which tsconfig files a typecheck must actually visit.
-//
-// `tsc --noEmit -p <solution>` on a solution-style config (`files: []` plus
-// `references`) compiles ZERO files and exits 0. The gate then prints
-// `ok: typecheck` while a type error sits in src, which is the single worst
-// output this repo can produce: an unmeasured green nobody can tell from a
-// measured one. tsc will not warn about it, so the caller has to resolve the
-// leaves itself and refuse when there are none.
-import { existsSync, readFileSync, statSync } from 'fs'
-import { dirname, isAbsolute, join, resolve } from 'path'
-import { parseJsonc } from 'rvlib-shipkit/src/ts/config.ts'
+// which tsconfig files a typecheck must actually visit, read from the disk.
+// ts/tsconfig-resolve.ts owns the resolution and why it exists.
+import { fsUnitReader } from '../release/units.ts'
+import { resolveTypecheckProjects as resolveWith, type TypecheckProjects } from './tsconfig-resolve.ts'
 
-export type TypecheckProjects = {
-    /** absolute paths, in declaration order, of the configs that compile files */
-    projects: string[]
-    /** nothing would be compiled: the check would pass without checking */
-    vacuous: boolean
-    /** references pointing at a path that does not exist, verbatim as declared */
-    missing: string[]
-}
-
-type RawConfig = {
-    files?: unknown
-    include?: unknown
-    references?: { path?: unknown }[]
-}
+export type { TypecheckProjects } from './tsconfig-resolve.ts'
 
-/** a reference may name a directory, a config file, or a dir with no config */
-function configPathFor(base: string, declared: string): string | null {
-    const p = isAbsolute(declared) ? declared : resolve(base, declared)
-    if (!existsSync(p)) return null
-    try { if (statSync(p).isDirectory()) return existsSync(join(p, 'tsconfig.json')) ? join(p, 'tsconfig.json') : null }
-    catch { return null }
-    return p
-}
-
-/**
- * whether tsc would compile anything for THIS config, ignoring its references.
- *
- * tsc's rule, and every branch here is a shape found in the field:
- * - `files` non-empty, or `include` non-empty: compiles those
- * - neither key present: the default `include` is `**\/*`, so it compiles the
- *   whole directory tree, which is why a bare `{ references: [...] }` is NOT
- *   a solution config
- * - `files: []` with no `include`: the solution-style marker, compiles nothing
- * - `include: []`: compiles nothing whatever `files` says, unless `files` lists
- *   something
- */
-function compilesOwnFiles(cfg: RawConfig): boolean {
-    const files = Array.isArray(cfg.files) ? cfg.files : null
-    const include = Array.isArray(cfg.include) ? cfg.include : null
-    if (files != null && files.length > 0) return true
-    if (include != null) return include.length > 0
-    return files == null
-}
-
-function read(path: string): RawConfig {
-    let text: string
-    try { text = readFileSync(path, 'utf8') }
-    catch (e) { throw new Error(`tsconfig unreadable at ${path}: ${String(e).slice(0, 120)}`) }
-    try { return (parseJsonc(text) ?? {}) as RawConfig }
-    catch (e) { throw new Error(`tsconfig unparseable at ${path}: ${String(e).slice(0, 120)}`) }
-}
-
-/**
- * Walk `references` to the leaves. A leaf that declares `files: []` with no
- * `include` compiles nothing and is dropped, so a solution whose every leaf is
- * empty comes back `vacuous` rather than as a command that passes for free.
- */
 export function resolveTypecheckProjects(tsconfigPath: string): TypecheckProjects {
-    const start = resolve(tsconfigPath)
-    const projects: string[] = []
-    const missing: string[] = []
-    // a reference loop is legal to WRITE and would otherwise recurse forever
-    const seen = new Set<string>()
-
-    const visit = (path: string): void => {
-        if (seen.has(path)) return
-        seen.add(path)
-        const cfg = read(path)
-        // references are checked FIRST so the list reads dependencies before
-        // dependents, the order `tsc -b` would build in
-        for (const r of Array.isArray(cfg.references) ? cfg.references : []) {
-            const declared = typeof r?.path === 'string' ? r.path : null
-            if (declared == null) continue
-            const next = configPathFor(dirname(path), declared)
-            if (next == null) missing.push(declared)
-            else visit(next)
-        }
-        // `references` does NOT suppress a config's own inputs: only an empty
-        // `files` with no `include` does, and that is what makes a config
-        // solution-style. Skipping a referencing config outright is how the
-        // first version of this file reintroduced the false green it exists to
-        // kill, on `{ include: ['src'], references: [...] }`, which is the
-        // ordinary monorepo package shape
-        if (compilesOwnFiles(cfg)) projects.push(path)
-    }
-
-    visit(start)
-    return { projects, vacuous: projects.length === 0, missing }
+    return resolveWith(tsconfigPath, fsUnitReader('/'), '/')
 }