brustjs 0.1.0-alpha

package/runtime/cli/build.ts

@@ -0,0 +1,252 @@
+import { existsSync } from 'node:fs'
+import { copyFile, mkdir, readdir, rm } from 'node:fs/promises'
+import path, { isAbsolute, resolve } from 'node:path'
+import {
+  actionsPrebuiltPlugin,
+  writePrebuiltActionsFileWithMap,
+} from './actions-prebuilt-plugin.ts'
+import { emitNativeTemplates } from './native-routes-emit.ts'
+import { nativeShimPlugin } from './native-shim-plugin.ts'
+
+/** repoRoot = the directory that contains runtime/. This file lives at
+ * runtime/cli/build.ts so two dirname() steps get us there. */
+const REPO_ROOT = path.resolve(import.meta.dir, '..', '..')
+
+interface ParsedArgs {
+  entry: string // absolute path to the entry file
+  outDir: string // absolute path to the output dir
+}
+
+function parseArgs(args: string[]): ParsedArgs {
+  let entry: string | undefined
+  let outDir: string | undefined
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '--out-dir') {
+      outDir = args[++i]
+      if (!outDir) {
+        console.error('brust build: --out-dir requires a value')
+        process.exit(1)
+      }
+    } else if (a.startsWith('--out-dir=')) {
+      outDir = a.slice('--out-dir='.length)
+    } else if (a.startsWith('-')) {
+      console.error(`brust build: unknown flag "${a}"`)
+      process.exit(1)
+    } else if (entry === undefined) {
+      entry = a
+    } else {
+      console.error(`brust build: unexpected positional argument "${a}"`)
+      process.exit(1)
+    }
+  }
+
+  const cwd = process.cwd()
+  const entryPath = entry
+    ? isAbsolute(entry)
+      ? entry
+      : resolve(cwd, entry)
+    : resolve(cwd, 'index.ts')
+
+  if (!existsSync(entryPath)) {
+    console.error(`brust build: no entry file at ${entryPath}; pass a path or create ./index.ts`)
+    process.exit(1)
+  }
+
+  const outPath = outDir
+    ? isAbsolute(outDir)
+      ? outDir
+      : resolve(cwd, outDir)
+    : resolve(cwd, 'dist')
+
+  return { entry: entryPath, outDir: outPath }
+}
+
+export async function runBuild(args: string[]): Promise<void> {
+  const { entry, outDir } = parseArgs(args)
+  const entryDir = path.dirname(entry)
+
+  console.log(`[brust build] entry:  ${entry}`)
+  console.log(`[brust build] outDir: ${outDir}`)
+
+  // 1. Clobber outDir.
+  await rm(outDir, { recursive: true, force: true })
+  await mkdir(outDir, { recursive: true })
+
+  // 2. Scan actions + rediscover id→source mapping for the prebuilt plugin.
+  const { scanActions, collectExports } = await import('../scan-actions.ts')
+  const scan = await scanActions({ roots: [entryDir] })
+  console.log(
+    `[brust build] actions: discovered ${scan.actions.length} (${scan.actions.map((a) => a.id).join(', ') || '(none)'})`,
+  )
+
+  const idToSource = new Map<string, string>()
+  for (const file of scan.sourceFiles) {
+    const defs = await collectExports(file)
+    for (const def of defs) idToSource.set(def.id, file)
+  }
+
+  // routes.tsx is the scan target for both islands (§3) and the MCP manifest
+  // (§4). Computed once here and reused below.
+  const routesFile = path.join(entryDir, 'routes.tsx')
+
+  // 3. Build islands (if any <Island> usage is found in the routes graph).
+  const { scanIslandChunks, buildIslands } = await import('../islands/build.ts')
+  const islandMap = existsSync(routesFile)
+    ? scanIslandChunks(routesFile)
+    : new Map<string, string>()
+  if (islandMap.size > 0) {
+    const islandsOutDir = path.join(outDir, 'islands')
+    const result = await buildIslands(islandMap, { outDir: islandsOutDir })
+    console.log(`[brust build] islands: ${result.islandCount} chunk(s) → ${islandsOutDir}`)
+  } else {
+    console.log('[brust build] islands: skipped (no <Island> usage)')
+  }
+
+  // 4. MCP manifest (if routes.tsx exists).
+  let loadedRoutes: any[] | undefined
+  if (existsSync(routesFile)) {
+    const { extractMcpManifest } = await import('../mcp/extractor.ts')
+    const { routes } = await import(routesFile)
+    loadedRoutes = routes
+    const manifest = await extractMcpManifest({
+      serverFiles: scan.sourceFiles,
+      routesFile,
+      sourceRoots: [entryDir],
+      actions: scan.actions,
+      routes,
+    })
+    const manifestPath = path.join(outDir, 'mcp-manifest.json')
+    await Bun.write(manifestPath, JSON.stringify(manifest, null, 2))
+    console.log(
+      `[brust build] mcp:     ${manifest.tools.length} tools + ${manifest.resources.length} resources → ${manifestPath}`,
+    )
+  } else {
+    console.log(`[brust build] mcp:     skipped (no routes.tsx)`)
+  }
+
+  // 4.1. Sub-project J — emit .brust/jinja/<Name>.jinja templates for every
+  // native: true route. Pipeline runs even if no native routes exist (writes
+  // an empty manifest) so consumers can rely on the output dir's presence.
+  {
+    // outDir must align with the runtime's loadJinjaOnce which reads from
+    // `process.cwd() + '.brust/jinja'`. Existing CSS pipeline uses cwd too
+    // (see boot log: "built CSS → <cwd>/.brust/css/app.css"). entryDir
+    // diverges when user runs `bun run dev <entry>` from a different dir;
+    // cwd is the single source of truth for both pipelines.
+    const jinjaDir = path.join(process.cwd(), '.brust/jinja')
+    // Spec §7 Component-source resolution: scan the routes module's source for
+    // ImportDeclarations, NOT the app entry's. The app entry only imports the
+    // routes module + brust; the page components are imported by routes.tsx.
+    // If routes.tsx doesn't exist (no routes module), we still write an empty
+    // manifest below — scanner falls back to passing a dummy path that produces
+    // an empty importMap (no native routes to emit anyway).
+    await emitNativeTemplates({
+      entryFile: existsSync(routesFile) ? routesFile : entry,
+      flatRoutes: (loadedRoutes ?? []) as { nativeTemplate?: string }[],
+      outDir: jinjaDir,
+      repoRoot: REPO_ROOT,
+    })
+    const nativeCount = (loadedRoutes ?? []).filter((r: any) => r?.nativeTemplate).length
+    console.log(`[brust build] jinja:   ${nativeCount} template(s) → ${jinjaDir}`)
+  }
+
+  // 4.5. CSS — Tailwind v4 if app.css is present.
+  const appCssPath = path.join(entryDir, 'app.css')
+  if (existsSync(appCssPath)) {
+    const { buildCss } = await import('../css/build.ts')
+    const cssOutDir = path.join(outDir, 'css')
+    await buildCss({ entry: appCssPath, outDir: cssOutDir })
+    console.log(`[brust build] css:     ${cssOutDir}/app.css`)
+  } else {
+    console.log(`[brust build] css:     skipped (no app.css)`)
+  }
+
+  // 4.6. Component CSS — Lightning CSS + Modules.
+  {
+    const { scanCssImports } = await import('../css/scan-imports.ts')
+    const scan = await scanCssImports(entryDir)
+    if (scan.size > 0) {
+      const { buildComponentCss } = await import('../css/component-build.ts')
+      const routesFile = path.join(entryDir, 'routes.tsx')
+      let routeForCss: { fullPath: string; componentSource: string }[] = []
+      if (existsSync(routesFile)) {
+        try {
+          const { routes } = await import(routesFile)
+          routeForCss = (routes as any[]).map((r) => ({
+            fullPath: r.fullPath,
+            componentSource: routesFile,
+          }))
+        } catch {
+          /* if routes import fails, skip — manifest still emits modules */
+        }
+      }
+      const cssOutDir = path.join(outDir, 'css')
+      const manifest = await buildComponentCss({
+        scanRoot: entryDir,
+        outDir: cssOutDir,
+        tailwindCompile: null,
+        routes: routeForCss,
+      })
+      console.log(
+        `[brust build] css-mod: ${Object.keys(manifest.modules).length} chunk(s) → ${cssOutDir}/components/`,
+      )
+    } else {
+      console.log(`[brust build] css-mod: skipped (no component CSS imports)`)
+    }
+  }
+
+  // 5. Generate the prebuilt-actions file (always — empty list if no actions).
+  const prebuiltActionsPath = path.join(outDir, '_actions-prebuilt.ts')
+  await writePrebuiltActionsFileWithMap(prebuiltActionsPath, idToSource, REPO_ROOT)
+
+  // 6. Bun.build the server bundle with both plugins + banner.
+  const banner =
+    `process.env.BRUST_PREBUILT = '1';\n` + `process.env.BRUST_DIST_DIR = import.meta.dir;\n`
+
+  const result = await Bun.build({
+    entrypoints: [entry],
+    outdir: outDir,
+    naming: 'index.js',
+    target: 'bun',
+    format: 'esm',
+    // Preserve function/class identifiers. The Island component's chunk-id
+    // marker on the React path IS `Component.name`, so mangled names would
+    // point at non-existent files. Whitespace + syntax minification still apply.
+    minify: { whitespace: true, syntax: true, identifiers: false },
+    banner,
+    plugins: [nativeShimPlugin(REPO_ROOT), actionsPrebuiltPlugin(prebuiltActionsPath, REPO_ROOT)],
+  })
+
+  if (!result.success) {
+    console.error('brust build: Bun.build failed')
+    for (const m of result.logs) console.error(String(m))
+    process.exit(1)
+  }
+  console.log(`[brust build] bundle:  ${path.join(outDir, 'index.js')}`)
+
+  // 7. Copy the current-platform native binary.
+  const nativeDir = path.join(outDir, 'native')
+  await mkdir(nativeDir, { recursive: true })
+
+  // napi-rs emits `runtime/brust.<platform>-<arch>[-libc].node` (binaryName
+  // "brust", from the root napi config). We copy every `brust.*.node` we find
+  // in runtime/ so a multi-platform pre-build (CI matrix) Just Works without
+  // further wiring; in single-platform local builds this is just one file.
+  const runtimeDir = path.join(REPO_ROOT, 'runtime')
+  const nodeFiles = (await readdir(runtimeDir)).filter((f) => /^brust\..+\.node$/.test(f))
+  if (nodeFiles.length === 0) {
+    console.error(
+      `brust build: no native binary found in ${runtimeDir}. ` +
+        `Run \`bun --filter runtime run build\` (or :debug) first.`,
+    )
+    process.exit(1)
+  }
+  for (const f of nodeFiles) {
+    await copyFile(path.join(runtimeDir, f), path.join(nativeDir, f))
+    console.log(`[brust build] native:  ${f}`)
+  }
+
+  console.log(`[brust build] done.`)
+}

