@exodus/stasis 1.0.0-beta.5 → 1.0.0-beta.7

package/src/scan.js

@@ -1,36 +1,34 @@
-import { extname, resolve as resolvePath, relative } from 'node:path'
+import { dirname, extname, resolve as resolvePath, relative } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { createRequire, isBuiltin } from 'node:module'
 import assert from 'node:assert/strict'
 import { packageType } from '@exodus/stasis-core/bundle-util'
-import { classifyExtension, classifyFormat, relativeEscapes } from '@exodus/stasis-core/util'
-import { resolveTypescriptFallback } from './resolve-typescript.js'
+import { classifyExtension, classifyFormat, isTypeDeclaration, relativeEscapes } from '@exodus/stasis-core/util'
+import { inNodeModules, resolveTypescriptFallback, typescriptSiblings } from './resolve-typescript.js'
 import { diskHost } from '@exodus/stasis-core/host'
 
 // Static require/import graph walker: parses source, never loads or executes user code.
 // Dynamic specifiers (`require(name)`, `import('./'+x)`) are recorded as unresolved.
 
-const SCRIPT_EXTS = new Set(['.js', '.cjs', '.mjs', '.ts', '.cts', '.mts'])
+// .jsx/.tsx need no flag: oxc parses them as JSX/TSX purely from the filename, so a reached one
+// -- e.g. a package whose React Native entry is src/index.tsx -- is parsed and carried like any .ts.
+const SCRIPT_EXTS = new Set(['.js', '.cjs', '.mjs', '.ts', '.cts', '.mts', '.jsx', '.tsx'])
 const RESOLVABLE_EXTS = new Set([...SCRIPT_EXTS, '.json'])
-// Under `jsx`, these get parsed with JSX enabled. Excludes the .ts family: TypeScript's `<T>`
+// The extensions whose name can't tell whether they hold JSX, parsed with JSX enabled only under
+// `jsx` (React Native's JSX-in-.js convention). Excludes the .ts family: TypeScript's `<T>`
 // generics collide with JSX, so tsc/oxc reserve JSX for .tsx — JSX-in-TS belongs in a .tsx file.
 const JSX_EXTS = new Set(['.js', '.cjs', '.mjs'])
-// The inherently-JSX extensions (oxc parses them as JSX/TSX purely from the filename, no flag).
-// Scanned + carried only under `--jsx`: off by default the scanner treats them as opaque leaves,
-// so a bundle whose toolchain can't build JSX never silently ships .jsx/.tsx source. Under `--jsx`
-// they join SCRIPT_EXTS/RESOLVABLE_EXTS (see the constructor) so a reached .jsx/.tsx dependency
-// — e.g. a package whose React Native entry is src/index.tsx — is parsed and carried like any .ts.
-const JSX_FILE_EXTS = new Set(['.jsx', '.tsx'])
 
 // Flow type syntax lives in the JS (non-TS) family; oxc parses TS natively, and running
 // flow-remove-types over a .ts/.tsx file would corrupt TS-only constructs, so --flow only strips
 // these. .jsx is included (it's JS + JSX, and can carry Flow types like .js); .tsx is not (it's
 // TypeScript). flow-remove-types preserves JSX, so a stripped .jsx re-parses under lang:jsx.
 const FLOW_EXTS = new Set(['.js', '.cjs', '.mjs', '.jsx'])
+const TS_EXTS = new Set(['.ts', '.cts', '.mts', '.tsx'])
 
 // Required lazily so non-JS bundlers don't load the native oxc parser.
 let _parser
