peachsim 0.1.527

package/src/metro-fingerprint-registry.ts

@@ -0,0 +1,302 @@
+export const RNX_METRO_FINGERPRINT_SCHEMA_VERSION = 2
+export const RNX_METRO_FINGERPRINT_POINTER_PATH = '/compile/metro-fingerprints.json'
+export const RNX_METRO_FINGERPRINT_MAX_POINTER_BYTES = 16 * 1024
+export const RNX_METRO_FINGERPRINT_MAX_PAYLOAD_BYTES = 8 * 1024 * 1024
+
+export type RNXMetroFingerprintPlatform = 'ios' | 'android'
+
+export interface RNXMetroFingerprintAtom {
+  key: string
+  exports: string[]
+  literals: string[]
+  dependencyArity: number
+  factoryDigest: string
+}
+
+export interface RNXMetroFingerprintNode {
+  atom: number
+  internalDependencies: Array<{ position: number; node: number }>
+  landmarkPath?: string
+}
+
+export interface RNXMetroFingerprintRoot {
+  node: number
+}
+
+export interface RNXMetroFingerprintTemplate {
+  packageName: string
+  packageVersion: string
+  sourceIntegrity: string
+  profile: string
+  platform: RNXMetroFingerprintPlatform
+  nodes: RNXMetroFingerprintNode[]
+  roots: RNXMetroFingerprintRoot[]
+}
+
+export interface RNXMetroFingerprintCandidate {
+  template: number
+  root: number
+}
+
+export interface RNXMetroFingerprintRegistry {
+  schemaVersion: typeof RNX_METRO_FINGERPRINT_SCHEMA_VERSION
+  revision: string
+  atoms: RNXMetroFingerprintAtom[]
+  templates: RNXMetroFingerprintTemplate[]
+  candidatesByFactoryDigest: Record<string, RNXMetroFingerprintCandidate[]>
+  candidatesByDiscriminator: Record<string, RNXMetroFingerprintCandidate[]>
+}
+
+export interface RNXMetroFingerprintPointer {
+  schemaVersion: typeof RNX_METRO_FINGERPRINT_SCHEMA_VERSION
+  revision: string
+  integrity: string
+  bytes: number
+  payloadUrl: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isSha256(value: unknown): value is string {
+  return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value)
+}
+
+function readStringArray(value: unknown): string[] | null {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === 'string')) {
+    return null
+  }
+  const entries = [...value]
+  if (
+    new Set(entries).size !== entries.length ||
+    entries.some((entry, index) => index > 0 && entries[index - 1] >= entry)
+  ) {
+    return null
+  }
+  return entries
+}
+
+export function parseRNXMetroFingerprintPointer(
+  value: unknown,
+): RNXMetroFingerprintPointer | null {
+  if (!isRecord(value)) return null
+  const { schemaVersion, revision, integrity, bytes, payloadUrl } = value
+  if (
+    schemaVersion !== RNX_METRO_FINGERPRINT_SCHEMA_VERSION ||
+    !isSha256(revision) ||
+    !isSha256(integrity) ||
+    typeof bytes !== 'number' ||
+    !Number.isSafeInteger(bytes) ||
+    bytes < 1 ||
+    typeof payloadUrl !== 'string' ||
+    payloadUrl.length === 0
+  ) {
+    return null
+  }
+  return { schemaVersion, revision, integrity, bytes, payloadUrl }
+}
+
+export function parseRNXMetroFingerprintRegistry(
+  value: unknown,
+): RNXMetroFingerprintRegistry | null {
+  if (!isRecord(value)) return null
+  const { schemaVersion, revision } = value
+  if (
+    schemaVersion !== RNX_METRO_FINGERPRINT_SCHEMA_VERSION ||
+    !isSha256(revision) ||
+    !Array.isArray(value.atoms) ||
+    !Array.isArray(value.templates) ||
+    !isRecord(value.candidatesByFactoryDigest) ||
+    !isRecord(value.candidatesByDiscriminator)
+  ) {
+    return null
+  }
+
+  const atoms: RNXMetroFingerprintAtom[] = []
+  for (const atomValue of value.atoms) {
+    if (!isRecord(atomValue)) return null
+    const exports = readStringArray(atomValue.exports)
+    const literals = readStringArray(atomValue.literals)
+    if (
+      typeof atomValue.key !== 'string' ||
+      atomValue.key.length === 0 ||
+      !exports ||
+      !literals ||
+      typeof atomValue.dependencyArity !== 'number' ||
+      !Number.isSafeInteger(atomValue.dependencyArity) ||
+      atomValue.dependencyArity < 0 ||
+      !isSha256(atomValue.factoryDigest)
+    ) {
+      return null
+    }
+    atoms.push({
+      key: atomValue.key,
+      exports,
+      literals,
+      dependencyArity: atomValue.dependencyArity,
+      factoryDigest: atomValue.factoryDigest,
+    })
+  }
+
+  const templates: RNXMetroFingerprintTemplate[] = []
+  for (const templateValue of value.templates) {
+    if (
+      !isRecord(templateValue) ||
+      typeof templateValue.packageName !== 'string' ||
+      templateValue.packageName.length === 0 ||
+      typeof templateValue.packageVersion !== 'string' ||
+      templateValue.packageVersion.length === 0 ||
+      !isSha256(templateValue.sourceIntegrity) ||
+      typeof templateValue.profile !== 'string' ||
+      templateValue.profile.length === 0 ||
+      (templateValue.platform !== 'ios' && templateValue.platform !== 'android') ||
+      !Array.isArray(templateValue.nodes) ||
+      templateValue.nodes.length === 0 ||
+      !Array.isArray(templateValue.roots) ||
+      templateValue.roots.length === 0
+    ) {
+      return null
+    }
+    const nodes: RNXMetroFingerprintNode[] = []
+    for (const nodeValue of templateValue.nodes) {
+      if (
+        !isRecord(nodeValue) ||
+        typeof nodeValue.atom !== 'number' ||
+        !Number.isSafeInteger(nodeValue.atom) ||
+        nodeValue.atom < 0 ||
+        nodeValue.atom >= atoms.length ||
+        !Array.isArray(nodeValue.internalDependencies) ||
+        (nodeValue.landmarkPath !== undefined &&
+          (typeof nodeValue.landmarkPath !== 'string' ||
+            nodeValue.landmarkPath.length === 0))
+      ) {
+        return null
+      }
+      const internalDependencies: Array<{ position: number; node: number }> = []
+      const positions = new Set<number>()
+      for (const edgeValue of nodeValue.internalDependencies) {
+        if (
+          !isRecord(edgeValue) ||
+          typeof edgeValue.position !== 'number' ||
+          !Number.isSafeInteger(edgeValue.position) ||
+          edgeValue.position < 0 ||
+          positions.has(edgeValue.position) ||
+          typeof edgeValue.node !== 'number' ||
+          !Number.isSafeInteger(edgeValue.node) ||
+          edgeValue.node < 0 ||
+          edgeValue.node >= templateValue.nodes.length
+        ) {
+          return null
+        }
+        positions.add(edgeValue.position)
+        internalDependencies.push({
+          position: edgeValue.position,
+          node: edgeValue.node,
+        })
+      }
+      internalDependencies.sort((left, right) => left.position - right.position)
+      nodes.push({
+        atom: nodeValue.atom,
+        internalDependencies,
+        ...(typeof nodeValue.landmarkPath === 'string'
+          ? { landmarkPath: nodeValue.landmarkPath }
+          : {}),
+      })
+    }
+    const roots: RNXMetroFingerprintRoot[] = []
+    for (const rootValue of templateValue.roots) {
+      if (
+        !isRecord(rootValue) ||
+        typeof rootValue.node !== 'number' ||
+        !Number.isSafeInteger(rootValue.node) ||
+        rootValue.node < 0 ||
+        rootValue.node >= nodes.length ||
+        !nodes[rootValue.node].landmarkPath
+      ) {
+        return null
+      }
+      roots.push({ node: rootValue.node })
+    }
+    templates.push({
+      packageName: templateValue.packageName,
+      packageVersion: templateValue.packageVersion,
+      sourceIntegrity: templateValue.sourceIntegrity,
+      profile: templateValue.profile,
+      platform: templateValue.platform,
+      nodes,
+      roots,
+    })
+  }
+
+  const candidatesByFactoryDigest: Record<string, RNXMetroFingerprintCandidate[]> = {}
+  for (const [factoryDigest, candidateValues] of Object.entries(
+    value.candidatesByFactoryDigest,
+  )) {
+    if (!isSha256(factoryDigest) || !Array.isArray(candidateValues)) return null
+    const candidates: RNXMetroFingerprintCandidate[] = []
+    for (const candidateValue of candidateValues) {
+      if (
+        !isRecord(candidateValue) ||
+        typeof candidateValue.template !== 'number' ||
+        !Number.isSafeInteger(candidateValue.template) ||
+        candidateValue.template < 0 ||
+        candidateValue.template >= templates.length ||
+        typeof candidateValue.root !== 'number' ||
+        !Number.isSafeInteger(candidateValue.root) ||
+        candidateValue.root < 0 ||
+        candidateValue.root >= templates[candidateValue.template].roots.length
+      ) {
+        return null
+      }
+      const template = templates[candidateValue.template]
+      const root = template.roots[candidateValue.root]
+      if (atoms[template.nodes[root.node].atom].factoryDigest !== factoryDigest) {
+        return null
+      }
+      candidates.push({
+        template: candidateValue.template,
+        root: candidateValue.root,
+      })
+    }
+    candidatesByFactoryDigest[factoryDigest] = candidates
+  }
+
+  const candidatesByDiscriminator: Record<string, RNXMetroFingerprintCandidate[]> = {}
+  for (const [discriminator, candidateValues] of Object.entries(
+    value.candidatesByDiscriminator,
+  )) {
+    if (!/^(?:e|l|ea|la|el|ela):[a-f0-9]{16}$/.test(discriminator)) return null
+    if (!Array.isArray(candidateValues) || candidateValues.length === 0) return null
+    const candidates: RNXMetroFingerprintCandidate[] = []
+    for (const candidateValue of candidateValues) {
+      if (
+        !isRecord(candidateValue) ||
+        typeof candidateValue.template !== 'number' ||
+        !Number.isSafeInteger(candidateValue.template) ||
+        candidateValue.template < 0 ||
+        candidateValue.template >= templates.length ||
+        typeof candidateValue.root !== 'number' ||
+        !Number.isSafeInteger(candidateValue.root) ||
+        candidateValue.root < 0 ||
+        candidateValue.root >= templates[candidateValue.template].roots.length
+      ) {
+        return null
+      }
+      candidates.push({
+        template: candidateValue.template,
+        root: candidateValue.root,
+      })
+    }
+    candidatesByDiscriminator[discriminator] = candidates
+  }
+
+  return {
+    schemaVersion,
+    revision,
+    atoms,
+    templates,
+    candidatesByFactoryDigest,
+    candidatesByDiscriminator,
+  }
+}