package/runtime/cli/dev.ts

@@ -0,0 +1,92 @@
+import { existsSync } from 'node:fs'
+import path, { dirname, isAbsolute, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { emitNativeTemplates } from './native-routes-emit.ts'
+
+/** repoRoot = the directory that contains runtime/. This file lives at
+ * runtime/cli/dev.ts so two dirname() steps get us there. */
+const REPO_ROOT = path.resolve(import.meta.dir, '..', '..')
+
+interface ParsedArgs {
+  entry: string
+  port: number | undefined
+}
+
+function parseArgs(args: string[]): ParsedArgs {
+  let entry: string | undefined
+  let port: number | undefined
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '--port') {
+      const v = args[++i]
+      if (!v) {
+        console.error('brust dev: --port requires a value')
+        process.exit(1)
+      }
+      port = parseInt(v, 10)
+      if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        console.error(`brust dev: invalid port ${v}`)
+        process.exit(1)
+      }
+    } else if (a.startsWith('--port=')) {
+      port = parseInt(a.slice('--port='.length), 10)
+    } else if (a.startsWith('-')) {
+      console.error(`brust dev: unknown flag ${a}`)
+      process.exit(1)
+    } else if (entry === undefined) {
+      entry = a
+    } else {
+      console.error(`brust dev: unexpected positional argument ${a}`)
+      process.exit(1)
+    }
+  }
+  const cwd = process.cwd()
+  const entryPath = entry
+    ? isAbsolute(entry)
+      ? entry
+      : resolve(cwd, entry)
+    : resolve(cwd, 'index.ts')
+  if (!existsSync(entryPath)) {
+    console.error(`brust dev: no entry file at ${entryPath}; pass a path or create ./index.ts`)
+    process.exit(1)
+  }
+  return { entry: entryPath, port }
+}
+
+export async function runDev(args: string[]): Promise<void> {
+  const { entry, port } = parseArgs(args)
+  process.env.BRUST_DEV = '1'
+  if (port !== undefined) process.env.BRUST_PORT = String(port)
+
+  // Sub-project J — emit .brust/jinja/<Name>.jinja templates BEFORE handing
+  // off to the user's entry. The runtime loads these on boot. Dev-mode HMR
+  // on .tsx edit is deferred per spec §12 (restart-to-reload for v2).
+  const entryDir = dirname(entry)
+  const routesFile = path.join(entryDir, 'routes.tsx')
+  let loadedRoutes: any[] = []
+  if (existsSync(routesFile)) {
+    try {
+      const mod = await import(routesFile)
+      loadedRoutes = mod.routes ?? []
+    } catch (err) {
+      console.warn(
+        `[brust dev] failed to pre-load routes for jinja emit: ${(err as Error).message}`,
+      )
+    }
+  }
+  // Spec §7 — scan routes.tsx (where page imports live), not the app entry.
+  // outDir = process.cwd() to align with the runtime's loadJinjaOnce which
+  // reads from `cwd + '.brust/jinja'`. When user runs `bun run dev
+  // example/hello-world/index.ts` from repo root, cwd != entryDir; writing
+  // to entryDir would put templates somewhere the runtime never looks.
+  await emitNativeTemplates({
+    entryFile: existsSync(routesFile) ? routesFile : entry,
+    flatRoutes: loadedRoutes as { nativeTemplate?: string }[],
+    outDir: path.join(process.cwd(), '.brust/jinja'),
+    repoRoot: REPO_ROOT,
+  })
+
+  // Hand off to the user's entry. It calls brust.run() which, with
+  // BRUST_DEV=1, enables dev wiring without requiring user edits.
+  await import(pathToFileURL(entry).href)
+}

