@exodus/stasis-plugins 1.0.0-beta.12 → 1.0.0-beta.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/stasis-plugins",
-  "version": "1.0.0-beta.12",
+  "version": "1.0.0-beta.14",
   "description": "Bundler plugins (webpack, esbuild, Rollup, Metro) for @exodus/stasis-core",
   "type": "module",
   "exports": {
@@ -36,6 +36,6 @@
   },
   "homepage": "https://github.com/PreventiveMeasures/stasis#readme",
   "dependencies": {
-    "@exodus/stasis-core": "1.0.0-beta.12"
+    "@exodus/stasis-core": "1.0.0-beta.14"
   }
 }

package/src/esbuild.js

@@ -4,7 +4,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url'
 import assert from 'node:assert/strict'
 
 import { Bundle } from '@exodus/stasis-core/bundle'
-import { resolvePluginState } from './plugins.js'
+import { attestedImport, resolvePluginState, unsupportedExtension } from './plugins.js'
 import { State } from '@exodus/stasis-core/state'
 // Pre-patch snapshot, not `import { readFile }`: under --fs=async that builtin is patched, and
 // this plugin loads after, so a direct import would route esbuild's reads through the capture hook.
@@ -71,6 +71,8 @@ export class StasisEsbuild {
   #resources
   #loaders
   #transform
+  #resource
+  #platform
   #emptyModule  // URL of the empty module disabled imports point at, once capture recorded it
   #browserScopes = new Map()  // dir -> Promise<[{ dir, keys }]>: `false` keys of it and its ancestors
   #probes = new Map()  // [kind, resolveDir, specifier] -> Promise<disabled path | null>
@@ -79,7 +81,7 @@ export class StasisEsbuild {
   // the second is refused in onStart.
   #captureBuildCount = 0
 
-  constructor(options = {}, { loaders, transform } = {}) {
+  constructor(options = {}, { loaders, transform, resource, platform } = {}) {
     // A caller that owns a State (e.g. `stasis build`) can pass it directly; a foreign-copy State
     // fails closed via the instanceof miss.
     const state = options instanceof State
@@ -95,6 +97,12 @@ export class StasisEsbuild {
     // (source, { path, loader }) => { contents, loader } | undefined, may be async. Never
     // runs at capture -- capture attests the file's raw bytes.
     this.#transform = transform
+    // Load-mode-only module builder for a resource no loader override names (e.g. `stasis build
+    // --metro`'s asset module): (source, { path }) => { contents, loader } | undefined, may be async.
+    this.#resource = resource
+    // Load mode: the platform whose target a --metro per-platform edge resolves to (none fails
+    // closed on one, as plain bundle=load does).
+    this.#platform = platform
   }
 
   // esbuild loader for a served file: configured override, else derived from extension
@@ -223,16 +231,11 @@ export class StasisEsbuild {
         // keys attributed edges under specific conditions the plugin's `*` lookup won't match.
         // The edge is looked up even for a built-in's name: a browser build records `fs` when a
         // `browser` field disables it (an edge to the empty module) or a package by that name serves it.
-        try {
-          ;({ url } = this.#state.getImport(parentURL, specifier, { importAttributes: attrs }))
-        } catch (err) {
-          // No attested edge -- at a successful capture that's a built-in or another EXTERNAL (never
-          // recorded as an edge), so hand it back to esbuild, which externalizes it as without us
-          // (built-ins under platform:'node'). File BYTES still fail closed at onLoad.
-          // A non-MODULE_NOT_FOUND error is a real fault -- rethrow.
-          if (err?.code === 'ERR_MODULE_NOT_FOUND') return undefined
-          throw err
-        }
+        // No attested edge (a built-in, or another external): esbuild's, which externalizes it as
+        // without us (built-ins under platform:'node'). File BYTES still fail closed at onLoad.
+        const attested = attestedImport(this.#state, parentURL, specifier, { importAttributes: attrs, platform: this.#platform })
+        if (attested === undefined) return undefined
+        ;({ url } = attested)
       }
       const format = this.#state.getFormat(url)
       const isEmpty = url === pathToFileURL(resolvePath(this.#state.root, EMPTY_MODULE_PATH)).toString()
@@ -268,11 +271,7 @@ export class StasisEsbuild {
       if (res.namespace === 'file' && !res.external) {
         kind = classifyExtension(res.path, this.#resources)
         if (kind === 'unknown') {
-          return {
-            errors: [{
-              text: `StasisEsbuild: unsupported extension for '${res.path}' -- add its extension or filename to the plugin's resources option or stop importing it`,
-            }],
-          }
+          return { errors: [{ text: unsupportedExtension('StasisEsbuild', `'${res.path}'`) }] }
         }
         // Record the edge for BOTH code and resource targets (never entries): load mode resolves
         // every specifier through this map, so a resource with no edge would miss at bundle=load and
@@ -305,11 +304,15 @@ export class StasisEsbuild {
         // one a CSS @import, `composes` or url() accepts, so one empty module serves JS and CSS importers.
         if (kind === 'empty') return { contents: source, loader: 'empty' }
         if (kind === 'resource') {
-          // Plugin-provided contents with no `loader` default to `js` (esbuild applies the build's
-          // per-extension loader only on its own load path), so replay the configured loader from
-          // initialOptions.loader. No configured loader fails symmetrically with a capture build.
-          const loader = initialOptions.loader?.[extname(path)]
-          return loader ? { contents: source, loader } : { contents: source }
+          // A loader override for its extension (`stasis build --loader=.png:dataurl`) wins; else the
+          // resource hook's module, where it builds one.
+          const override = this.#loaders.get(extname(path))
+          if (override) return { contents: source, loader: override }
+          const built = await this.#resource?.(source, { path })
+          if (built) return built
+          // Else the loader esbuild's own load path takes (the build's `loader` option, else its default
+          // for the extension), so a resource none loads fails as at capture, not parsed as js.
+          return { contents: source, loader: 'default' }
         }
         const loader = this.#loaderFor(path)
         // A transform that declines (undefined) serves the attested bytes unchanged.

package/src/metro-babel-transformer.js

@@ -8,13 +8,16 @@ import { createRequire } from 'node:module'
 // babel-plugin-module-resolver mapping `#local/abc` to `./src/abc`) leaves the serializer only the
 // rewrite. This adds one plugin that records every specifier in its `pre` -- Babel runs every
 // plugin's `pre` before any plugin's visitor, so nothing has rewritten one yet -- and reads each
-// again once Babel is done, before Metro's own passes replace them in the AST, unless Babel erased
-// it. The real transformer runs as it would; its output is untouched.
+// again once Babel is done, before Metro's own passes replace them in the AST, but one importing
+// types alone that Babel erased. One a plugin consumed, gone from Babel's output with nothing left
+// naming its module (`require('./messages.po')`, which @exodus/i18n's plugin-inline-po reads and
+// inlines), it keeps apart. The real transformer runs as it would; its output is untouched.
 
 const require = createRequire(import.meta.url)
 
 // One per worker transform, run by ./metro-transformer.js: `babelTransformerPath` is the project's
-// (absolute), and `asWritten` maps each specifier Babel left to the ones written there.
+// (absolute), `asWritten` maps each specifier Babel left to the ones written there, and `consumed`
+// holds each one a plugin consumed, as Babel last left it.
 export const transformContext = new AsyncLocalStorage()
 
 // The nodes Metro's collectDependencies takes a specifier from: these declarations, and the calls
@@ -22,7 +25,10 @@ export const transformContext = new AsyncLocalStorage()
 const DECLARATIONS = new Set(['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'])
 const REQUIRE_MEMBERS = new Set(['context', 'resolveWeak', 'unstable_importMaybeSync'])
 
-function isDependencyCall(callee) {
+// Whether `node` is one of them.
+function isDependency(node) {
+  if (node.type !== 'CallExpression') return DECLARATIONS.has(node.type)
+  const { callee } = node
   if (callee.type === 'Import') return true
   if (callee.type === 'Identifier') return callee.name === 'require' || callee.name === '__prefetchImport'
   return callee.type === 'MemberExpression' && !callee.computed &&
@@ -30,30 +36,78 @@ function isDependencyCall(callee) {
     callee.property.type === 'Identifier' && REQUIRE_MEMBERS.has(callee.property.name)
 }
 
-// The specifier a dependency node holds as a string literal: an import/export's source, a call's
-// first argument. A plugin rewriting it replaces the literal, never the node holding it.
+// The string `node` holds as a constant: a literal, a template with no substitutions, or a `+` of
+// such, which Metro's collectDependencies evaluates to the specifier as it does a literal.
+function constantString(node) {
+  if (node?.type === 'StringLiteral') return node.value
+  if (node?.type === 'TemplateLiteral' && node.expressions.length === 0) return node.quasis[0].value.cooked ?? undefined
+  if (node?.type !== 'BinaryExpression' || node.operator !== '+') return undefined
+  const left = constantString(node.left)
+  const right = left === undefined ? undefined : constantString(node.right)
+  return right === undefined ? undefined : left + right
+}
+
+// The specifier a dependency node holds as a constant: an import/export's source, a call's first
+// argument. A plugin rewriting it replaces the literal, never the node holding it.
 function specifierOf(node) {
-  const literal = node.type === 'CallExpression' ? node.arguments[0] : node.source
-  return literal?.type === 'StringLiteral' ? literal.value : undefined
+  return constantString(node.type === 'CallExpression' ? node.arguments[0] : node.source)
+}
+
+const TYPE_KINDS = new Set(['type', 'typeof'])
+
+// A declaration of types alone, which Babel may erase, and then it names no module Metro depends on:
+// Flow's `import type`/`import typeof`, TypeScript's `import type`, `export type ... from`, and one
+// whose every specifier is a type (`import { type A }`, which TypeScript's `onlyRemoveTypeImports`
+// keeps as `import {} from`).
+function typesOnly(node) {
+  if (TYPE_KINDS.has(node.importKind ?? node.exportKind)) return true
+  const specifiers = node.specifiers ?? []
+  return specifiers.length > 0 && specifiers.every((specifier) => TYPE_KINDS.has(specifier.importKind ?? specifier.exportKind))
+}
+
+// The dependency nodes in Babel's output, and the specifiers they hold as constants.
+function dependenciesLeft(t, ast) {
+  const nodes = new Set()
+  const specifiers = new Set()
+  t.traverseFast(ast, (node) => {
+    if (!isDependency(node)) return
+    nodes.add(node)
+    const specifier = specifierOf(node)
+    if (specifier !== undefined) specifiers.add(specifier)
+  })
+  return { nodes, specifiers }
 }
 
 function asWrittenPlugin({ types: t }) {
   return {
     name: 'stasis-as-written',
     pre(file) {
-      const { slots } = transformContext.getStore()
+      const context = transformContext.getStore()
+      context.types = t
+      const { slots } = context
+      let evaluate = false
       t.traverseFast(file.ast, (node) => {
-        if (node.type === 'CallExpression' ? !isDependencyCall(node.callee) : !DECLARATIONS.has(node.type)) return
+        if (!isDependency(node)) return
         const written = specifierOf(node)
-        if (written !== undefined) slots.push({ node, written })
+        if (written !== undefined) slots.push({ node, written, types: node.type !== 'CallExpression' && typesOnly(node) })
+        else if (node.type === 'CallExpression' && node.arguments.length > 0) evaluate = true
+      })
+      // Metro takes any argument Babel evaluates to a string with confidence, one bound to a constant
+      // too (`const name = './x'; require(name)`), which only a path, and its scope, can evaluate.
+      if (!evaluate) return
+      file.path.traverse({
+        CallExpression(path) {
+          if (!isDependency(path.node) || specifierOf(path.node) !== undefined || path.node.arguments.length === 0) return
+          const { confident, value } = path.get('arguments.0').evaluate()
+          if (confident && typeof value === 'string') slots.push({ node: path.node, written: value })
+        },
       })
     },
     visitor: {
-      // Babel exits a node only if no plugin removed it on the way in, so a declaration erased for
-      // importing types alone (`import type`, `import { type A }`, a TS import used only as a type)
-      // never exits: flow-strip-types removes it as it enters it, the TS plugin before the
-      // traversal gets there. One lowered to a require exits first: wherever it is listed,
-      // @babel/plugin-transform-modules-commonjs takes the declarations away as the program exits.
+      // Babel exits a node only if no plugin removed it on the way in, so a declaration of types
+      // alone that Babel erased never exits: flow-strip-types removes it as it enters it, the TS
+      // plugin before the traversal gets there. One it kept (`import {} from` under
+      // `onlyRemoveTypeImports`) exits, still naming its module.
       'ImportDeclaration|ExportNamedDeclaration|ExportAllDeclaration': {
         exit(path) {
           transformContext.getStore().kept.add(path.node)
@@ -69,14 +123,24 @@ export function transform(args) {
   const slots = []
   const kept = new Set()
   Object.assign(context, { slots, kept })
-  // Once Babel is done: each specifier as it left it, from the node that held it as written.
+  // Once Babel is done: each specifier as it left it, from the node that held it as written, but a
+  // declaration of types alone Babel erased. One a plugin replaced keeps it too: lowered to a require
+  // (the commonjs transform), or split in two (`export * as ns from` into an import and an export,
+  // the export-namespace-from transform), it names the same module, its specifier as rewritten
+  // before (module-resolver rewrites every one as the program enters). One gone from the output,
+  // with no node there naming its module, a plugin consumed in its stead.
   const collect = (result) => {
-    for (const { node, written } of slots) {
-      if (DECLARATIONS.has(node.type) && !kept.has(node)) continue
-      const left = specifierOf(node)
-      if (left === undefined) continue
-      if (!context.asWritten.has(left)) context.asWritten.set(left, new Set())
-      context.asWritten.get(left).add(written)
+    const left = result?.ast && context.types ? dependenciesLeft(context.types, result.ast) : null
+    for (const { node, written, types } of slots) {
+      if (types && !kept.has(node)) continue
+      // One evaluated through its scope stays as written: no plugin rewrites what isn't a literal.
+      const specifier = specifierOf(node) ?? written
+      if (left !== null && !left.nodes.has(node) && !left.specifiers.has(specifier)) {
+        context.consumed.add(specifier)
+        continue
+      }
+      if (!context.asWritten.has(specifier)) context.asWritten.set(specifier, new Set())
+      context.asWritten.get(specifier).add(written)
     }
     return result
   }

package/src/metro-native.js

@@ -1,54 +1,168 @@
-import { dirname, join } from 'node:path'
+import { isUtf8 } from 'node:buffer'
+import { basename, dirname, join, posix, relative, sep } from 'node:path'
 
-import { classifyNativeCapture, isExcludedNativeDir, isNativeArtifact, isPodspec, isSkippedNativeWalkDir, refineNativeCapture } from '@exodus/stasis-core/util'
+import { readJson } from '@exodus/stasis-core/bundle-util'
+import { diskHost } from '@exodus/stasis-core/host'
+import { CODE_EXTENSIONS, classifyFormat, isAutoExcludedDir, isBinaryPlist, isDotEnvFile, isExcludedNativeFile, isNativeArtifact, nameFormat, pathExt, toPosix } from '@exodus/stasis-core/util'
 
 // The native build inputs of a React Native app's packages, shared by the Metro plugin's capture and
 // `stasis bundle --metro` so the two carry the same files. Both read through `fs`:
 //   readdir(dir) -> Dirent[] (throws where `dir` isn't one), readFile(file) -> Buffer,
 //   stat(path) -> Stats, or null where nothing is there.
 
+// Files a React Native build requires that neither Metro's module graph nor a run's loader carries,
+// each as a require() of it from the project root resolves it (one that doesn't, or lies outside the
+// root, is passed over), tagged by the shared classifier: setup_env.sh, which the React Native CLI runs
+// (`execFileSync`) as every command of it starts, `react-native config` the Metro plugin runs included.
+// The run's toolchain, none of it the app's: the Metro plugin records each under `run`, `stasis bundle
+// --metro` as its own (`bundle`).
+export const AUTO_INCLUDES = ['@react-native-community/cli/setup_env.sh']
+
+// The entries of the directory `dir`, none where it's missing or no directory.
+export function listing(dir, fs) {
+  try {
+    return fs.readdir(dir)
+  } catch {
+    return []
+  }
+}
+
+// RN core build scripts the native walk would defer to Metro as `.js`, but Metro never sees them (RN's
+// podspecs invoke them at pod-install). Project-relative, so react-native's `exports` can't hide them.
+export const RN_CORE_INCLUDE_FILES = ['sdks/hermes-engine/utils/replace_hermes_version.js']
+
+// Discovered by name: RN scatters podspecs in subdirs `react-native config` misses.
+function isPodspec(name) {
+  return name.endsWith('.podspec') || name.endsWith('.podspec.json')
+}
+
+// The off-platform top-level dir of a native package, which no build on this host compiles.
+export function isExcludedNativeDir(name, { win32 = process.platform === 'win32' } = {}) {
+  return !win32 && name === 'windows'
+}
+
+// Dirs the NATIVE walks (Metro plugin + the static --metro bundler) skip, on top of the shared set:
+// nested packages (attested separately) and regenerated build output -- none is a build input.
+const NATIVE_BUILD_OUTPUT_DIRS = new Set(['node_modules', 'build', '.gradle', '.cxx', 'Pods', 'DerivedData'])
+function isSkippedNativeWalkDir(name) {
+  return NATIVE_BUILD_OUTPUT_DIRS.has(name) || isAutoExcludedDir(name) || isNativeArtifact(name)
+}
+
+// An extensionless non-UTF-8 file is a compiled tool (Hermes' `hermesc`), never source -- skipped.
+function isExtensionlessBinary(name, content) {
+  return pathExt(name) === '' && Buffer.isBuffer(content) && !isUtf8(content)
+}
+
+// The Metro native capture's policy view. Returns { action, format }: 'code' (a native build input),
+// 'skip' (excluded noise, or a JS-family file matched BY EXTENSION -- Metro owns those), else 'resource'.
+export function classifyNativeCapture(name, { win32 = process.platform === 'win32', content } = {}) {
+  // `.env` files carry secrets: an automated capture must never sweep them in.
+  if (isExcludedNativeFile(name, { win32 }) || isDotEnvFile(name)) return { action: 'skip' }
+  // Name-matched code is always a native build input, even when its tag is a Node format the JS
+  // graph would otherwise own.
+  const byName = nameFormat(name)
+  if (byName !== undefined) return { action: 'code', format: byName }
+  if (CODE_EXTENSIONS.has(pathExt(name))) return { action: 'skip' }
+  const format = classifyFormat(name, { content })
+  return format === undefined ? { action: 'resource' } : { action: 'code', format }
+}
+
+// The byte-level half of the native classification, refining what classifyNativeCapture derived from the
+// NAME. Both rules only ever demote. A 'resource' carries no format: storage derives base64 from bytes.
+export function refineNativeCapture(classified, name, content, resources = new Set()) {
+  if (isExtensionlessBinary(name, content)) return { action: 'skip' }
+  if (isBinaryPlist(name, content)) return { action: resources.has('plist') ? 'resource' : 'skip' }
+  return classified
+}
+
+// A file name as Metro's AssetPaths reads it (parsePlatformFilePath, then parseBaseName): its asset,
+// `${name}.${type}` less any scale (`a@2x.png` is `a.png`'s), its scale (`resolution`, 1 where it
+// names none), and its platform where it names `platform` (`a.ios.png`; another's, `a.android.png`,
+// is an asset of its own). -> { asset, name, type, resolution, platform }, or null for a name with no type
+const METRO_PLATFORM_FILE = /^(.+?)(?:\.([^.]+))?\.([^.]+)$/u
+const METRO_ASSET_SCALE = /^(.+?)(?:@([\d.]+)x)?$/u
+export function parseMetroAssetName(name, platform) {
+  const match = METRO_PLATFORM_FILE.exec(name)
+  if (match === null) return null
+  const [, base, suffix, type] = match
+  const ofPlatform = suffix !== undefined && suffix === platform
+  const [, root, scale] = METRO_ASSET_SCALE.exec(suffix === undefined || ofPlatform ? base : `${base}.${suffix}`)
+  const resolution = Number.parseFloat(scale)
+  return { asset: `${root}.${type}`, name: root, type, resolution: Number.isNaN(resolution) ? 1 : resolution, platform: ofPlatform ? platform : null }
+}
+
+// What a file's stat answers to metroAssetFiles, for a file a listing names but the disk lacks.
+export const FILE_STAT = { isFile: () => true }
+
+// The files `state` (a loaded State) carries, as a directory listing of them (metroAssetFiles' host):
+// an asset's files as captured.
+export function bundleDirHost(state) {
+  const dirs = Map.groupBy([...state.sources.keys(), ...state.resources.keys()], (rel) => posix.dirname(rel))
+  return {
+    readdir: (dir) => (dirs.get(toPosix(state.relative(dir)) || '.') ?? []).map((rel) => ({ name: posix.basename(rel) })),
+    stat: () => FILE_STAT,
+  }
+}
+
+// Metro's record of the asset module `path` (its Assets' getAbsoluteAssetRecord): the files it reads
+// to build the module (its `scales` and `hash`) and copies out with it. In `path`'s directory, each of
+// the asset's name and type at any scale (`a.png`, `a@2x.png`, `a@3x.png`): those for `platform`
+// (`a.ios.png`, `a@3x.ios.png`) where it has any, else those for none. -> absolute paths
+export function metroAssetFiles(path, platform = null, host = diskHost) {
+  const own = parseMetroAssetName(basename(path), platform)
+  if (own === null) return []
+  const dir = dirname(path)
+  const byPlatform = new Map()
+  for (const { name } of host.readdir(dir)) {
+    const parsed = parseMetroAssetName(name, platform)
+    if (parsed?.asset !== own.asset || host.stat(join(dir, name))?.isFile() !== true) continue
+    if (!byPlatform.has(parsed.platform)) byPlatform.set(parsed.platform, [])
+    byPlatform.get(parsed.platform).push(join(dir, name))
+  }
+  return (platform === null ? undefined : byPlatform.get(platform)) ?? byPlatform.get(null) ?? []
+}
+
 // True if the package at `root` ships native code: an ios/ or android/ dir, or a podspec under it.
 export function looksNative(root, fs) {
-  if (fs.stat(join(root, 'ios')) !== null || fs.stat(join(root, 'android')) !== null) return true
-  return hasPodspec(root, fs)
+  return fs.stat(join(root, 'ios')) !== null || fs.stat(join(root, 'android')) !== null || hasPodspec(root, fs)
 }
 
 // True if any *.podspec exists under `dir`, pruning the same subtrees the native walk skips.
 function hasPodspec(dir, fs) {
-  let entries
-  try {
-    entries = fs.readdir(dir)
-  } catch {
-    return false
-  }
-  for (const ent of entries) {
-    if (ent.isSymbolicLink()) continue
-    if (ent.isFile()) {
-      if (isPodspec(ent.name)) return true
-    } else if (ent.isDirectory() && !isSkippedNativeWalkDir(ent.name)) {
-      if (hasPodspec(join(dir, ent.name), fs)) return true
-    }
-  }
-  return false
+  return listing(dir, fs).some((ent) => !ent.isSymbolicLink() &&
+    (ent.isFile() ? isPodspec(ent.name) : ent.isDirectory() && !isSkippedNativeWalkDir(ent.name) && hasPodspec(join(dir, ent.name), fs)))
 }
 
+// The specs React Native's codegen parses in a package's codegen sources (codegenSources), as its own
+// filter takes them (filterJSFile): a JS or TS module named `Native…` or `…NativeComponent` (a platform's
+// `.ios`/`.android` one too), but a type declaration.
+const isCodegenSpec = (name) => /^(?:Native.+|.+NativeComponent)/u.test(name) && /\.(?:jsx?|tsx?)$/u.test(name) && !name.endsWith('.d.ts')
+
 // Each native build input in the package at `root`, walked whole, a native build reading sources
 // from anywhere in it (a podspec compiling `cpp/` beside `ios/`): every file but build output and
 // prebuilt binaries (isSkippedNativeWalkDir, isNativeArtifact), an off-platform top-level dir
 // (isExcludedNativeDir), what the shared classifier skips (the JS and TS Metro's graph owns, docs,
-// secrets) and symlinks (a cycle or escape hazard). A file `skip(file)` holds is passed over unread.
-// `resources` is the allowlist the byte-level rules consult. -> yields { file, source, action, format },
-// `action` 'code' (under the source-language `format`) or 'resource'
+// secrets) and symlinks (a cycle or escape hazard). And the specs of its codegen sources
+// (codegenSources, isCodegenSpec), as code with no format, as Metro's code has none: none of the
+// other JS there (a react-native.config.js, the package's build, where `jsSrcsDir` is its root), which
+// codegen never reads. A file `skip(file)` holds is passed over unread. `resources` is the allowlist
+// the byte-level rules consult.
+// -> yields { file, source, action, format }, `action` 'code' (under the source-language `format`,
+// none for JS and TS) or 'resource'
 export function* nativeInputs(root, fs, { resources = new Set(), skip = () => false } = {}) {
   yield* walk(root, true)
-  function* walk(dir, atRoot) {
-    let entries
-    try {
-      entries = fs.readdir(dir)
-    } catch {
-      return // dir missing / not a directory -- nothing to walk
+  for (const dir of codegenSources(root, fs)) yield* sources(dir)
+  function* sources(dir) {
+    for (const ent of listing(dir, fs)) {
+      // None in a dot, node_modules or tests directory, as codegen skips one.
+      if (ent.isSymbolicLink() || ent.name.startsWith('.') || ent.name === 'node_modules' || ent.name.startsWith('__tests')) continue
+      const file = join(dir, ent.name)
+      if (ent.isDirectory()) yield* sources(file)
+      else if (ent.isFile() && isCodegenSpec(ent.name) && !skip(file)) yield { file, source: fs.readFile(file), action: 'code', format: undefined }
     }
-    for (const ent of entries) {
+  }
+  function* walk(dir, atRoot) {
+    for (const ent of listing(dir, fs)) {
       if (ent.isSymbolicLink()) continue
       const file = join(dir, ent.name)
       if (ent.isDirectory()) {
@@ -66,21 +180,39 @@ export function* nativeInputs(root, fs, { resources = new Set(), skip = () => fa
   }
 }
 
+// The directories of the package at `root` its package.json's `codegenConfig` names as its JS sources
+// (`jsSrcsDir`, or each of its `libraries`', as React Native's own names `src`), each reached within it
+// through no symlink, as the walk follows none: React Native's codegen parses the specs there to
+// generate the native code a build compiles (a missing one fails it), and `react-native config` reads
+// them for the components they declare (`codegenNativeComponent`, in a `…NativeComponent` spec).
+// -> the absolute dirs
+function codegenSources(root, fs) {
+  const config = readJson(join(root, 'package.json'), fs)?.codegenConfig
+  const named = [config?.jsSrcsDir, ...(Array.isArray(config?.libraries) ? config.libraries.map((library) => library?.jsSrcsDir) : [])]
+  return named.filter((dir) => typeof dir === 'string' && dir !== '').map((dir) => packageDir(root, dir, fs)).filter((dir) => dir !== null)
+}
+
+// The directory `rel` names in the package at `root`, each step of it one (a link's entry is none, and
+// none is `..`). -> its absolute path, or null
+function packageDir(root, rel, fs) {
+  let dir = root
+  for (const name of relative(root, join(root, rel)).split(sep)) {
+    if (name === '') continue
+    if (!listing(dir, fs).some((ent) => ent.name === name && ent.isDirectory())) return null
+    dir = join(dir, name)
+  }
+  return dir
+}
+
 // A package name as npm takes one (`name` or `@scope/name`), which a path can't climb out with.
 const PACKAGE_NAME = /^(?:@[^/\\@.][^/\\]*\/)?[^/\\@.][^/\\]*$/u
 
-// The app's packages `react-native config` links, as a native build would, read as data rather than
-// by running the CLI: each name the app's package.json lists under dependencies, peerDependencies or
-// devDependencies (the CLI's list), in the nearest node_modules up from `projectDir` that holds it
-// (as the CLI looks), where it ships native code (looksNative). What a react-native.config.js changes,
-// being code, isn't seen. -> the package dirs, as found
-export function linkedNativePackages(projectDir, fs) {
-  let manifest
-  try {
-    manifest = JSON.parse(fs.readFile(join(projectDir, 'package.json')).toString('utf8'))
-  } catch {
-    return []
-  }
+// The app's packages `react-native config` reads, read as data rather than by running the CLI: each
+// name the app's package.json lists under dependencies, peerDependencies or devDependencies (the
+// CLI's list), in the nearest node_modules up from `projectDir` that holds it (as the CLI looks). What
+// a react-native.config.js changes, being code, isn't seen. -> the package dirs, as found
+export function linkedPackages(projectDir, fs) {
+  const manifest = readJson(join(projectDir, 'package.json'), fs)
   const listed = (field) => (manifest?.[field] && typeof manifest[field] === 'object' ? Object.keys(manifest[field]) : [])
   const names = new Set([...listed('dependencies'), ...listed('peerDependencies'), ...listed('devDependencies')])
   const dirs = []
@@ -89,7 +221,7 @@ export function linkedNativePackages(projectDir, fs) {
     for (let dir = projectDir; ; dir = dirname(dir)) {
       const found = join(dir, 'node_modules', name)
       if (fs.stat(found)?.isDirectory()) {
-        if (looksNative(found, fs)) dirs.push(found)
+        dirs.push(found)
         break
       }
       if (dirname(dir) === dir) break
@@ -97,3 +229,9 @@ export function linkedNativePackages(projectDir, fs) {
   }
   return dirs
 }
+
+// Of those, the ones `react-native config` links, as a native build would: those that ship native
+// code (looksNative). -> the package dirs, as found
+export function linkedNativePackages(projectDir, fs) {
+  return linkedPackages(projectDir, fs).filter((dir) => looksNative(dir, fs))
+}