package/src/metro-plugin.ts

@@ -0,0 +1,341 @@
+// rnx metro plugin for dev shell and bundle module identity annotation.
+// shell assets come from an engine runtime under ~/.rnx/runtimes/, fetched
+// by `rnx runtime install`. 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 { withRNX } = require('rnxsim/metro')
+//   module.exports = withRNX(getDefaultConfig(__dirname))
+
+import fs from 'fs'
+import { createRequire } from 'module'
+import { randomUUID } from 'node:crypto'
+import path from 'path'
+import { tagRnxBundleForPlugin } from './dev-server-open'
+import {
+  handleReplacementModuleRequest,
+  isReplacementModuleRequestUrl,
+} from './host/replacement-module-handler'
+import {
+  appendRNXMetroModuleIdentityFooter,
+  RNX_METRO_MODULE_IDENTITY_VERSION,
+  toRNXDevelopmentBundleUrl,
+  toRNXProductionBundleUrl,
+  type RNXMetroModuleIdentityMetadata,
+} from './metro-production-bundle'
+import {
+  isRootRuntimeAssetPath,
+  resolveRuntimeFilePath,
+  resolveRuntimeRootForRequestHost,
+  serveRuntimeFile,
+  SOOTSIM_RUNTIME_MISSING_MESSAGE,
+} from './runtime-assets'
+
+const prefix = '/__soot'
+export { toRNXDevelopmentBundleUrl, toRNXProductionBundleUrl }
+
+type MetroSerializerModule = {
+  path: string
+  dependencies?: ReadonlyMap<
+    string,
+    {
+      absolutePath?: string
+      data?: { name?: string }
+    }
+  >
+}
+
+type MetroSerializerGraph = {
+  dependencies?: ReadonlyMap<unknown, MetroSerializerModule>
+}
+
+type MetroSerializerOptions = {
+  createModuleId?: (modulePath: string) => number
+  dev?: boolean
+  [key: string]: unknown
+}
+
+type MetroSerializerResult = string | { code: string; map: string }
+
+type MetroSerializer = (
+  entryPoint: string,
+  preModules: readonly unknown[],
+  graph: MetroSerializerGraph,
+  options: MetroSerializerOptions,
+) => MetroSerializerResult | Promise<MetroSerializerResult>
+
+type MetroConfigWithServer = {
+  projectRoot?: string
+  serializer?: {
+    customSerializer?: MetroSerializer
+    [key: string]: unknown
+  }
+  server?: {
+    enhanceMiddleware?: (middleware: unknown, server: unknown) => unknown
+    port?: number
+    [key: string]: unknown
+  }
+}
+
+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
+  }
+}
+
+// the only thing rnx adds to an ordinary Metro bundle. production needs the
+// footer because Metro drops the fourth `__d` argument when `dev` is false;
+// development keeps that verbose name and receives the same identity without
+// changing resolution, transforms, or the trailing source map.
+function appendRNXModulePaths(
+  result: MetroSerializerResult,
+  graph: MetroSerializerGraph,
+  options: MetroSerializerOptions,
+  projectRoot: string,
+): MetroSerializerResult {
+  const dependencies = graph.dependencies
+  const createModuleId = options.createModuleId
+  if (!dependencies || !createModuleId) {
+    return result
+  }
+
+  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: bundle module IDs were not unique')
+  }
+
+  const specifiersByModuleId = new Map<string, Set<string>>()
+  for (const module of dependencies.values()) {
+    for (const [dependencyKey, dependency] of module.dependencies ?? []) {
+      const specifier = dependency.data?.name ?? dependencyKey
+      if (
+        specifier.length === 0 ||
+        specifier.startsWith('.') ||
+        specifier.startsWith('/') ||
+        typeof dependency.absolutePath !== 'string'
+      ) {
+        continue
+      }
+      const moduleId = String(createModuleId(dependency.absolutePath))
+      if (!Object.prototype.hasOwnProperty.call(modulePaths, moduleId)) continue
+      const found = specifiersByModuleId.get(moduleId)
+      if (found) found.add(specifier)
+      else specifiersByModuleId.set(moduleId, new Set([specifier]))
+    }
+  }
+  const logicalSpecifiers = Object.fromEntries(
+    [...specifiersByModuleId]
+      .sort(([left], [right]) => Number(left) - Number(right))
+      .map(([moduleId, specifiers]) => [moduleId, [...specifiers].sort()]),
+  )
+  const identity: RNXMetroModuleIdentityMetadata = {
+    version: RNX_METRO_MODULE_IDENTITY_VERSION,
+    identitySource: 'rnx-plugin',
+    modulePaths,
+    logicalSpecifiers,
+  }
+  return typeof result === 'string'
+    ? appendRNXMetroModuleIdentityFooter(result, identity)
+    : { ...result, code: appendRNXMetroModuleIdentityFooter(result.code, identity) }
+}
+
+export function withRNX<T extends Record<string, unknown>>(config: T): T {
+  const cfgProjectRoot = (config as MetroConfigWithServer).projectRoot || process.cwd()
+  const configuredBundleUrl = '/index.bundle?platform=ios&dev=true&hot=true&minify=false'
+
+  const cfgServer = (config as MetroConfigWithServer).server
+  const port = resolveMetroPort(cfgServer)
+  const metroServerId = randomUUID()
+  const bundleUrl = tagRnxBundleForPlugin(
+    configuredBundleUrl,
+    `http://localhost:${port}`,
+    metroServerId,
+    cfgProjectRoot,
+  )
+  const cfgSerializer = (config as MetroConfigWithServer).serializer
+  const existingEnhance = cfgServer?.enhanceMiddleware
+  const existingSerializer = cfgSerializer?.customSerializer
+
+  let defaultSerializer: MetroSerializer | undefined
+
+  const serializerConfig = {
+    serializer: {
+      ...cfgSerializer,
+      customSerializer: async (
+        entryPoint: string,
+        preModules: readonly unknown[],
+        graph: MetroSerializerGraph,
+        serializerOptions: MetroSerializerOptions,
+      ) => {
+        const serializer =
+          existingSerializer ||
+          (defaultSerializer ||= createMetroDefaultSerializer(cfgProjectRoot))
+        const result = await serializer(entryPoint, preModules, graph, serializerOptions)
+        return appendRNXModulePaths(result, graph, serializerOptions, cfgProjectRoot)
+      },
+    },
+  }
+
+  const serverConfig = {
+    ...cfgServer,
+    enhanceMiddleware: (metroMiddleware: any, metroServer: any) => {
+      let middleware = metroMiddleware
+      if (existingEnhance) {
+        middleware = existingEnhance(metroMiddleware, metroServer)
+      }
+
+      let connect: any
+      try {
+        connect = require('connect')
+      } catch {
+        console.warn('[rnx] connect not available')
+        return middleware
+      }
+
+      const server = connect()
+
+      server.use((req: any, res: any, next: any) => {
+        if (isReplacementModuleRequestUrl(req.url)) {
+          void handleReplacementModuleRequest(req, res, {
+            projectRoot: cfgProjectRoot,
+            requestToken: metroServerId,
+            requireLoopbackOrigin: true,
+          }).then((handled) => {
+            if (!handled) next()
+          })
+          return
+        }
+
+        const url = req.url || ''
+        const pathname = url.split('?')[0]
+
+        const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers?.host)
+
+        if (!runtimeRoot) {
+          if (pathname === prefix || pathname === prefix + '/') {
+            res.statusCode = 500
+            res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE)
+            return
+          }
+          next()
+          return
+        }
+
+        // root-relative runtime assets emitted by the shell and engine vite
+        // builds. if a user app has its own /assets/foo request, we only
+        // intercept when that exact file exists in the runtime; otherwise
+        // metro handles it normally.
+        if (isRootRuntimeAssetPath(pathname)) {
+          const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname)
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath)
+            return
+          }
+        }
+
+        // /__soot/* — serve runtime assets
+        if (pathname.startsWith(prefix + '/')) {
+          const fullPath = resolveRuntimeFilePath(
+            runtimeRoot,
+            pathname.slice(prefix.length),
+          )
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath)
+            return
+          }
+        }
+
+        // serve HTML shell for /__soot and extensionless in-shell routes.
+        if (
+          pathname === prefix ||
+          pathname === prefix + '/' ||
+          pathname.startsWith(prefix + '/')
+        ) {
+          const ext = path.extname(pathname)
+          if (!ext) {
+            const htmlPath = path.join(runtimeRoot, 'index.html')
+            let html = fs.readFileSync(htmlPath, 'utf8')
+            const script = `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleUrl)});history.replaceState(null,'','${prefix}/'+u.search)})()</script>`
+            html = html.includes('</head>')
+              ? html.replace('</head>', `${script}</head>`)
+              : `${html}${script}`
+            res.setHeader('content-type', 'text/html')
+            res.end(html)
+            return
+          }
+        }
+
+        next()
+      })
+
+      server.use(middleware)
+
+      console.log(`[rnx] serving at ${prefix}/`)
+      return server
+    },
+  }
+
+  return {
+    ...config,
+    ...serializerConfig,
+    server: serverConfig,
+  } as T
+}
+
+function resolveMetroPort(server: MetroConfigWithServer['server']): number {
+  const inlinePort = process.argv.find((arg) => arg.startsWith('--port='))?.slice(7)
+  const portIndex = process.argv.indexOf('--port')
+  const splitPort = portIndex >= 0 ? process.argv[portIndex + 1] : undefined
+  const rawPort =
+    inlinePort || splitPort || process.env.RCT_METRO_PORT || server?.port || 8081
+  const port = Number(rawPort)
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`rnx: Metro port must be a positive integer, got ${rawPort}`)
+  }
+  return port
+}
+
+export default withRNX