rnxsim 0.1.335 → 0.1.337

package/src/metro-plugin.ts

@@ -1,15 +1,21 @@
-// sootsim metro plugin — serves the sootsim shell at /__soot/ on metro's server.
+// rnx metro plugin for opt-in dev shell and production bundle integration.
 // shell assets come from an engine runtime under ~/.sootsim/runtimes/, fetched
 // by `sootsim runtime install` / `sootsim setup`. ordinary localhost requests
 // follow active; a version-owned localhost origin stays on its exact directory
 // when active changes, so one loaded shell cannot mix runtime chunk trees.
 //
 // usage in metro.config.js:
-//   const { withSootsim } = require('sootsim/metro')
-//   module.exports = withSootsim(getDefaultConfig(__dirname))
+//   const { withRNX } = require('rnxsim/metro')
+//   module.exports = withRNX(getDefaultConfig(__dirname), { devServer: true })
 
 import fs from 'fs'
+import { createRequire } from 'module'
 import path from 'path'
+import {
+  RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION,
+  createRNXMetroModulePathsFooter,
+  toRNXProductionBundleUrl,
+} from './metro-production-bundle'
 import {
   isRootRuntimeAssetPath,
   resolveRuntimeFilePath,
@@ -19,32 +25,260 @@ import {
 } from './runtime-assets'
 
 const prefix = '/__soot'
+export { toRNXProductionBundleUrl }
+
+const hostModuleSpecifiers = [
+  'react',
+  'react-dom',
+  'react/jsx-runtime',
+  'react/jsx-dev-runtime',
+  'react-native',
+  'react-native-web',
+] as const
+
+type MetroResolverContext = {
+  customResolverOptions?: Record<string, unknown>
+  resolveRequest: MetroResolver
+}
+
+type MetroResolution = {
+  type: string
+  filePath?: string
+  [key: string]: unknown
+}
+
+type MetroResolver = (
+  context: MetroResolverContext,
+  moduleName: string,
+  platform: string | null,
+) => MetroResolution
+
+type MetroSerializerGraph = {
+  dependencies?: ReadonlyMap<unknown, { path: string }>
+  transformOptions?: {
+    dev?: boolean
+    customTransformOptions?: Record<string, unknown>
+  }
+}
+
+type MetroSerializerOptions = {
+  createModuleId?: (modulePath: string) => number
+  dev?: boolean
+  [key: string]: unknown
+}
+
+type MetroSerializerResult = string | { code: string; map: string }
 
-export interface SootsimMetroOptions {
+type MetroSerializer = (
+  entryPoint: string,
+  preModules: readonly unknown[],
+  graph: MetroSerializerGraph,
+  options: MetroSerializerOptions,
+) => MetroSerializerResult | Promise<MetroSerializerResult>
+
+export interface RNXMetroOptions {
   bundleUrl?: string
-  enabled?: boolean
+  devServer?: boolean
+  productionBundles?: boolean
 }
 
 // the slice of metro's config we touch — keeps `T` open for whatever
 // shape consumers pass while letting us extend `server.enhanceMiddleware`.
 type MetroConfigWithServer = {
+  projectRoot?: string
+  watchFolders?: readonly string[]
+  resolver?: {
+    resolveRequest?: MetroResolver
+    [key: string]: unknown
+  }
+  serializer?: {
+    customSerializer?: MetroSerializer
+    [key: string]: unknown
+  }
   server?: {
     enhanceMiddleware?: (middleware: unknown, server: unknown) => unknown
     [key: string]: unknown
   }
 }
 
-export function withSootsim<T extends Record<string, unknown>>(
+function isRNXProductionBundle(graph: MetroSerializerGraph): boolean {
+  return (
+    graph.transformOptions?.dev === false &&
+    graph.transformOptions.customTransformOptions?.[
+      RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION
+    ] === 'true'
+  )
+}
+
+function assertProductionEnvironment(): void {
+  if (process.env.NODE_ENV === 'production') return
+  throw new Error(
+    'rnxsim: production bundle requests require NODE_ENV=production; restart Metro with NODE_ENV=production',
+  )
+}
+
+function hostModuleFileName(specifier: (typeof hostModuleSpecifiers)[number]): string {
+  return `${specifier.replaceAll('/', '__')}.js`
+}
+
+function resolveHostModules(): { root: string; files: ReadonlyMap<string, string> } {
+  const root = path.join(__dirname, 'metro-host-modules')
+  const files = new Map<string, string>()
+
+  for (const specifier of hostModuleSpecifiers) {
+    const filePath = path.join(root, hostModuleFileName(specifier))
+    files.set(specifier, filePath)
+  }
+
+  return { root, files }
+}
+
+function readCallableMetroExport(
+  moduleValue: unknown,
+  label: string,
+): (...args: readonly unknown[]) => unknown {
+  const callable =
+    typeof moduleValue === 'function'
+      ? moduleValue
+      : typeof moduleValue === 'object' && moduleValue !== null
+        ? Reflect.get(moduleValue, 'default')
+        : undefined
+  if (typeof callable !== 'function') {
+    throw new Error(`rnxsim: Metro ${label} module did not export a function`)
+  }
+  return (...args) => Reflect.apply(callable, undefined, args)
+}
+
+function createMetroDefaultSerializer(projectRoot: string): MetroSerializer {
+  const projectRequire = createRequire(path.join(projectRoot, 'package.json'))
+  const metroRoot = path.dirname(projectRequire.resolve('metro/package.json'))
+  const baseJSBundle = readCallableMetroExport(
+    projectRequire(path.join(metroRoot, 'src/DeltaBundler/Serializers/baseJSBundle.js')),
+    'baseJSBundle',
+  )
+  const bundleToString = readCallableMetroExport(
+    projectRequire(path.join(metroRoot, 'src/lib/bundleToString.js')),
+    'bundleToString',
+  )
+
+  return (entryPoint, preModules, graph, options) => {
+    const serialized = bundleToString(
+      baseJSBundle(entryPoint, preModules, graph, options),
+    )
+    const code =
+      typeof serialized === 'object' && serialized !== null
+        ? Reflect.get(serialized, 'code')
+        : undefined
+    if (typeof code !== 'string') {
+      throw new Error('rnxsim: Metro bundleToString did not return bundle code')
+    }
+    return code
+  }
+}
+
+function prependRNXModulePaths(
+  result: MetroSerializerResult,
+  graph: MetroSerializerGraph,
+  options: MetroSerializerOptions,
+  projectRoot: string,
+): MetroSerializerResult {
+  const dependencies = graph.dependencies
+  const createModuleId = options.createModuleId
+  if (!dependencies || !createModuleId) {
+    throw new Error(
+      'rnxsim: Metro did not provide the production module graph and createModuleId',
+    )
+  }
+
+  const modulePaths: Record<string, string> = {}
+  for (const module of dependencies.values()) {
+    modulePaths[String(createModuleId(module.path))] = path
+      .relative(projectRoot, module.path)
+      .replaceAll(path.sep, '/')
+  }
+  if (Object.keys(modulePaths).length !== dependencies.size) {
+    throw new Error('rnxsim: production module IDs were not unique')
+  }
+
+  const footer = createRNXMetroModulePathsFooter(modulePaths)
+  return typeof result === 'string'
+    ? result + footer
+    : { ...result, code: result.code + footer }
+}
+
+export function withRNX<T extends Record<string, unknown>>(
   config: T,
-  options: SootsimMetroOptions = {},
+  options: RNXMetroOptions = {},
 ): T {
-  if (options.enabled === false) return config
+  if (!options.devServer && !options.productionBundles) return config
 
   const bundleUrl =
     options.bundleUrl || '/index.bundle?platform=ios&dev=true&hot=true&minify=false'
 
   const cfgServer = (config as MetroConfigWithServer).server
+  const cfgResolver = (config as MetroConfigWithServer).resolver
+  const cfgSerializer = (config as MetroConfigWithServer).serializer
+  const cfgProjectRoot = (config as MetroConfigWithServer).projectRoot || process.cwd()
   const existingEnhance = cfgServer?.enhanceMiddleware
+  const existingResolveRequest = cfgResolver?.resolveRequest
+  const existingSerializer = cfgSerializer?.customSerializer
+  let productionConfig: Partial<MetroConfigWithServer> = {}
+
+  if (options.productionBundles) {
+    const hostModules = resolveHostModules()
+    let defaultSerializer: MetroSerializer | undefined
+
+    productionConfig = {
+      watchFolders: [
+        ...((config as MetroConfigWithServer).watchFolders || []),
+        hostModules.root,
+      ],
+      resolver: {
+        ...cfgResolver,
+        resolveRequest: (
+          context: MetroResolverContext,
+          moduleName: string,
+          platform: string | null,
+        ) => {
+          if (
+            context.customResolverOptions?.[RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION] ===
+            'true'
+          ) {
+            assertProductionEnvironment()
+            const hostModule = hostModules.files.get(moduleName)
+            if (hostModule) return { type: 'sourceFile', filePath: hostModule }
+          }
+          return existingResolveRequest
+            ? existingResolveRequest(context, moduleName, platform)
+            : context.resolveRequest(context, moduleName, platform)
+        },
+      },
+      serializer: {
+        ...cfgSerializer,
+        customSerializer: async (
+          entryPoint: string,
+          preModules: readonly unknown[],
+          graph: MetroSerializerGraph,
+          serializerOptions: MetroSerializerOptions,
+        ) => {
+          const serializer =
+            existingSerializer ||
+            (defaultSerializer ||= createMetroDefaultSerializer(cfgProjectRoot))
+          const productionBundle = isRNXProductionBundle(graph)
+          if (productionBundle) assertProductionEnvironment()
+          const result = await serializer(
+            entryPoint,
+            preModules,
+            graph,
+            serializerOptions,
+          )
+          return productionBundle
+            ? prependRNXModulePaths(result, graph, serializerOptions, cfgProjectRoot)
+            : result
+        },
+      },
+    }
+  }
 
   const serverConfig = {
     ...cfgServer,
@@ -67,6 +301,7 @@ export function withSootsim<T extends Record<string, unknown>>(
       server.use((req: any, res: any, next: any) => {
         const url = req.url || ''
         const pathname = url.split('?')[0]
+
         const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers?.host)
 
         if (!runtimeRoot) {
@@ -133,7 +368,11 @@ export function withSootsim<T extends Record<string, unknown>>(
     },
   }
 
-  return { ...config, server: serverConfig } as T
+  return {
+    ...config,
+    ...productionConfig,
+    ...(options.devServer ? { server: serverConfig } : {}),
+  } as T
 }
 
-export default withSootsim
+export default withRNX

package/src/metro-production-bundle.ts

@@ -0,0 +1,51 @@
+export const RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION = 'rnxsim'
+const RNXSIM_METRO_MODULE_PATHS_PREFIX = 'globalThis.__sootsimModulePaths='
+
+export type RNXMetroModulePathMap = Record<string, string>
+export interface RNXMetroModuleIdentity {
+  source: string
+  modulePaths: RNXMetroModulePathMap
+}
+
+export function toRNXProductionBundleUrl(bundleUrl: string): string {
+  const relative = bundleUrl.startsWith('/')
+  const url = new URL(bundleUrl, 'http://rnxsim.local')
+  url.searchParams.set('dev', 'false')
+  url.searchParams.set('hot', 'false')
+  url.searchParams.set('minify', 'true')
+  url.searchParams.set(`resolver.${RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION}`, 'true')
+  url.searchParams.set(`transform.${RNXSIM_METRO_PRODUCTION_BUNDLE_OPTION}`, 'true')
+  return relative ? `${url.pathname}${url.search}${url.hash}` : url.toString()
+}
+
+export function createRNXMetroModulePathsFooter(
+  modulePaths: RNXMetroModulePathMap,
+): string {
+  const payload = JSON.stringify(modulePaths)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/<\//g, '<\\/')
+  return `\n${RNXSIM_METRO_MODULE_PATHS_PREFIX}${payload};`
+}
+
+export function readRNXMetroModuleIdentity(
+  bundleText: string,
+): RNXMetroModuleIdentity | null {
+  const footerPrefix = `\n${RNXSIM_METRO_MODULE_PATHS_PREFIX}`
+  const footerStart = bundleText.lastIndexOf(footerPrefix)
+  if (footerStart < 0 || !bundleText.endsWith(';')) return null
+
+  const parsed: unknown = JSON.parse(
+    bundleText.slice(footerStart + footerPrefix.length, -1),
+  )
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    return null
+  }
+
+  const modulePaths: RNXMetroModulePathMap = {}
+  for (const [moduleId, modulePath] of Object.entries(parsed)) {
+    if (typeof modulePath !== 'string') return null
+    modulePaths[moduleId] = modulePath
+  }
+  return { source: bundleText.slice(0, footerStart), modulePaths }
+}

package/src/public-brand.ts

@@ -3,7 +3,7 @@ const name = 'rnx'
 export const rnxPublicBrand = Object.freeze({
   name,
   packageName: 'rnxsim',
-  commandName: 'rnxsim',
+  commandName: 'rnx',
   domain: 'rnxsim.com',
   origin: 'https://rnxsim.com',
 })

package/src/react-native-host-modules.ts

@@ -0,0 +1,25 @@
+/**
+ * react-native specifiers whose upstream JavaScript must stay in a guest bundle.
+ *
+ * rnx owns the rest of the react-native package through its host-module registry.
+ * these modules instead run against globals installed by the simulator, which
+ * preserves upstream platform, style, event-emitter, and TurboModule behavior.
+ */
+export const REACT_NATIVE_PASSTHROUGH_SPECIFIERS: readonly string[] = [
+  'react-native/Libraries/vendor/emitter',
+  'react-native/Libraries/Components/View/ReactNativeStyleAttributes',
+  'react-native/Libraries/StyleSheet',
+  'react-native/Libraries/Utilities/differ',
+  'react-native/Libraries/Utilities/stringifySafe',
+  'react-native/src/private/featureflags',
+  'react-native/Libraries/TurboModule/TurboModuleRegistry',
+  'react-native/Libraries/Utilities/Platform',
+  'react-native/Libraries/Utilities/NativePlatformConstants',
+  'react-native/src/private/specs_DEPRECATED/modules/NativePlatformConstants',
+]
+
+export function isReactNativePassthroughSpecifier(specifier: string): boolean {
+  return REACT_NATIVE_PASSTHROUGH_SPECIFIERS.some(
+    (passthrough) => specifier === passthrough || specifier.startsWith(`${passthrough}/`),
+  )
+}

package/src/runtime-assets.ts

@@ -9,7 +9,7 @@ import { isValidRuntimeVersion } from '@contrast/runtime-delivery'
 import { readActiveRuntime, runtimeDir } from './home-paths.ts'
 
 export const SOOTSIM_RUNTIME_MISSING_MESSAGE =
-  '[rnx] no engine runtime installed — run `rnxsim setup`, or `rnxsim runtime install`'
+  '[rnx] no engine runtime installed — run `rnx setup`, or `rnx runtime install`'
 
 // --- dev-checkout mode boundary --------------------------------------------
 //

package/src/sim-client.ts

@@ -1,4 +1,4 @@
-// SimClient — the typed, promise-based client every rnxsim frontend drives a
+// SimClient — the typed, promise-based client every rnx frontend drives a
 // sim through. it wraps a bridge transport (the CLI's ws bridge, or any
 // InspectBridge-shaped channel) and reuses the existing inspect verbs as its
 // implementation; it never re-implements tap resolution, find, settling, or