package/runtime/cli/index.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+const [, , subcommand, ...rest] = process.argv
+
+switch (subcommand) {
+  case 'build': {
+    const { runBuild } = await import('./build.ts')
+    await runBuild(rest)
+    break
+  }
+  case 'dev': {
+    const { runDev } = await import('./dev.ts')
+    await runDev(rest)
+    break
+  }
+  case 'new': {
+    const { runNew } = await import('./new.ts')
+    await runNew(rest)
+    break
+  }
+  default: {
+    if (!subcommand) {
+      console.error('brust: missing subcommand. Try: brust build | brust dev | brust new')
+    } else {
+      console.error(
+        `brust: unknown subcommand "${subcommand}". Try: brust build | brust dev | brust new`,
+      )
+    }
+    process.exit(1)
+  }
+}

package/runtime/cli/native-routes-emit.ts

@@ -0,0 +1,171 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { ISLANDS_IMPORTMAP_AND_BOOTSTRAP } from '../islands/importmap.ts'
+
+/** Sub-project J — build pass that turns user's `pages/<Name>.tsx` files into
+ * `.brust/jinja/<Name>.jinja` templates. Invoked from `brust build` and
+ * `brust dev` after the user's routes are flattened.
+ *
+ * Limitations (spec §7 + §13.10):
+ * - Regex-based import scanner — handles `import Name from './path'` only.
+ *   Full swc AST + re-export chain support deferred to v2.x.
+ * - Dev mode does NOT hot-reload templates on .tsx edit. Boot-only; restart
+ *   required. Deferred per spec §12.
+ */
+
+export interface NativeRouteEmitOpts {
+  /** User's routes entry file (absolute path). Scanned for ImportDeclarations
+   * to resolve each native: true route's Component to its source .tsx. */
+  entryFile: string
+  /** Flat routes array; only entries with `nativeTemplate` are emitted. */
+  flatRoutes: { nativeTemplate?: string }[]
+  /** `.brust/jinja` absolute output dir. Created if missing. */
+  outDir: string
+  /** Repo root — used to resolve the `jsx-rustc` binary. */
+  repoRoot: string
+}
+
+/** One entry in a `<Name>.islands.json` as emitted by `jsx-rustc` (camelCase,
+ * see crates/jsx-rust-compiler/src/lib.rs). Enriched with `sourcePath`. */
+interface RawIslandEntry {
+  component: string
+  instance: number
+  propsPath: string
+  ssr: boolean
+  hydrate: string
+}
+interface EnrichedIslandEntry extends RawIslandEntry {
+  /** Absolute path to the island's client source, resolved from the page's
+   * own `import <component> from "..."` declaration. */
+  sourcePath: string
+}
+
+export async function emitNativeTemplates(opts: NativeRouteEmitOpts): Promise<void> {
+  mkdirSync(opts.outDir, { recursive: true })
+
+  const nativeRoutes = opts.flatRoutes.filter((r) => r.nativeTemplate)
+
+  // Resolve jsx-rustc binary: prefer release, fall back to debug.
+  const jsxRustcRelease = resolve(opts.repoRoot, 'target/release/jsx-rustc')
+  const jsxRustcDebug = resolve(opts.repoRoot, 'target/debug/jsx-rustc')
+  const jsxRustc = existsSync(jsxRustcRelease)
+    ? jsxRustcRelease
+    : existsSync(jsxRustcDebug)
+      ? jsxRustcDebug
+      : null
+
+  if (!jsxRustc && nativeRoutes.length > 0) {
+    throw new Error(
+      'jsx-rustc binary not found in target/{release,debug}/; ' +
+        'run `cargo build -p jsx-rust-compiler --bin jsx-rustc`',
+    )
+  }
+
+  const importMap =
+    nativeRoutes.length > 0 ? scanImports(opts.entryFile) : new Map<string, string>()
+
+  const built: string[] = []
+  for (const r of nativeRoutes) {
+    const name = r.nativeTemplate!
+    const sourcePath = importMap.get(name)
+    if (!sourcePath) {
+      console.warn(
+        `[brust build] no import for native route "${name}" in ${opts.entryFile}; skipping`,
+      )
+      continue
+    }
+    const outPath = resolve(opts.outDir, `${name}.jinja`)
+    const result = Bun.spawnSync({
+      cmd: [jsxRustc!, sourcePath, '-o', outPath],
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    if (result.exitCode !== 0) {
+      const stderr = result.stderr ? new TextDecoder().decode(result.stderr) : ''
+      const stdout = result.stdout ? new TextDecoder().decode(result.stdout) : ''
+      throw new Error(`jsx-rustc failed for ${sourcePath}:\n${stdout}\n${stderr}`)
+    }
+    built.push(name)
+
+    // Islands post-processing. jsx-rustc writes `<Name>.islands.json` ONLY when
+    // the route uses <Island>; absent file ⇒ no islands ⇒ leave the .jinja
+    // byte-identical (no-island regression).
+    const islandsJsonPath = resolve(opts.outDir, `${name}.islands.json`)
+    if (existsSync(islandsJsonPath)) {
+      // Island source paths resolve from the PAGE file's own imports.
+      const pageImports = scanImports(sourcePath)
+      reconcileIslandManifest(outPath, islandsJsonPath, pageImports, name)
+    }
+  }
+
+  writeFileSync(
+    resolve(opts.outDir, '_manifest.json'),
+    JSON.stringify({ templates: built, generatedAt: new Date().toISOString() }, null, 2),
+  )
+}
+
+/** Scan the entry file's `import Name from './path'` declarations and build a
+ * map of localName -> resolved absolute path. Extension resolution tries
+ * `.tsx`, `.ts`, `/index.tsx`, `/index.ts` in order. */
+export function scanImports(entryFile: string): Map<string, string> {
+  const source = readFileSync(entryFile, 'utf8')
+  const map = new Map<string, string>()
+  // Regex-based scanner; full swc AST scan deferred per spec §7 + §13.10.
+  const re = /^import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/gm
+  for (let m = re.exec(source); m !== null; m = re.exec(source)) {
+    const localName = m[1]!
+    const importPath = m[2]!
+    if (!importPath.startsWith('.')) continue // skip package imports
+    const baseDir = dirname(entryFile)
+    const resolved = resolve(baseDir, importPath)
+    const candidates = [
+      `${resolved}.tsx`,
+      `${resolved}.ts`,
+      `${resolved}/index.tsx`,
+      `${resolved}/index.ts`,
+    ]
+    const found = candidates.find((p) => existsSync(p))
+    if (found) map.set(localName, found)
+  }
+  return map
+}
+
+/** Reconcile the raw `<Name>.islands.json` jsx-rustc emitted against the page's
+ * own imports, then bake the importmap+bootstrap into the `.jinja`.
+ *
+ * Pure-ish & synchronous (fs only) so it unit-tests deterministically:
+ * 1. If `islandsJsonPath` is absent → no-op (the route has no islands; the
+ *    `.jinja` stays byte-identical).
+ * 2. Resolve every entry's `sourcePath` from the page's `import <component>
+ *    from "..."` (else throw).
+ * 3. Enrich each entry with that absolute `sourcePath` and rewrite the
+ *    `.islands.json`.
+ * 4. Append `{% raw %}…{% endraw %}`-wrapped bootstrap to the `.jinja`. The raw
+ *    block keeps the importmap's literal `}}`/`{{` inert through minijinja's
+ *    boot-time compile.
+ */
+export function reconcileIslandManifest(
+  jinjaPath: string,
+  islandsJsonPath: string,
+  pageImports: Map<string, string>,
+  routeName: string,
+): void {
+  if (!existsSync(islandsJsonPath)) return
+
+  const raw = JSON.parse(readFileSync(islandsJsonPath, 'utf8')) as RawIslandEntry[]
+
+  const enriched: EnrichedIslandEntry[] = raw.map((entry) => {
+    const sourcePath = pageImports.get(entry.component)
+    if (!sourcePath) {
+      throw new Error(
+        `island component "${entry.component}" in native route "${routeName}" has no matching import in the page source (expected \`import ${entry.component} from "..."\`)`,
+      )
+    }
+    return { ...entry, sourcePath }
+  })
+
+  writeFileSync(islandsJsonPath, JSON.stringify(enriched))
+
+  const baked = `{% raw %}${ISLANDS_IMPORTMAP_AND_BOOTSTRAP}{% endraw %}`
+  writeFileSync(jinjaPath, readFileSync(jinjaPath, 'utf8') + baked)
+}

package/runtime/cli/native-shim-plugin.ts

@@ -0,0 +1,85 @@
+import { resolve } from 'node:path'
+import type { BunPlugin } from 'bun'
+
+/** Bun.build plugin that replaces `runtime/index.js` (the napi-rs platform
+ * shim, 469 lines of conditional require()s) with a single shim that resolves
+ * the native binary from `BRUST_DIST_DIR/native/brust.<platform>-<arch>[-libc].node`.
+ *
+ * The shim relies on the bundle banner having set BRUST_DIST_DIR; if that env
+ * is missing (shouldn't happen post-build) it falls back to import.meta.dir.
+ *
+ * Linux: napi emits a libc-suffixed name (brust.linux-x64-gnu.node / -musl);
+ * darwin/win have no suffix. The shim detects musl-vs-glibc (via process.report,
+ * the same signal the full napi loader uses) to order candidates, then falls
+ * back to the other libc so a single-platform dist still loads even if detection
+ * is off. */
+export function nativeShimPlugin(repoRoot: string): BunPlugin {
+  const targetPath = resolve(repoRoot, 'runtime/index.js')
+
+  const SHIM = `
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+
+const require_ = createRequire(import.meta.url)
+const { platform, arch } = process
+const dir = process.env.BRUST_DIST_DIR ?? import.meta.dir
+
+// Detect musl via process.report: glibc runtimes report glibcVersionRuntime in
+// the report header, musl does not. Mirrors the full napi loader's signal.
+function linuxIsMusl() {
+  try {
+    if (typeof process.report?.getReport === 'function') {
+      process.report.excludeNetwork = true
+      const report = process.report.getReport()
+      return !(report && report.header && report.header.glibcVersionRuntime)
+    }
+  } catch {}
+  return false
+}
+
+// Candidate binary names in load order. Linux is libc-suffixed (detected libc
+// first, the other as fallback); darwin/win are bare platform-arch.
+let candidates
+if (platform === 'linux') {
+  const libc = linuxIsMusl() ? 'musl' : 'gnu'
+  const other = libc === 'musl' ? 'gnu' : 'musl'
+  candidates = [\`brust.linux-\${arch}-\${libc}.node\`, \`brust.linux-\${arch}-\${other}.node\`]
+} else {
+  candidates = [\`brust.\${platform}-\${arch}.node\`]
+}
+
+let nativeBinding
+const tried = []
+for (const name of candidates) {
+  const absPath = join(dir, 'native', name)
+  try {
+    nativeBinding = require_(absPath)
+    break
+  } catch (cause) {
+    tried.push(\`\${absPath} (\${cause && cause.message ? cause.message : cause})\`)
+  }
+}
+if (!nativeBinding) {
+  throw new Error(
+    \`brust: no native binary for \${platform}-\${arch}. Tried:\\n  \` +
+    tried.join('\\n  ') +
+    \`\\nRun \\\`brust build\\\` on the target platform.\`,
+  )
+}
+
+module.exports = nativeBinding
+`.trim()
+
+  return {
+    name: 'brust-native-shim',
+    setup(build) {
+      build.onLoad({ filter: /.*runtime[\\/]index\.js$/ }, (args) => {
+        // Only rewrite the canonical napi-rs shim; ignore any same-named file
+        // elsewhere in node_modules (Bun resolves real paths, so this guard
+        // is just belt-and-braces).
+        if (args.path !== targetPath) return undefined
+        return { contents: SHIM, loader: 'js' }
+      })
+    },
+  }
+}