-function getParser() {
+export function getParser() {
   _parser ??= createRequire(import.meta.url)('oxc-parser')
   return _parser
 }
@@ -63,7 +61,10 @@ function formatForFile(file, host) {
   return `${type}${extname(file) === '.ts' ? '-typescript' : ''}`
 }
 
-function literalSpec(node) {
+// The errors oxc reports for a parse, but its warnings and advice.
+export const syntaxErrors = (parsed) => (parsed.errors ?? []).filter((e) => e.severity !== 'Warning' && e.severity !== 'Advice')
+
+export function literalSpec(node) {
   if (!node) return null
   if (node.type === 'Literal' && typeof node.value === 'string') return node.value
   if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
@@ -111,6 +112,67 @@ function findCallSpecifiers(ast, push) {
   visit(ast)
 }
 
+// The import specifiers `program` holds, as { kind, spec } ({ kind, dynamic: true } for a computed
+// one). STATEMENT-level type-ness decides an edge, matching what survives type erasure at runtime
+// (verbatimModuleSyntax / Node's own type stripping): an `import type` / `export type` statement is
+// erased whole, so no edge; a statement that merely lists inline `type` specifiers
+// (`import { type A }`, `export { type B } from`) -- or none at all (`import {}`, `export {} from`)
+// -- still loads its module, so its edge is real. oxc's module records can't draw that line
+// (`import type { A }` and `import { type A }` yield identical all-isType entries, and
+// `export {} from` yields no entry at all), so the statements are read off the AST, where
+// importKind/exportKind carry it.
+function collectSpecifiers(program) {
+  const specs = []
+  for (const node of program.body) {
+    if (node.type === 'ImportDeclaration') {
+      if (node.importKind !== 'type') specs.push({ kind: 'import', spec: node.source.value })
+    } else if (node.type === 'ExportNamedDeclaration') {
+      if (node.source != null && node.exportKind !== 'type') specs.push({ kind: 'export-from', spec: node.source.value })
+    } else if (node.type === 'ExportAllDeclaration') {
+      if (node.exportKind !== 'type') specs.push({ kind: 'export-from', spec: node.source.value })
+    }
+  }
+  findCallSpecifiers(program, (s) => specs.push(s))
+  return specs
+}
+
+// Whether `entries` (absolute paths) import TS sources by their OUTPUT names -- tsc's convention,
+// which only --typescript resolves -- so the build can take --typescript as given: every entry is
+// TypeScript, they hold at least one relative import naming a JS output (`./a.js`, or .jsx/.mjs/
+// .cjs), and not one of those is on disk while the TS source it maps to is (`./a.ts`; see
+// typescriptSiblings), outside node_modules as the resolver requires. Any part missing is no tell, and neither is an entry that doesn't parse as
+// the scan parses it (Scan#parseFile; the scan reports it), nor one in node_modules, where
+// --typescript maps nothing. Read off the entries alone, before the scan.
+export function importsTypescriptByOutputName(entries, host = diskHost) {
+  if (!entries.every((entry) => TS_EXTS.has(extname(entry)) && !inNodeModules(entry, host))) return false
+  // Outside the try, as in the scan: a missing oxc-parser is an env error, not an entry's.
+  getParser()
+  const scanner = new Scan({ host })
+  const targets = []
+  for (const entry of entries) {
+    let result
+    try {
+      result = scanner.parseFile(entry)
+    } catch {
+      return false // unreadable: the scan reports it
+    }
+    if (result.crash !== undefined || result.errors.length > 0) return false
+    for (const { spec } of collectSpecifiers(result.parsed.program)) {
+      if (spec?.startsWith('./') || spec?.startsWith('../')) {
+        const target = resolvePath(dirname(entry), spec)
+        if (typescriptSiblings(target).length > 0) targets.push(target)
+      }
+    }
+  }
+  // tsc's pick, the first TS source on disk, as the resolver maps it: none where it lies in node_modules.
+  const isSource = (file) => !isTypeDeclaration(file) && (host.stat(file)?.isFile() ?? false)
+  const mapsTo = (target) => {
+    const pick = typescriptSiblings(target).find(isSource)
+    return pick !== undefined && !inNodeModules(pick, host)
+  }
+  return targets.length > 0 && targets.every((target) => host.stat(target) === null && mapsTo(target))
+}
+
 function condKey(set) {
   return [...set].join(', ')
 }
@@ -129,25 +191,25 @@ export class Scan {
   // off by default because oxc, like tsc, only auto-enables JSX for .jsx/.tsx by extension.
   // `flow`: strip Flow type syntax from JS-family sources before parsing (see #scanFile).
   // `typescript`: retry a failed resolution with tsc's mapping (see #typescriptResolve), with
-  // `typescriptPaths` (a loadTsconfigPaths matcher) adding tsconfig alias support; only consulted
-  // on the built-in (Node) resolver -- a custom `resolve` owns its own TS handling.
+  // `typescriptPaths` (a tsconfig paths matcher; see resolveTypescriptFallback) adding tsconfig alias support; only consulted
+  // on the built-in (Node) resolver -- a custom `resolve` owns its own TS handling. Without it, the
+  // mapping only names the file a miss would resolve to under --typescript (see #typescriptCandidate).
+  // `typescriptResolve`: the custom `resolve`'s --typescript twin (same shape), consulted only for
+  // that hint; null when there is no custom resolver or `typescript` is on.
   // `resources` (a `parseResourcesOption` Set of extensions/filenames): reached files matching it
   // are carried as opaque resources (bytes only) rather than rejected as un-carryable -- for graphs
   // that aren't fully loadable in JS (e.g. Metro consuming .png/.svg assets).
   // `host`: the filesystem the walk reads and resolves through (@exodus/stasis-core/host).
-  constructor({ conditions = [], resolve = null, jsx = false, flow = false, typescript = false, typescriptPaths = null, resources = new Set(), host = diskHost } = {}) {
+  constructor({ conditions = [], resolve = null, jsx = false, flow = false, typescript = false, typescriptPaths = null, typescriptResolve = null, resources = new Set(), host = diskHost } = {}) {
     this.extraConditions = [...conditions]
     this.customResolve = resolve
+    this.typescriptResolve = typescriptResolve
     this.jsx = jsx
     this.flow = flow
     this.typescript = typescript
     this.typescriptPaths = typescriptPaths
     this.resources = resources
     this.host = host
-    // --jsx widens the script/resolvable extension sets to include .jsx/.tsx, so those files are
-    // parsed (not left as opaque leaves) and queued when reached. Off by default the base sets apply.
-    this.scriptExts = jsx ? new Set([...SCRIPT_EXTS, ...JSX_FILE_EXTS]) : SCRIPT_EXTS
-    this.resolvableExts = jsx ? new Set([...RESOLVABLE_EXTS, ...JSX_FILE_EXTS]) : RESOLVABLE_EXTS
   }
 
   // A reached file whose extension/filename is in the --resources allowlist: carried as an opaque
@@ -201,7 +263,6 @@ export class Scan {
   #typescriptResolve(parentFile, spec, conditions) {
     const hit = resolveTypescriptFallback(parentFile, spec, {
       conditions,
-      tsx: this.jsx,
       paths: this.typescriptPaths,
       host: this.host,
     })
@@ -213,6 +274,16 @@ export class Scan {
     }
   }
 
+  // The file: URL a miss would resolve to under --typescript, or null: a hint for the unresolved
+  // report only, never an edge. A custom resolver asks its --typescript twin; the built-in one
+  // tsc's mapping, as #typescriptResolve gives it under --typescript.
+  #typescriptCandidate(parentFile, spec, conditions) {
+    if (this.typescript) return null
+    if (this.customResolve) return this.typescriptResolve?.(parentFile, spec, conditions)?.url ?? null
+    const hit = this.#typescriptResolve(parentFile, spec, conditions)
+    return hit == null ? null : pathToFileURL(hit).toString()
+  }
+
   // Strip Flow type syntax to plain JS via the optional flow-remove-types dep (resolved lazily; a
   // missing dep is an env error and propagates). Only invoked as a parse fallback (see #scanFile),
   // so plain-JS files never reach it. Returns the rewritten source, or null when the transform
@@ -229,25 +300,12 @@ export class Scan {
     }
   }
 
-  #scanFile(url, queue) {
-    const file = fileURLToPath(url)
+  // Parse `file` (a script extension) as Node loads it: under the format its name and package
+  // declare, or for a typeless .js/.ts the one Node detects from its syntax. -> { format, parsed,
+  // errors } (`errors`: what the parse still reports), or { declared, crash } where the parser
+  // itself threw on the file, salvaging nothing.
+  parseFile(file) {
     const ext = extname(file)
-    if (ext === '.json') {
-      this.files.set(url, { format: 'json', edges: [] })
-      return
-    }
-    if (this.#isResource(file)) {
-      // Allowlisted asset: carry it as a resource with no parse and no edges. `resource: true` is
-      // the authoritative signal (both bundle builders key off it); the concrete format
-      // (resource vs resource:base64) is byte-derived by the builder, so leave it unset here.
-      this.files.set(url, { format: null, edges: [], resource: true })
-      return
-    }
-    if (!this.scriptExts.has(ext)) {
-      this.files.set(url, { format: null, edges: [] })
-      return
-    }
-
     // declared === null: typeless package; Node decides .js/.ts by syntax, resolved after parse.
     const declared = formatForFile(file, this.host)
     const src = this.host.readFile(file).toString('utf8')
@@ -259,14 +317,15 @@ export class Scan {
     // force the JSX variant when opted in (`--jsx`) to parse React Native's JSX-in-.js source.
     const lang = this.jsx && JSX_EXTS.has(ext) ? 'jsx' : undefined
     const parseOptions = (sourceType) => (lang ? { sourceType, lang } : { sourceType })
+    // `commonjs`, not `script`: Node runs CJS inside its module wrapper function, where a top-level
+    // `return` or `new.target` is legal; oxc's `commonjs` accepts both and is otherwise `script`.
     const baseSourceType = declared === null ? 'unambiguous'
-      : declared.startsWith('module') ? 'module' : 'script'
+      : declared.startsWith('module') ? 'module' : 'commonjs'
     let parsed
     try {
       parsed = parser.parseSync(file, src, parseOptions(baseSourceType))
     } catch (cause) {
-      this.#recordParseError(url, declared, cause.message, false)
-      return
+      return { declared, crash: cause.message }
     }
 
     // Match Node's syntax detection for typeless packages: ESM syntax picks the module variant
@@ -280,15 +339,15 @@ export class Scan {
 
     // oxc recovers from syntax errors (reports them in parsed.errors) rather than throwing;
     // Warning/Advice severities aren't real parse errors.
-    const nonWarning = (p) => (p.errors ?? []).filter((e) => e.severity !== 'Warning' && e.severity !== 'Advice')
-    let errors = nonWarning(parsed)
+    let errors = syntaxErrors(parsed)
 
-    // oxc's hasModuleSyntax misses top-level await, so a TLA-only ESM file parses here as a
-    // broken script; mirror Node by retrying as module and preferring a clean module parse.
+    // oxc's `unambiguous` mode counts top-level await as module syntax (since 0.109; before, a
+    // TLA-only ESM file parsed here as a broken script). Keep mirroring Node for any script parse
+    // that still fails: retry as module and prefer a clean module parse.
     if (errors.length > 0 && declared === null && !format.startsWith('module')) {
       try {
         const asModule = parser.parseSync(file, src, parseOptions('module'))
-        if (nonWarning(asModule).length === 0) {
+        if (syntaxErrors(asModule).length === 0) {
           parsed = asModule
           format = `module${tsSuffix}`
           errors = []
@@ -296,6 +355,19 @@ export class Scan {
       } catch { /* keep the script parse and its recorded errors */ }
     }
 
+    // A typeless file Node detects as CJS runs inside the module wrapper too, but `unambiguous`
+    // parses it as a plain script, so a top-level `return` still fails there: retry as `commonjs`
+    // and prefer a clean parse (the detected commonjs format stands).
+    if (errors.length > 0 && declared === null && !format.startsWith('module')) {
+      try {
+        const asCommonjs = parser.parseSync(file, src, parseOptions('commonjs'))
+        if (syntaxErrors(asCommonjs).length === 0) {
+          parsed = asCommonjs
+          errors = []
+        }
+      } catch { /* keep the script parse and its recorded errors */ }
+    }
+
     // --flow: oxc parses JS/TS but not Flow, so a Flow-typed .js/.cjs/.mjs file lands here with
     // parse errors. Only now -- after a raw oxc parse actually failed -- strip Flow types and
     // re-parse, so plain-JS files never pay the transform cost. Only the parse input is rewritten;
@@ -307,7 +379,7 @@ export class Scan {
       if (flowSrc !== null) {
         try {
           const asFlow = parser.parseSync(file, flowSrc, parseOptions(baseSourceType))
-          if (nonWarning(asFlow).length === 0) {
+          if (syntaxErrors(asFlow).length === 0) {
             parsed = asFlow
             format = declared ?? detectedFormat(parsed)
             errors = []
@@ -316,6 +388,35 @@ export class Scan {
       }
     }
 
+    return { format, parsed, errors }
+  }
+
+  #scanFile(url, queue) {
+    const file = fileURLToPath(url)
+    const ext = extname(file)
+    if (ext === '.json') {
+      this.files.set(url, { format: 'json', edges: [] })
+      return
+    }
+    if (this.#isResource(file)) {
+      // Allowlisted asset: carry it as a resource with no parse and no edges. `resource: true` is
+      // the authoritative signal (both bundle builders key off it); the concrete format
+      // (resource vs resource:base64) is byte-derived by the builder, so leave it unset here.
+      this.files.set(url, { format: null, edges: [], resource: true })
+      return
+    }
+    if (!SCRIPT_EXTS.has(ext)) {
+      this.files.set(url, { format: null, edges: [] })
+      return
+    }
+
+    const result = this.parseFile(file)
+    if (result.crash !== undefined) {
+      this.#recordParseError(url, result.declared, result.crash, false)
+      return
+    }
+    const { format, parsed, errors } = result
+
     let parseError
     if (errors.length > 0) {
       parseError = errors.map((e) => e.message).join('; ')
@@ -328,25 +429,7 @@ export class Scan {
       this.parseErrors.push({ url, format, message: parseError, recovered: true })
     }
 
-    const specs = []
-    // STATEMENT-level type-ness decides an edge, matching what survives type erasure at runtime
-    // (verbatimModuleSyntax / Node's own type stripping): an `import type` / `export type`
-    // statement is erased whole, so no edge; a statement that merely lists inline `type`
-    // specifiers (`import { type A }`, `export { type B } from`) -- or none at all (`import {}`,
-    // `export {} from`) -- still loads its module, so its edge is real. oxc's module records
-    // can't draw that line (`import type { A }` and `import { type A }` yield identical
-    // all-isType entries, and `export {} from` yields no entry at all), so the statements are
-    // read off the AST, where importKind/exportKind carry it.
-    for (const node of parsed.program.body) {
-      if (node.type === 'ImportDeclaration') {
-        if (node.importKind !== 'type') specs.push({ kind: 'import', spec: node.source.value })
-      } else if (node.type === 'ExportNamedDeclaration') {
-        if (node.source != null && node.exportKind !== 'type') specs.push({ kind: 'export-from', spec: node.source.value })
-      } else if (node.type === 'ExportAllDeclaration') {
-        if (node.exportKind !== 'type') specs.push({ kind: 'export-from', spec: node.source.value })
-      }
-    }
-    findCallSpecifiers(parsed.program, (s) => specs.push(s))
+    const specs = collectSpecifiers(parsed.program)
 
     // The edge KIND picks the resolution context, not the parent's format: createRequire()d
     // require() inside ESM resolves under REQUIRE conditions, literal import() inside CJS under
@@ -359,11 +442,13 @@ export class Scan {
       edges.push({ ...s, child: childURL })
       if (!specMaps.has(key)) specMaps.set(key, new Map())
       specMaps.get(key).set(s.spec, childURL)
-      if (this.resolvableExts.has(extname(childPath)) || this.#isResource(childPath)) queue.push(childURL)
+      if (RESOLVABLE_EXTS.has(extname(childPath)) || this.#isResource(childPath)) queue.push(childURL)
     }
-    const addUnresolved = (s, reason) => {
+    // Records the file --typescript would land the miss on too (typescriptURL), resolved as the miss was.
+    const addUnresolved = (s, reason, conditions) => {
       edges.push({ ...s, error: reason })
-      this.unresolved.push({ parentURL: url, kind: s.kind, spec: s.spec, reason })
+      const typescriptURL = this.#typescriptCandidate(file, s.spec, conditions)
+      this.unresolved.push({ parentURL: url, kind: s.kind, spec: s.spec, reason, ...(typescriptURL ? { typescriptURL } : {}) })
     }
 
     for (const s of specs) {
@@ -386,7 +471,7 @@ export class Scan {
         } else if (r?.url) {
           addChild(s, key, r.url, fileURLToPath(r.url))
         } else {
-          addUnresolved(s, 'MODULE_NOT_FOUND')
+          addUnresolved(s, 'MODULE_NOT_FOUND', conditions)
         }
         continue
       }
@@ -402,7 +487,7 @@ export class Scan {
         // stays keyed by the ORIGINAL specifier -- only the target is the mapped file.
         if (this.typescript) childPath = this.#typescriptResolve(file, s.spec, conditions)
         if (childPath == null) {
-          addUnresolved(s, cause.code ?? cause.message)
+          addUnresolved(s, cause.code ?? cause.message, conditions)
           continue
         }
       }
@@ -440,7 +525,7 @@ export class Scan {
           ),
         ])
       ),
-      unresolved: this.unresolved.map(({ parentURL, ...rest }) => ({ parent: rel(parentURL), ...rest })),
+      unresolved: this.unresolved.map(({ parentURL, typescriptURL, ...rest }) => ({ parent: rel(parentURL), ...rest, ...(typescriptURL ? { typescript: rel(typescriptURL) } : {}) })),
       parseErrors: this.parseErrors.map(({ url, ...rest }) => ({ file: rel(url), ...rest })),
     }
   }

package/src/vfs-bundle/entries.js

@@ -9,7 +9,7 @@ import { foundrySourceDir } from '../loaders/foundry.js'
 import { resolveTypescriptFallback, typescriptExportsTarget } from '../resolve-typescript.js'
 import { checkKind, checkVersion, packageManagerOf, vfsHost } from './tree.js'
 
-const JS = /\.[cm]?[jt]s$/u
+const JS = /\.(?:[cm]?[jt]s|[jt]sx)$/u
 // Node's own conditions for require() and for import, which the build's are added to.
 const NODE_CONDITIONS = [['require', 'node', 'node-addons', 'module-sync'], ['import', 'node', 'node-addons', 'module-sync']]
 
@@ -21,7 +21,7 @@ const NODE_CONDITIONS = [['require', 'node', 'node-addons', 'module-sync'], ['im
 // fields, else index); each subpath `exports` holds (but a pattern), as the package's name resolves
 // for require() and for import, with the conditions the build adds (the RN ones under `metro`); and
 // each `bin`. Only JS files in `dir` that are there, named from within it; none without a package.json.
-function packageEntries(host, dir, { conditions = [], mainFields, metro = false, platforms = [], jsx = false, typescript = false } = {}) {
+function packageEntries(host, dir, { conditions = [], mainFields, metro = false, platforms = [], typescript = false } = {}) {
   const real = host.realpath(dir)
   const manifest = join(real, 'package.json')
   const pkg = readJson(manifest, host)
@@ -32,7 +32,7 @@ function packageEntries(host, dir, { conditions = [], mainFields, metro = false,
     if (rel !== '' && !relativeEscapes(rel) && JS.test(rel)) found.add(rel)
   }
   const passes = metro || mainFields !== undefined
-    ? (metro ? platforms : [null]).map((platform) => fieldResolverFor(platform, { mainFields, metro, conditions, jsx, typescript, host }))
+    ? (metro ? platforms : [null]).map((platform) => fieldResolverFor(platform, { mainFields, metro, conditions, typescript, host }))
     : [{ extras: conditions, mainFields: ['main'] }]
   // Node's resolution of `specifier`, else under `typescript` the miss `mapped` as tsc maps it; a
   // real path either way, or undefined.
@@ -49,7 +49,7 @@ function packageEntries(host, dir, { conditions = [], mainFields, metro = false,
     const entry = fields.map((name) => pkg[name]).find((value) => typeof value === 'string' && value !== '')
     if (entry !== undefined && posixPathEscapes(entry)) continue
     if (resolver === undefined) {
-      add(viaNode('./', NODE_CONDITIONS[0], extras, (set) => resolveTypescriptFallback(manifest, './', { conditions: set, tsx: jsx, host })))
+      add(viaNode('./', NODE_CONDITIONS[0], extras, (set) => resolveTypescriptFallback(manifest, './', { conditions: set, host })))
     } else {
       // A real path, as Node's resolution gives and the scan takes.
       const hit = resolver(manifest, './')
@@ -63,7 +63,7 @@ function packageEntries(host, dir, { conditions = [], mainFields, metro = false,
     if (!subpath.startsWith('.') || subpath.includes('*') || subpath.endsWith('/')) continue
     const specifier = subpath === '.' ? name : `${name}${subpath.slice(1)}`
     for (const { extras } of passes) {
-      for (const names of NODE_CONDITIONS) add(viaNode(specifier, names, extras, (set) => typescriptExportsTarget(real, exports, subpath, { conditions: set, tsx: jsx, host })))
+      for (const names of NODE_CONDITIONS) add(viaNode(specifier, names, extras, (set) => typescriptExportsTarget(real, exports, subpath, { conditions: set, host })))
     }
   }
   const bins = typeof pkg.bin === 'string' ? [pkg.bin] : pkg.bin !== null && typeof pkg.bin === 'object' ? Object.values(pkg.bin) : []

package/src/vfs-bundle/github.js

@@ -8,7 +8,7 @@ import { createClient } from '@preventive/upstream/github.js'
 import { vfsFromEntries } from '@preventive/vfs'
 import { buildVfsBundle } from '../cmd/bundle.js'
 import { KINDS, checkAhead } from './entries.js'
-import { checkTarget, detectPackageManager, installedAlone, lockfileOf, lockfileRoot, lockfilesListed, noLockfile, packageManagerOf, vfsHost } from './tree.js'
+import { checkTarget, detectPackageManager, installedAlone, lockfileOf, lockfilesListed, noLockfile, packageManagerOf, vfsHost } from './tree.js'
 
 // As upstream's tree verification bounds a tarball's unpacked size.
 const MAX_TAR_BYTES = 2 ** 30
@@ -166,23 +166,29 @@ async function repoTree(name, { github, sha, tag, directory, client, packageMana
 // A GitHub repo at a full commit, or the one `tag` names, the default branch's head without either,
 // as buildVfsBundle builds it: `directory` downloaded alone where it stands alone, else the whole
 // repo, and without a `packageManager`, the one whose lockfile installs it, where only one's does
-// (repoTree). Without `entries`, they are the ones suggestedEntries suggests. `repo` names the
-// commit and where the lockfile is, which the bundle's paths are relative to. Nothing is read from
-// disk: the tree's bytes come from GitHub, or from the cache setCacheDir names, held to the git tree
-// id either way (@preventive/upstream), and are unpacked into a Vfs that buildVfsBundle reads alone.
+// (repoTree). Without `entries`, they are the ones suggestedEntries suggests. The bundle's paths are
+// relative to `directory`, or for a JS bundle, to the innermost package directory at or above it
+// holding every file it bundles (buildJsBundle's innermostRoot), which is the project's root where
+// one is outside the others; `repo` names that directory and the commit. Nothing is read from disk:
+// the tree's bytes come from GitHub, or from the cache setCacheDir names, held to the git tree id
+// either way (@preventive/upstream), and are unpacked into a Vfs that buildVfsBundle reads alone.
 export async function buildGitHubBundle({ github, sha, tag, directory, client, packageManager, ...options } = {}) {
   checkTarget('buildGitHubBundle', options)
+  // Its own, for a Soldeer git dependency too.
+  client ??= createClient({ token: null })
   const tree = await repoTree('buildGitHubBundle', { github, sha, tag, directory, client, packageManager }, options)
-  const root = lockfileRoot(tree.host, tree.packageManager, tree.cwd, options.os)
-  const at = tree.subtree ? posix.join(directory, (root ?? '/').slice(1)) : (root ?? '/').slice(1)
-  const location = at === '' ? { root: true } : isValidRepoField('directory', at) ? { directory: at } : {}
   let { entries } = options
   if (entries === undefined) {
     // As suggestedEntries suggests them, from the tree at hand.
     entries = tree.kind.entries(tree.host, tree.cwd, options)
     if (entries.length === 0) throw new Error(`${tree.where}: no entries given, and ${directory || 'the repo root'} ${tree.kind.none}`)
   }
-  return buildVfsBundle({ ...options, entries, packageManager: tree.packageManager, vfs: tree.vfs, cwd: tree.cwd, repo: { github, commit: tree.sha, ...location } })
+  const repo = { github, commit: tree.sha }
+  const built = await buildVfsBundle({ ...options, entries, packageManager: tree.packageManager, vfs: tree.vfs, cwd: tree.cwd, innermostRoot: true, repo, client })
+  // The Vfs is the repo's tree, or the subtree at `directory`: a layout known, so its root is `''`.
+  const at = posix.join(tree.subtree ? directory : '.', posix.relative('/', built.root)).replace(/^\.$/u, '')
+  built.bundle.repo = { ...repo, ...(isValidRepoField('directory', at) ? { directory: at } : {}) }
+  return built
 }
 
 // suggestedEntries of a GitHub repo, `{ github, sha, tag, directory, client, packageManager }`, as