peachsim 0.1.1644 → 0.1.1653

package/src/swift-objc-standin.ts

@@ -32,6 +32,8 @@ export interface ObjcSurface {
 
 export interface ObjcView {
   graphs: SymbolGraph[]
+  /** present for original implementations, read without repairing declarations. */
+  clangAST?: unknown
   /** precise enum case and option ids → their header values. */
   values: Map<string, string>
   /** the modules the headers import besides their own. */
@@ -206,6 +208,7 @@ export function objcView(
   stdlib: string,
   cacheDir: string,
   work: string,
+  original?: { flags: readonly string[]; target: string },
 ): ObjcView {
   if (!fs.existsSync(stdlib))
     throw new Error(
@@ -220,6 +223,7 @@ export function objcView(
   const headersDir = framework
     ? path.join(frameworks, `${surface.module}.framework`, 'Headers')
     : path.join(include, surface.module)
+  fs.mkdirSync(headersDir, { recursive: true })
   const originals = new Map(
     headerFiles(surface.headers).map((file) => [
       path.join(headersDir, file),
@@ -373,8 +377,9 @@ export function objcView(
         '-module-name',
         surface.module,
         '-target',
-        IOS_SDK_TARGET,
+        original?.target ?? IOS_SDK_TARGET,
         ...search,
+        ...(original?.flags.flatMap((flag) => ['-Xcc', flag]) ?? []),
         '-module-cache-path',
         path.join(cacheDir, 'ios-module-cache'),
         '-minimum-access-level',
@@ -391,6 +396,10 @@ export function objcView(
       ...run.stderr.matchAll(/^(?:(.+?):(\d+):(\d+): )?(?:fatal )?error: (.*)$/gm),
     ]
     if (errors.length === 0 && run.status === 0) break
+    if (original)
+      throw new Error(
+        `original Objective-C declarations do not import as Swift: ${run.stderr.trim() || run.stdout.trim()}`,
+      )
     let progress = false
     const learn = (name: string, kind: 'class' | 'protocol' | 'struct' | 'macro') => {
       if (missing.has(name)) return
@@ -452,11 +461,138 @@ export function objcView(
   imports.delete(surface.module)
   return {
     graphs,
+    ...(original
+      ? {
+          clangAST: objcDeclarationAST(
+            surface,
+            framework,
+            toolchainBin,
+            search,
+            work,
+            original.flags,
+            original.target,
+          ),
+        }
+      : {}),
     values: enumValues(graphs, surface, framework, toolchainBin, search, work),
     imports: [...imports].sort(),
   }
 }
 
+function objcDeclarationAST(
+  surface: ObjcSurface,
+  framework: boolean,
+  toolchainBin: string,
+  search: string[],
+  work: string,
+  originalFlags: readonly string[],
+  target: string,
+): unknown {
+  const roots = [
+    ...fs
+      .readFileSync(surface.modulemap, 'utf8')
+      .matchAll(/(?:umbrella\s+)?header\s+"([^"]+)"/g),
+  ].map((match) => match[1]!)
+  const probe = path.join(work, 'declarations.m')
+  fs.writeFileSync(
+    probe,
+    roots
+      .map((file) =>
+        framework ? `#import <${surface.module}/${file}>\n` : `#import "${file}"\n`,
+      )
+      .join(''),
+  )
+  const flags: string[] = []
+  for (let index = 0; index < search.length; index += 2) {
+    const [flag, value] = [search[index]!, search[index + 1]!]
+    // the swift resource directory contains swift overlays, not clang builtins.
+    if (flag === '-resource-dir') continue
+    flags.push(flag === '-sdk' ? '-isysroot' : flag, value)
+  }
+  const args = [
+    '-x',
+    'objective-c',
+    '-fobjc-arc',
+    '-fblocks',
+    '-fsyntax-only',
+    '-target',
+    target,
+    ...flags,
+    ...originalFlags,
+    `-fmodule-name=${surface.module}`,
+    '-Xclang',
+    '-ast-dump-all=json',
+  ]
+  const dump = (filter?: string) => {
+    const run = spawnSync(
+      path.join(toolchainBin, 'clang'),
+      [
+        ...args,
+        ...(filter ? ['-Xclang', '-ast-dump-filter', '-Xclang', filter] : []),
+        probe,
+      ],
+      { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 256 * 1024 * 1024 },
+    )
+    if (run.error) throw run.error
+    if (run.status !== 0)
+      throw new Error(`original Objective-C declaration AST failed: ${run.stderr.trim()}`)
+    return run.stdout
+  }
+  const ast: unknown = JSON.parse(dump())
+  const children: unknown =
+    ast && typeof ast === 'object' ? Reflect.get(ast, 'inner') : undefined
+  if (!Array.isArray(children))
+    throw new Error('original Objective-C declaration AST has no translation unit')
+  const inner: unknown[] = children
+  // clang lazily omits module typedefs from a translation unit dump, even with
+  // ast-dump-all. named lookup deserializes the original typedef declarations.
+  // C function result types lack the desugared type that parameters carry.
+  const aliases = new Set<string>()
+  const declared = new Set<string>()
+  for (const node of inner) {
+    if (!node || typeof node !== 'object') continue
+    if (Reflect.get(node, 'kind') === 'TypedefDecl')
+      declared.add(String(Reflect.get(node, 'name')))
+    if (Reflect.get(node, 'kind') !== 'FunctionDecl') continue
+    const type: unknown = Reflect.get(node, 'type')
+    const written: unknown =
+      type && typeof type === 'object' ? Reflect.get(type, 'qualType') : undefined
+    const name =
+      typeof written === 'string' ? /^([A-Za-z_]\w*)\s*\(/.exec(written)?.[1] : undefined
+    if (name) aliases.add(name)
+  }
+  for (const alias of aliases) {
+    if (
+      declared.has(alias) ||
+      [
+        'void',
+        'bool',
+        '_Bool',
+        'char',
+        'short',
+        'int',
+        'long',
+        'float',
+        'double',
+      ].includes(alias)
+    )
+      continue
+    const output = dump(alias)
+    // filtered clang output is a stream of JSON declaration objects.
+    for (const object of output.split(/\n(?=\{\n)/).filter((text) => text.trim())) {
+      const declaration: unknown = JSON.parse(object)
+      if (
+        declaration &&
+        typeof declaration === 'object' &&
+        Reflect.get(declaration, 'kind') === 'TypedefDecl' &&
+        Reflect.get(declaration, 'name') === alias
+      )
+        inner.push(declaration)
+    }
+  }
+  return ast
+}
+
 // the header values of the graphs' objective-c enum cases and option members
 // (c:@E@Enum@Constant, c:@EA@Enum@Constant), from clang's AST of the same
 // headers: an enumerator's value is its initializer's, or one past the one

package/src/swift-package.ts

@@ -174,6 +174,7 @@ export const SWIFT_NATIVE_SOURCE_EXTENSIONS = [
   '.hh',
   '.hpp',
   '.hxx',
+  '.pch',
   '.inc',
   '.inl',
   '.modulemap',
@@ -325,6 +326,99 @@ export function swiftResourceBundles(
   }))
 }
 
+/** the generated accessor files of a native Objective-C resource target,
+ *  written beside its sources: the header is forced into each unit of the
+ *  target and the body is one more unit of it. */
+export const OBJC_RESOURCE_ACCESSOR_HEADER = 'resource_bundle_accessor.h'
+export const OBJC_RESOURCE_ACCESSOR_BODY = 'resource_bundle_accessor.m'
+
+/** the bundle name SwiftPM derives symbols from, for a native Objective-C
+ *  target. a resource target needs the assignment of its own source path, a
+ *  target without resources cannot use the macro, and either mismatch is
+ *  refused here because clang accepts another target's header. */
+export function swiftObjCResourceBundleName(args: {
+  target: string
+  path: string
+  resources: boolean
+  usesBundleMacro: boolean
+  bundles: readonly SwiftResourceBundle[] | undefined
+}): string | undefined {
+  const { target, resources, usesBundleMacro } = args
+  if (!resources) {
+    if (usesBundleMacro)
+      throw new Error(
+        `objective-c target ${target} uses SWIFTPM_MODULE_BUNDLE but declares no resources`,
+      )
+    return undefined
+  }
+  const bundle = args.bundles?.find((candidate) => candidate.target === target)
+  if (
+    !bundle ||
+    bundle.sourcePath !== args.path ||
+    !bundle.path.endsWith(`_${target}.bundle`)
+  )
+    throw new Error(`swift resource target ${target} has no matching bundle assignment`)
+  return bundle.path.slice(0, -'.bundle'.length)
+}
+
+/** SwiftPM's Objective-C resource accessor for one bundle name. */
+export function swiftObjCResourceAccessor(bundleName: string): {
+  header: string
+  body: string
+} {
+  if (!/^[A-Za-z_]\w*$/.test(bundleName))
+    throw new Error(`Objective-C resource bundle symbol is unqualified: ${bundleName}`)
+  const symbol = `${bundleName}_SWIFTPM_MODULE_BUNDLE`
+  const finder = `${bundleName}_SWIFTPM_MODULE_BUNDLER_FINDER`
+  return {
+    header: [
+      '#import <Foundation/Foundation.h>',
+      '',
+      '__BEGIN_DECLS',
+      '',
+      `NSBundle* ${symbol}(void);`,
+      '',
+      `#define SWIFTPM_MODULE_BUNDLE ${symbol}()`,
+      '',
+      '__END_DECLS',
+    ].join('\n'),
+    body: [
+      '#import <Foundation/Foundation.h>',
+      '',
+      'NS_ASSUME_NONNULL_BEGIN',
+      '',
+      `@interface ${finder} : NSObject`,
+      '@end',
+      '',
+      `@implementation ${finder}`,
+      '@end',
+      '',
+      `NSBundle* ${symbol}() {`,
+      `    NSString *bundleName = @"${bundleName}";`,
+      '',
+      '    NSArray<NSURL*> *candidates = @[',
+      '        NSBundle.mainBundle.resourceURL,',
+      `        [NSBundle bundleForClass:[${finder} class]].resourceURL,`,
+      '        NSBundle.mainBundle.bundleURL',
+      '    ];',
+      '',
+      '    for (NSURL* candidate in candidates) {',
+      '        NSURL *bundlePath = [candidate URLByAppendingPathComponent:[NSString stringWithFormat:@"%@.bundle", bundleName]];',
+      '',
+      '        NSBundle *bundle = [NSBundle bundleWithURL:bundlePath];',
+      '        if (bundle != nil) {',
+      '            return bundle;',
+      '        }',
+      '    }',
+      '',
+      '    @throw [[NSException alloc] initWithName:@"SwiftPMResourcesAccessor" reason:[NSString stringWithFormat:@"unable to find bundle named %@", bundleName] userInfo:nil];',
+      '}',
+      '',
+      'NS_ASSUME_NONNULL_END',
+    ].join('\n'),
+  }
+}
+
 /** the one resource target owning a canonical compile-input file. */
 export function swiftResourceBundleForFile(
   bundles: readonly SwiftResourceBundle[],

package/src/swift-packages.ts

@@ -3,8 +3,8 @@
 // (swift-package-manifest.ts) to the source targets that build it; remote
 // packages are fetched at the revision the app's Package.resolved pins, into
 // PEACH_HOME/cache/swift-packages, isolated by the app root. swift and c-family source
-// targets use the common compiler backend. objective-c, assembly and binary
-// targets the host built no stand-in for stay missing with their reason;
+// targets, including objective-c, use the common compiler backend. assembly
+// and binary targets the host built no stand-in for stay missing with their reason;
 // the targets beside them still compile.
 
 import { execFileSync } from 'node:child_process'
@@ -93,8 +93,8 @@ export function remoteSwiftCheckouts(root: string): string {
   return path.join(fs.realpathSync(cacheDir()), 'swift-packages', key, 'checkouts')
 }
 
-// sources requiring an objective-c runtime or assembly lowering.
-const UNSUPPORTED_NATIVE = /\.(m|mm|s|S)$/
+// assembly requires its own target lowering; objective-c keeps its original bodies.
+const UNSUPPORTED_NATIVE = /\.(s|S)$/
 
 const BINARY = 'is a binary framework'
 // retain every independent blocker in dependency order. a product can reach
@@ -264,7 +264,7 @@ export function resolveSwiftPackages(options: {
           : target.type !== 'regular' && target.type !== 'system'
             ? `${name} is a ${target.type} target`
             : files.some((file) => UNSUPPORTED_NATIVE.test(file))
-              ? `${name} is an Objective-C or assembly target${gap ? `; ${gap}` : ''}`
+              ? `${name} is an assembly target${gap ? `; ${gap}` : ''}`
               : null
       // every dependency resolves, so a failing one never hides the rest
       // of the closure from the compile or from the report

package/src/swift-submit.ts

@@ -25,6 +25,8 @@ import {
   isSwiftMetalLibrarySources,
   type SwiftMetalLibrarySource,
   type SwiftResourceBundle,
+  type SwiftNativeTarget,
+  type SwiftObjCPeerStartup,
 } from './swiftContract'
 
 export const SWIFT_COMPILE_PATH = '/api/swift-compile'
@@ -234,6 +236,8 @@ export interface SwiftCompileContext {
 
 export type SwiftCompileSubmit = (work: {
   files: Record<string, string>
+  nativeTargets?: SwiftNativeTarget[]
+  objcPeerStartup?: SwiftObjCPeerStartup
   metalSources?: Record<string, string>
   /** the bundle pack; absent means the project packs none. */
   resources?: Record<string, string>
@@ -399,6 +403,8 @@ export async function compileSwiftProject(
   submit: SwiftCompileSubmit,
   work: {
     files: Record<string, string>
+    nativeTargets?: SwiftNativeTarget[]
+    objcPeerStartup?: SwiftObjCPeerStartup
     metalSources?: Record<string, string>
     resources?: Record<string, string>
     /** project-relative resource paths used to associate implicit resources with targets. */

package/src/swiftContract.ts

@@ -22,6 +22,105 @@ export interface SwiftObjCPeerClass {
   header: string
 }
 
+/** generated registration source whose call must precede the application entry. */
+export interface SwiftObjCPeerStartup {
+  registration: string
+}
+
+export function isSwiftObjCPeerStartup(value: unknown): value is SwiftObjCPeerStartup {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'registration' in value &&
+    isSwiftResourcePath(value.registration) &&
+    value.registration.endsWith('.swift') &&
+    Object.keys(value).length === 1
+  )
+}
+
+export const SWIFT_NATIVE_INPUT_ROOT = '$(PEACH_INPUT_ROOT)'
+export const SWIFT_NATIVE_SDK_INCLUDE = '$(PEACH_SDK_INCLUDE)'
+
+export interface SwiftObjCImplementationPlan {
+  owner: string
+  registeredClasses: string[]
+  units: string[]
+}
+
+export interface SwiftProjectPreparation {
+  headerProducers: string[]
+  objcImplementations?: SwiftObjCImplementationPlan
+}
+
+/** project-relative original clang inputs; no host paths cross the compile boundary. */
+export interface SwiftNativeTarget {
+  name: string
+  deploymentTarget: string | null
+  headers: string[]
+  publicHeaders: string[]
+  bridgingHeader: string | null
+  prefixHeader: string | null
+  headerSearchPaths: string[]
+  frameworkSearchPaths: string[]
+  flags: string[]
+  cxxFlags: string[]
+  fileFlags: Record<string, string[]>
+  sourceDirectories: Record<string, string>
+}
+
+export function isSwiftNativeTargets(value: unknown): value is SwiftNativeTarget[] {
+  const strings = (value: unknown): value is string[] =>
+    Array.isArray(value) &&
+    value.every((item: unknown) => typeof item === 'string' && !item.includes('\0'))
+  const paths = (value: unknown): value is string[] =>
+    strings(value) && value.every(isSwiftResourcePath)
+  return (
+    Array.isArray(value) &&
+    value.length <= 128 &&
+    value.every((target: unknown) => {
+      if (!target || typeof target !== 'object') return false
+      const field = (name: string): unknown => Reflect.get(target, name)
+      const nullablePath = (name: string) =>
+        field(name) === null || isSwiftResourcePath(field(name))
+      const perFile = field('fileFlags')
+      const directories = field('sourceDirectories')
+      const searches = field('headerSearchPaths')
+      const frameworks = field('frameworkSearchPaths')
+      const deployment = field('deploymentTarget')
+      return (
+        typeof field('name') === 'string' &&
+        /^[A-Za-z_]\w*$/.test(String(field('name'))) &&
+        (deployment === null ||
+          (typeof deployment === 'string' && /^\d+(?:\.\d+){0,2}$/.test(deployment))) &&
+        paths(field('headers')) &&
+        paths(field('publicHeaders')) &&
+        nullablePath('bridgingHeader') &&
+        nullablePath('prefixHeader') &&
+        strings(searches) &&
+        searches.every((item) => item === '.' || isSwiftResourcePath(item)) &&
+        strings(frameworks) &&
+        frameworks.every((item) => item === '.' || isSwiftResourcePath(item)) &&
+        strings(field('flags')) &&
+        strings(field('cxxFlags')) &&
+        !!perFile &&
+        typeof perFile === 'object' &&
+        !Array.isArray(perFile) &&
+        Object.entries(perFile).every(
+          ([file, flags]) => isSwiftResourcePath(file) && strings(flags),
+        ) &&
+        !!directories &&
+        typeof directories === 'object' &&
+        !Array.isArray(directories) &&
+        Object.entries(directories).every(
+          ([file, directory]) =>
+            isSwiftResourcePath(file) &&
+            (directory === '.' || isSwiftResourcePath(directory)),
+        )
+      )
+    })
+  )
+}
+
 export interface SwiftObjCImplementationPreparation {
   receipt: string
   objects: { target: string; source: string; file: string }[]

package/src/target-matcher.ts

@@ -43,7 +43,12 @@ export function filterTargetNodes<
     )
       return false
     if (!regex) return matcher.type !== 'text' || node.text === matcher.value
-    const matches = (value: unknown) => typeof value === 'string' && regex.test(value)
+    // detox iOS compares its first regex match's range with the entire value.
+    const matches = (value: unknown) => {
+      if (typeof value !== 'string') return false
+      const match = regex.exec(value)
+      return match !== null && match.index === 0 && match[0].length === value.length
+    }
     if (matcher.type === 'id') return matches(node.testID) || matches(node.id)
     if (matcher.type === 'text') return matches(node.text)
     return matches(node.accessibilityLabel || (node.accessible ? node.text : null))

package/src/vite-plugin.ts

@@ -1,3 +1,4 @@
+import crypto from 'crypto'
 // peach vite plugin — use in any vite project to get react-native resolution,
 // native dep stubbing, and external app support.
 //
@@ -7,8 +8,6 @@
 //
 //   // with external app:
 //   export default defineConfig({ plugins: [sootsim({ app: '~/my-rn-app' })] })
-
-import crypto from 'crypto'
 import fs from 'fs'
 import { createRequire } from 'module'
 import { runInNewContext, Script } from 'node:vm'
@@ -19,6 +18,12 @@ import { minifySync, transformSync } from 'rolldown/utils'
 import { type Plugin, transformWithOxc } from 'vite'
 import { resolveOneNativeBackend } from '../../contrast-bundler/src/oneFramework.ts'
 import { transformFlowSource } from '../../peach-compat/src/flow-strip.ts'
+import { getCliRuntime } from './cli-runtime.ts'
+import {
+  isEngineReactImporter,
+  isWorkerReactBridgeImporter,
+  keepsRealReact,
+} from './react-bridge-importers.ts'
 import { renderWorkerSystemChunk } from './worker-system-chunks.ts'
 
 declare module '@babel/core' {
@@ -41,12 +46,6 @@ import {
   compatStubsForBuildResolver,
   reactNativeDeepStubsForBuildResolver,
 } from '../../peach-compat/src/stub-manifest.ts'
-import { WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE } from '../../peach-engine/src/components/native-ui/webview-frame-bridge.ts'
-import {
-  isExpoHostSocketModule,
-  isReactNativeEnvironmentSetupModule,
-} from '../../peach-engine/src/guest-module-overrides.ts'
-import { readPeachWarmManifest } from '../../peach-engine/src/peach-warm-manifest.ts'
 import {
   assertPeachPortEnvironment,
   resolveSootsimBridgePort,
@@ -420,9 +419,9 @@ export function sootsim(options: SootSimOptions = {}): Plugin[] {
 function hostEnvironmentBootstrapRedirect(): Plugin {
   const target = '\0peach:host-environment-bootstrap'
   const isHostBootstrap = (id: string) =>
-    isExpoHostSocketModule(id) ||
+    getCliRuntime().guest_module_overrides.isExpoHostSocketModule(id) ||
     ((id.startsWith('react-native/') || id.includes('/react-native/')) &&
-      isReactNativeEnvironmentSetupModule(id))
+      getCliRuntime().guest_module_overrides.isReactNativeEnvironmentSetupModule(id))
   return {
     name: 'peach-host-environment-bootstrap',
     enforce: 'pre',
@@ -546,7 +545,7 @@ function warmManifestJsonPlugin(): Plugin {
       const filename = id.slice(marker.length, -3)
       this.addWatchFile(filename)
       const value: unknown = JSON.parse(fs.readFileSync(filename, 'utf8'))
-      const manifest = readPeachWarmManifest(value)
+      const manifest = getCliRuntime().peach_warm_manifest.readPeachWarmManifest(value)
       const entries = [
         manifest.home,
         ...Object.values(manifest.launches),
@@ -1805,21 +1804,11 @@ function reactBridgePlugin(): Plugin {
         if ((options as { scan?: boolean })?.scan || options?.ssr) return null
 
         // only redirect imports from peachsim, peach-engine, peach-compat, and react-reconciler
-        const shouldRedirect =
-          importer.includes('/peachsim/src/') ||
-          importer.includes('/peach-engine/src/') ||
-          importer.includes('/peach-compat/src/') ||
-          importer.includes('/peach-compat/dist-pressability/') ||
-          importer.includes('/peach-kit/src/') ||
-          importer.includes('react-reconciler')
+        const shouldRedirect = isEngineReactImporter(importer)
 
         if (!shouldRedirect) return null
 
-        // don't redirect react-bridge's own import of react (avoid infinite loop)
-        if (importer.includes('react-bridge')) return null
-
-        // stub-registry needs the real React (with __CLIENT_INTERNALS) for bundle stubs
-        if (importer.includes('stub-registry')) return null
+        if (keepsRealReact(importer)) return null
 
         redirectCount++
         if (redirectCount <= 10) {
@@ -1851,28 +1840,13 @@ export function workerReactBridgePlugin(): Plugin {
         // skip during dep scanning / SSR
         if ((options as { scan?: boolean })?.scan || options?.ssr) return null
 
-        // don't redirect react-bridge's own import of react (avoid infinite loop)
-        if (importer.includes('react-bridge')) return null
-
-        // stub-registry needs the real React (with __CLIENT_INTERNALS) for bundle stubs
-        if (importer.includes('stub-registry')) return null
-
         // redirect react imports from peachsim, peach-engine, peach-compat, react-reconciler,
         // and any pure-JS RN-ecosystem package the bundle pulls in. without this
         // redirect, packages like react-native-drawer-layout / use-latest-callback
         // call into a separate React instance than the renderer/bridge does, so
         // their useRef/useEffect refs collide with the engine's hooks state and
         // we hit "Maximum update depth exceeded" infinite-loop renders.
-        const shouldRedirect =
-          importer.includes('/peachsim/src/') ||
-          importer.includes('/peach-engine/src/') ||
-          importer.includes('/peach-compat/src/') ||
-          importer.includes('/peach-compat/dist-pressability/') ||
-          importer.includes('/peach-kit/src/') ||
-          importer.includes('react-reconciler') ||
-          importer.includes('/node_modules/')
-
-        if (!shouldRedirect) return null
+        if (!isWorkerReactBridgeImporter(importer)) return null
 
         return { id: reactBridgePath, external: false }
       },
@@ -2719,7 +2693,7 @@ export function expoDomComponentsPlugin(
       window.process.env = window.process.env || {};
       window.process.env.NODE_ENV = window.process.env.NODE_ENV || 'development';
       window.process.env.EXPO_OS = 'web';
-      ${WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE}
+      ${getCliRuntime().components_native_ui_webview_frame_bridge.WEBVIEW_SAME_ORIGIN_BOOTSTRAP_SOURCE}
       (function () {
         // metro-style require shim for expo's dom closure: classic scripts
         // run before module imports evaluate, so this covers eval-time

package/src/worker-system-chunks.ts

@@ -1,8 +1,8 @@
 import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import { Worker } from 'node:worker_threads'
-import { PAGE_DELIVERED_CHUNKS_NAME_SUFFIX } from '../../peach-engine/src/render-worker/boot-worker-kickoff.ts'
 import { isRecord } from './is-record'
+import { PAGE_DELIVERED_CHUNKS_NAME_SUFFIX } from './workerChunkContract.ts'
 
 const require = createRequire(import.meta.url)
 const systemRuntime = fs.readFileSync(require.resolve('systemjs/dist/s.min.js'), 'utf8')

package/src/workerChunkContract.ts

@@ -0,0 +1,5 @@
+// the kickoff ends the name of each worker it starts with this suffix. that
+// worker's loader then links each Home chunk from the body the kickoff posts
+// (`peach-chunk-list`, then one `peach-chunk-body` per url) instead of
+// downloading it again (worker-system-chunks.ts).
+export const PAGE_DELIVERED_CHUNKS_NAME_SUFFIX = ':page-chunks'

package/src/worklets-babel.ts

@@ -69,18 +69,37 @@ const pendingWorkletTransforms = new Map<
 export function shouldApplyWorkletsPlugin(id: string, code: string): boolean {
   if (!/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/.test(id)) return false
   if (REANIMATED_IGNORED_PATHS_REGEX.test(id)) return false
+  if (!REANIMATED_WORKLETIZATION_REGEX.test(code)) return false
   // sootsim engine source has local helpers named like upstream reanimated
-  // hooks. only transform engine files that actually import upstream
-  // react-native-reanimated; otherwise the plugin rewrites callbacks for our
-  // own engine hooks and expects a `this.__closure` binding they never provide.
+  // hooks. without an upstream import, require an authored worklet directive
+  // before letting the plugin rewrite callbacks. keyboard hooks and shared
+  // worklet helpers need no direct reanimated import.
   if (
     id.includes(SOOTSIM_ENGINE_SRC_PATH) &&
     !id.includes(SOOTSIM_ENGINE_TEST_FIXTURE_PATH) &&
     !REANIMATED_IMPORT_REGEX.test(code)
   ) {
-    return false
+    if (!/['"]worklet['"]/.test(code)) return false
+    const { parseSync, types }: typeof import('@babel/core') =
+      sootsimPluginRequire('@babel/core')
+    const syntax = parseSync(code, {
+      filename: id,
+      babelrc: false,
+      configFile: false,
+      parserOpts: {
+        plugins: isTypescriptFile(id) ? ['typescript', 'jsx'] : ['jsx'],
+      },
+    })
+    let hasWorkletDirective = false
+    if (syntax) {
+      types.traverseFast(syntax, (node) => {
+        if (node.type === 'Directive' && node.value.value === 'worklet')
+          hasWorkletDirective = true
+      })
+    }
+    return hasWorkletDirective
   }
-  return REANIMATED_WORKLETIZATION_REGEX.test(code)
+  return true
 }
 
 function isEngineStandIn(id: string): boolean {