peachsim 0.1.628 → 0.1.630

package/src/native-app-identity.ts

@@ -0,0 +1,376 @@
+// generic native app identity: the values an installed iOS/Android binary
+// carries, read from the app's own native project (`Info.plist` resolved
+// against the Xcode Release build settings, or `android/app/build.gradle`), so
+// a simulator tenant reports the same identity the native Release build does.
+//
+// the values travel in a footer a bundle builder appends to the artifact — the
+// same transport shape the Metro module identity footer already uses — and the
+// tenant boot reads it from the bundle text before the guest evaluates, then
+// stores it on the tenant realm for the native app-information seams. a bundle
+// with no native identity footer leaves every seam exactly where it was.
+
+export type NativeAppIdentityPlatform = 'ios' | 'android'
+
+export interface NativeAppIdentity {
+  applicationName: string | null
+  appVersion: string
+  buildVersion: string
+  bundleIdentifier: string
+  platform: NativeAppIdentityPlatform
+}
+
+export type NativeAppIdentityFiles = Record<string, string>
+
+const NATIVE_APP_IDENTITY_PREFIX = 'globalThis.__sootsimNativeAppIdentity='
+const METRO_MODULE_PATHS_PREFIX = 'globalThis.__sootsimModulePaths='
+const APPLIED_NATIVE_APP_IDENTITY_KEY = '__sootsim_native_app_identity'
+
+interface NativeAppIdentityGlobals {
+  __sootsim_native_app_identity?: NativeAppIdentity | null
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function nonEmptyString(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
+export function isNativeAppIdentity(value: unknown): value is NativeAppIdentity {
+  if (!isRecord(value)) return false
+  const platform = value.platform
+  if (platform !== 'ios' && platform !== 'android') return false
+  const applicationName = value.applicationName
+  if (applicationName !== null && nonEmptyString(applicationName) === null) return false
+  if (nonEmptyString(value.appVersion) === null) return false
+  if (nonEmptyString(value.bundleIdentifier) === null) return false
+  const buildVersion = nonEmptyString(value.buildVersion)
+  if (buildVersion === null) return false
+  if (platform === 'android' && !/^[1-9][0-9]*$/.test(buildVersion)) return false
+  return true
+}
+
+// read a host-supplied identity. absent/null clears it; a present value that is
+// neither is a contract violation the caller must not paper over.
+export function readNativeAppIdentity(value: unknown): NativeAppIdentity | null {
+  if (value === undefined || value === null) return null
+  if (!isNativeAppIdentity(value)) {
+    throw new Error('native app identity is malformed')
+  }
+  return {
+    applicationName: value.applicationName,
+    appVersion: value.appVersion,
+    buildVersion: value.buildVersion,
+    bundleIdentifier: value.bundleIdentifier,
+    platform: value.platform,
+  }
+}
+
+// the one realm store every seam reads. set by the tenant boot before the
+// guest evaluates, cleared on a boot without an identity so a previous app's
+// identity can never leak into the next load.
+export function applyNativeAppIdentity(identity: NativeAppIdentity | null): void {
+  const globals = globalThis as NativeAppIdentityGlobals
+  if (identity) globals.__sootsim_native_app_identity = identity
+  else delete globals.__sootsim_native_app_identity
+}
+
+export function getAppliedNativeAppIdentity(): NativeAppIdentity | null {
+  const value = (globalThis as NativeAppIdentityGlobals).__sootsim_native_app_identity
+  return isNativeAppIdentity(value) ? value : null
+}
+
+// one line, so the footer survives a bundle whose last statement is the Metro
+// module identity footer and can be found again by reading the text.
+export function createNativeAppIdentityFooter(identity: NativeAppIdentity): string {
+  const payload = JSON.stringify(identity)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/<\//g, '<\\/')
+  return `\n${NATIVE_APP_IDENTITY_PREFIX}${payload};`
+}
+
+function nativeAppIdentityFooterStart(source: string): number {
+  return source.lastIndexOf(`\n${NATIVE_APP_IDENTITY_PREFIX}`)
+}
+
+export function readNativeAppIdentityFooter(source: string): NativeAppIdentity | null {
+  const start = nativeAppIdentityFooterStart(source)
+  if (start < 0) return null
+  const lineEnd = source.indexOf('\n', start + 1)
+  const line = source.slice(start + 1, lineEnd < 0 ? undefined : lineEnd)
+  if (!line.endsWith(';')) {
+    throw new Error('native app identity footer is truncated')
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(line.slice(NATIVE_APP_IDENTITY_PREFIX.length, -1))
+  } catch {
+    throw new Error('native app identity footer is not valid JSON')
+  }
+  if (!isNativeAppIdentity(parsed)) {
+    throw new Error('native app identity footer is malformed')
+  }
+  return parsed
+}
+
+// remove the canonical footer from a bundle builder's input, returning the
+// identity it carried. the cloud artifact normalizer detaches before
+// minifying — a minifier rewrites the payload (`{key:…}`, joined statements) —
+// and reattaches the same canonical statement afterwards.
+export function detachNativeAppIdentityFooter(source: string): {
+  source: string
+  identity: NativeAppIdentity | null
+} {
+  const start = nativeAppIdentityFooterStart(source)
+  if (start < 0) return { source, identity: null }
+  const identity = readNativeAppIdentityFooter(source)
+  const lineEnd = source.indexOf('\n', start + 1)
+  const end = lineEnd < 0 ? source.length : lineEnd
+  return { source: source.slice(0, start) + source.slice(end), identity }
+}
+
+// insert the footer ahead of the Metro module identity footer when the bundle
+// carries one: readers of that contract slice the bundle at its start, and the
+// native identity has to stay in the text they hand to the guest. no footer
+// present (a development or legacy artifact) appends.
+export function insertNativeAppIdentityFooter(
+  source: string,
+  identity: NativeAppIdentity,
+): string {
+  const existing = nativeAppIdentityFooterStart(source)
+  const existingEnd =
+    existing < 0
+      ? -1
+      : source.includes('\n', existing + 1)
+        ? source.indexOf('\n', existing + 1)
+        : -1
+  const withoutExisting =
+    existing < 0
+      ? source
+      : source.slice(0, existing) +
+        source.slice(existingEnd < 0 ? source.length : existingEnd)
+  const moduleFooter = withoutExisting.lastIndexOf(`\n${METRO_MODULE_PATHS_PREFIX}`)
+  const footer = createNativeAppIdentityFooter(identity)
+  if (moduleFooter < 0) return withoutExisting + footer
+  return (
+    withoutExisting.slice(0, moduleFooter) + footer + withoutExisting.slice(moduleFooter)
+  )
+}
+
+// ── native project extraction ────────────────────────────────────────────────
+
+function plistString(plist: string, key: string): string | null {
+  const match = plist.match(new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`))
+  return match ? match[1].trim() : null
+}
+
+// Xcode build settings support `$(VAR)` references, so a plist value can only
+// be read against the settings of the configuration the binary ships with.
+// references recurse because a setting may itself reference another, and a
+// value whose reference cannot be fully resolved — an unknown variable or a
+// modifier this reader does not implement — is rejected rather than asserted.
+function resolveBuildSetting(
+  value: string,
+  settings: Record<string, string>,
+  depth = 0,
+): string | null {
+  if (depth > 8) return null
+  let unresolved = false
+  const resolved = value.replace(/\$\(([^()]+)\)/g, (_match, reference: string) => {
+    const separator = reference.indexOf(':')
+    if (separator >= 0) {
+      unresolved = true
+      return ''
+    }
+    const replacement = settings[reference]
+    if (replacement === undefined) {
+      unresolved = true
+      return ''
+    }
+    return replacement
+  })
+  if (unresolved) return null
+  if (resolved.includes('$(')) return resolveBuildSetting(resolved, settings, depth + 1)
+  return resolved
+}
+
+// an identity field is only usable when it is a real value: non-empty and free
+// of any unresolved build-setting syntax.
+function resolvedIdentityField(value: string | null): string | null {
+  const trimmed = value?.trim() ?? ''
+  if (!trimmed || trimmed.includes('$(')) return null
+  return trimmed
+}
+
+function identityFieldFrom(
+  settings: Record<string, string>,
+  raw: string | null,
+  fallbackSetting: string | undefined,
+): string | null {
+  if (raw !== null) return resolvedIdentityField(resolveBuildSetting(raw, settings))
+  return resolvedIdentityField(nonEmptyString(fallbackSetting ?? null))
+}
+
+function readBuildSettingsBlock(source: string, start: number): string {
+  // start is the index of `{`; walk to its matching close so nested arrays and
+  // dictionaries inside buildSettings stay part of the block.
+  let depth = 0
+  for (let index = start; index < source.length; index++) {
+    const character = source[index]
+    if (character === '{') depth++
+    else if (character === '}') {
+      depth--
+      if (depth === 0) return source.slice(start, index + 1)
+    }
+  }
+  return source.slice(start)
+}
+
+function parseBuildSettings(block: string): Record<string, string> {
+  const settings: Record<string, string> = {}
+  const matchPattern = /([A-Z0-9_]+) = ("(?:[^"\\]|\\.)*"|[^;{}]*);/g
+  let match: RegExpExecArray | null
+  while ((match = matchPattern.exec(block)) !== null) {
+    const raw = match[2].trim()
+    settings[match[1]] = raw.startsWith('"') ? raw.slice(1, -1) : raw.trim()
+  }
+  return settings
+}
+
+// the Release XCBuildConfiguration of the app target: the configuration whose
+// INFOPLIST_FILE is the plist being resolved, else the one whose PRODUCT_NAME
+// names the target directory. Debug settings (suffixes, dev bundle ids) must
+// never win.
+function appTargetReleaseSettings(
+  pbxproj: string,
+  targetName: string,
+  infoPlistRelativePath: string,
+): Record<string, string> | null {
+  const configurationPattern = /\/\* (Release|Debug) \*\/ = \{/g
+  const candidates: Array<{ name: string; settings: Record<string, string> }> = []
+  let match: RegExpExecArray | null
+  while ((match = configurationPattern.exec(pbxproj)) !== null) {
+    const blockStart = pbxproj.indexOf('{', match.index)
+    if (blockStart < 0) continue
+    const block = readBuildSettingsBlock(pbxproj, blockStart)
+    const buildSettingsStart = block.indexOf('buildSettings = {')
+    if (buildSettingsStart < 0) continue
+    const settings = parseBuildSettings(
+      readBuildSettingsBlock(block, block.indexOf('{', buildSettingsStart)),
+    )
+    candidates.push({ name: match[1], settings })
+  }
+  const plistMatch = (settings: Record<string, string>): boolean => {
+    const plist = settings.INFOPLIST_FILE
+    if (!plist) return false
+    const normalized = plist.replace(/^"|"$/g, '')
+    return (
+      normalized === infoPlistRelativePath ||
+      infoPlistRelativePath.endsWith(`/${normalized}`) ||
+      normalized.endsWith(`/${infoPlistRelativePath}`)
+    )
+  }
+  const named = (settings: Record<string, string>): boolean =>
+    resolveBuildSetting(settings.PRODUCT_NAME ?? '', settings) === targetName
+  return (
+    candidates.find(
+      (candidate) => candidate.name === 'Release' && plistMatch(candidate.settings),
+    )?.settings ??
+    candidates.find(
+      (candidate) => candidate.name === 'Release' && named(candidate.settings),
+    )?.settings ??
+    null
+  )
+}
+
+function nativeAppIdentityFromIos(
+  files: NativeAppIdentityFiles,
+): NativeAppIdentity | null {
+  const appDelegatePattern = /(?:^|\/)ios\/([^/]+)\/AppDelegate\.(?:swift|mm|m)$/
+  let targetName: string | null = null
+  for (const path of Object.keys(files)) {
+    if (path.includes('/Pods/')) continue
+    const match = path.match(appDelegatePattern)
+    if (match) {
+      targetName = match[1]
+      break
+    }
+  }
+  if (!targetName) return null
+
+  const plistPath = Object.keys(files).find(
+    (path) => path === `ios/${targetName}/Info.plist`,
+  )
+  const plist = plistPath ? files[plistPath] : null
+  if (!plist) return null
+
+  const pbxprojPath = Object.keys(files).find((path) =>
+    /(?:^|\/)ios\/[^/]+\.xcodeproj\/project\.pbxproj$/.test(path),
+  )
+  const settings = pbxprojPath
+    ? appTargetReleaseSettings(files[pbxprojPath], targetName, `${targetName}/Info.plist`)
+    : null
+  if (!settings) return null
+
+  const bundleIdentifier = identityFieldFrom(
+    settings,
+    plistString(plist, 'CFBundleIdentifier'),
+    settings.PRODUCT_BUNDLE_IDENTIFIER,
+  )
+  if (!bundleIdentifier) return null
+
+  const appVersion = identityFieldFrom(
+    settings,
+    plistString(plist, 'CFBundleShortVersionString'),
+    settings.MARKETING_VERSION,
+  )
+  const buildVersion = identityFieldFrom(
+    settings,
+    plistString(plist, 'CFBundleVersion'),
+    settings.CURRENT_PROJECT_VERSION,
+  )
+  if (!appVersion || !buildVersion) return null
+
+  const applicationName =
+    identityFieldFrom(settings, plistString(plist, 'CFBundleDisplayName'), undefined) ??
+    identityFieldFrom(
+      settings,
+      plistString(plist, 'CFBundleName'),
+      settings.PRODUCT_NAME,
+    ) ??
+    resolvedIdentityField(resolveBuildSetting(settings.PRODUCT_NAME ?? '', settings)) ??
+    resolvedIdentityField(targetName)
+  if (!applicationName) return null
+
+  return {
+    applicationName,
+    appVersion,
+    buildVersion,
+    bundleIdentifier,
+    platform: 'ios',
+  }
+}
+
+// Android's shipped identity requires resolving the selected flavor and
+// buildType overrides (`productFlavors.prod`, `buildTypes.release`), which a
+// text reader of `defaultConfig` cannot distinguish from the defaults it
+// overrides. an Android project therefore ships no footer until that
+// resolution exists — never a guessed identity.
+function nativeAppIdentityFromAndroid(): NativeAppIdentity | null {
+  return null
+}
+
+// read the identity a bundle builder transports. files are project-relative
+// paths to their text, so both a checked-out app directory and a stored
+// project file map resolve identically. null when the project carries no
+// resolvable native config — the builder then ships no footer.
+export function extractNativeAppIdentityFromFiles(
+  files: NativeAppIdentityFiles,
+  platform: NativeAppIdentityPlatform,
+): NativeAppIdentity | null {
+  return platform === 'android'
+    ? nativeAppIdentityFromAndroid()
+    : nativeAppIdentityFromIos(files)
+}

package/src/native-firebase-config.ts

@@ -0,0 +1,90 @@
+// the native installer reads Expo's googleServicesFile before Firebase starts.
+// expose only FirebaseOptions, never a partner-specific extra configuration.
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { isRecord } from './is-record'
+import { parsePlistSource } from './plist'
+
+export function readNativeFirebaseConfig(projectRoot: string) {
+  const result: Record<string, unknown> = {}
+  if (
+    ![
+      'app.json',
+      'app.config.js',
+      'app.config.ts',
+      'app.config.cjs',
+      'app.config.mjs',
+    ].some((name) => fs.existsSync(path.join(projectRoot, name)))
+  )
+    return result
+  const require = createRequire(path.join(projectRoot, 'package.json'))
+  const configModule: unknown = require('@expo/config')
+  if (!isRecord(configModule) || typeof configModule.getConfig !== 'function') {
+    throw new Error('Expo native configuration is unavailable.')
+  }
+  const resolved: unknown = Reflect.apply(configModule.getConfig, configModule, [
+    projectRoot,
+    { skipSDKVersionRequirement: true },
+  ])
+  const config = isRecord(resolved) && isRecord(resolved.exp) ? resolved.exp : {}
+  for (const platform of ['ios', 'android']) {
+    const native = config[platform]
+    if (!isRecord(native) || typeof native.googleServicesFile !== 'string') continue
+    try {
+      const source = fs.readFileSync(
+        path.resolve(projectRoot, native.googleServicesFile),
+        'utf8',
+      )
+      const parsed: unknown =
+        platform === 'ios' ? parsePlistSource(source) : JSON.parse(source)
+      if (!isRecord(parsed)) throw new Error('Invalid Google services file.')
+      if (platform === 'ios') {
+        result[platform] = {
+          apiKey: parsed.API_KEY,
+          appId: parsed.GOOGLE_APP_ID,
+          projectId: parsed.PROJECT_ID,
+          databaseURL: parsed.DATABASE_URL,
+          gaTrackingId: parsed.TRACKING_ID,
+          storageBucket: parsed.STORAGE_BUCKET,
+          messagingSenderId: parsed.GCM_SENDER_ID,
+          clientId: parsed.CLIENT_ID,
+          androidClientID: parsed.ANDROID_CLIENT_ID,
+          deepLinkUrlScheme: parsed.REVERSED_CLIENT_ID,
+        }
+      } else {
+        const project = isRecord(parsed.project_info) ? parsed.project_info : {}
+        const clients: unknown[] = Array.isArray(parsed.client) ? parsed.client : []
+        const client = clients.find((value) => {
+          if (!isRecord(value) || !isRecord(value.client_info)) return false
+          const android = value.client_info.android_client_info
+          return isRecord(android) && android.package_name === native.package
+        })
+        if (!isRecord(client) || !isRecord(client.client_info))
+          throw new Error('No Google services client matches the Android package.')
+        const apiKeys: unknown[] = Array.isArray(client.api_key) ? client.api_key : []
+        const apiKey = apiKeys.find(
+          (value) => isRecord(value) && typeof value.current_key === 'string',
+        )
+        const oauthClients: unknown[] = Array.isArray(client.oauth_client)
+          ? client.oauth_client
+          : []
+        const oauth = oauthClients.find(
+          (value) => isRecord(value) && value.client_type === 3,
+        )
+        result[platform] = {
+          apiKey: isRecord(apiKey) ? apiKey.current_key : undefined,
+          appId: client.client_info.mobilesdk_app_id,
+          projectId: project.project_id,
+          databaseURL: project.firebase_url,
+          storageBucket: project.storage_bucket,
+          messagingSenderId: project.project_number,
+          clientId: isRecord(oauth) ? oauth.client_id : undefined,
+        }
+      }
+    } catch (error) {
+      result[platform] = { error: error instanceof Error ? error.message : String(error) }
+    }
+  }
+  return result
+}

package/src/screenshots/frame-compose.ts

@@ -19,7 +19,7 @@ import {
   resolveDeviceFrameGeometry,
   type CornerRadii,
   type DeviceModel,
-} from 'peach-engine/settings'
+} from 'peach-engine/settings/devices'
 import { launchReapedChrome } from '../../../../scripts/lib/reap-browser'
 
 const METALLIC_RING_SHADOW =
@@ -90,7 +90,10 @@ export function getFramedScreenshotLayout(model: DeviceModel): FramedScreenshotL
   const modernGeometry = resolveDeviceFrameGeometry(spec)
   const housingLayers = isLegacyHardware
     ? null
-    : resolveHousingArt(spec.posture ?? 'closed', modernGeometry)
+    : resolveHousingArt(spec.posture ?? 'closed', modernGeometry, {
+        orientation: spec.orientation,
+        landscapeSide: spec.landscapeSide,
+      })
   const logicalFrameWidth = isLegacyHardware
     ? spec.width + LEGACY_SIDE_BEZEL * 2
     : modernGeometry.frameWidth

package/src/screenshots/registry.ts

@@ -6,7 +6,7 @@
 // this module re-exports those tokens plus the composer-specific
 // `FrameComposeSpec` shape.
 
-import type { DeviceModel } from 'peach-engine/settings'
+import type { DeviceModel } from 'peach-engine/settings/devices'
 
 export {
   BACKGROUND_PRESETS,

package/src/screenshots/schema.ts

@@ -1,7 +1,8 @@
 import { readFileSync } from 'fs'
 import path from 'path'
-import { devices, type DeviceModel } from 'peach-engine/settings'
+import { devices, type DeviceModel } from 'peach-engine/settings/devices'
 import yaml from 'yaml'
+import { isRecord } from '../is-record'
 import {
   cloneBackgroundSpec,
   DEFAULT_FRAME_SHADOW,
@@ -16,7 +17,6 @@ import {
   type PosePresetName,
   type TextPresetName,
 } from './registry'
-import { isRecord } from '../is-record'
 
 export type CaptureMode = 'raw' | 'framed' | 'raw+framed'
 export type CapturePathMode = 'auto' | 'plan' | 'flow'

package/src/vite-plugin-one.ts

@@ -41,8 +41,8 @@ const loadSwiftHost = () => (swiftHost ??= import('peachsim/vite-swift'))
 // the Kotlin host (toolchain fetch, compile, artifact serving) loads the same
 // way, on the first /__peach/kotlin request from an Android device
 const KOTLIN_ROUTE_PREFIX = '/__peach/kotlin'
-let kotlinHost: Promise<typeof import('peachsim/vite-kotlin')> | undefined
-const loadKotlinHost = () => (kotlinHost ??= import('peachsim/vite-kotlin'))
+let kotlinHost: Promise<typeof import('peachsim/kotlin-host')> | undefined
+const loadKotlinHost = () => (kotlinHost ??= import('peachsim/kotlin-host'))
 
 export function rnxPlugin(options: PeachPluginOptions = {}): Plugin {
   const prefix = options.prefix || '/__soot'
@@ -140,34 +140,17 @@ export function rnxPlugin(options: PeachPluginOptions = {}): Plugin {
         if (!pathname.startsWith(KOTLIN_ROUTE_PREFIX)) return next()
         loadKotlinHost()
           .then(async (host) => {
-            if (host.serveKotlinArtifact(pathname, res)) return
-            if (pathname !== '/__peach/kotlin-package') return next()
             if (!kotlinModuleRoot) {
-              const moduleRoot = path.join(
-                path.dirname(
-                  createRequire(path.join(server.config.root, 'package.json')).resolve(
-                    'peachsim/package.json',
-                  ),
-                ),
-                'kotlin',
-              )
-              kotlinModuleRoot = moduleRoot
-              server.watcher.add(path.join(moduleRoot, 'Sources'))
-            }
-            try {
-              const artifact = await host.kotlinArtifact(
-                server.config.root,
-                kotlinModuleRoot,
-                devOrigin(),
-              )
-              res.setHeader('access-control-allow-origin', '*')
-              res.setHeader('content-type', 'application/json')
-              res.end(JSON.stringify({ ...artifact, hmrPath }))
-            } catch (error) {
-              res.statusCode = 500
-              res.setHeader('access-control-allow-origin', '*')
-              res.end(error instanceof Error ? error.message : String(error))
+              kotlinModuleRoot = host.peachKotlinModuleRoot(server.config.root)
+              server.watcher.add(path.join(kotlinModuleRoot, 'Sources'))
             }
+            const served = await host.serveKotlinRequest(pathname, res, {
+              root: server.config.root,
+              moduleRoot: kotlinModuleRoot,
+              origin: devOrigin(),
+              hmrPath,
+            })
+            if (!served) next()
           })
           .catch(next)
       })

package/src/vite-plugin.ts

@@ -1682,6 +1682,7 @@ export function workletsBabelTransform(
 // scripts/build/bundler-deps.ts so esbuild-based dep prebundles stay in sync.
 let flowBabel: typeof import('@babel/core') | null = null
 let flowStripPlugin: import('@babel/core').PluginItem | null = null
+let hermesParserPlugin: import('@babel/core').PluginItem | null = null
 let jsxSyntaxPlugin: import('@babel/core').PluginItem | null = null
 function loadFlowBabel(): void {
   if (flowBabel) return
@@ -1689,6 +1690,10 @@ function loadFlowBabel(): void {
   flowStripPlugin = sootsimPluginRequire(
     '@babel/plugin-transform-flow-strip-types',
   ) as import('@babel/core').PluginItem
+  // react native uses Hermes to parse current Flow syntax, including `as` casts.
+  hermesParserPlugin = sootsimPluginRequire(
+    'babel-plugin-syntax-hermes-parser',
+  ) as import('@babel/core').PluginItem
   jsxSyntaxPlugin = sootsimPluginRequire(
     '@babel/plugin-syntax-jsx',
   ) as import('@babel/core').PluginItem
@@ -1708,7 +1713,7 @@ function flowStripTransform(): Plugin {
           filename: id,
           babelrc: false,
           configFile: false,
-          plugins: [flowStripPlugin!, jsxSyntaxPlugin!],
+          plugins: [hermesParserPlugin!, flowStripPlugin!, jsxSyntaxPlugin!],
           sourceMaps: true,
           compact: false,
         })