vxrn 1.25.16 → 1.26.0

package/src/utils/createNativeDevEngine.ts

@@ -20,11 +20,10 @@ import { pathToFileURL } from 'node:url'
 import type { InputOptions, OutputOptions, Plugin, RolldownOutput } from 'rolldown'
 import type { DevEngine } from 'rolldown/experimental'
 import { loadEnv as loadViteEnv, normalizePath } from 'vite'
+import { shouldStripFlow, transformHermesAsync } from '@vxrn/compiler'
 import { DEFAULT_ASSET_EXTS } from '../constants/defaults'
 import { getNativePrelude } from '../runtime/native-prelude'
-
-// files that contain Flow syntax and need stripping
-const FLOW_FILE_PATTERN = /node_modules[\\/](?:react-native|@react-native)[\\/].*\.js$/
+import { rnCodegenPlugin } from '../plugins/rnCodegenPlugin'
 
 // Hermes needs the whole class shape lowered *together*. downleveling only the
 // class fields while leaving `class ... extends` as modern ES6 produces a
@@ -136,6 +135,16 @@ export function getNativeTransformConfig(
     }
   })()
 
+  // app-supplied defines (One's native.bundlerOptions.define). vite's rule:
+  // a string is a raw expression, anything else is JSON stringified. rolldown's
+  // binding only accepts strings, so normalize rather than crashing the build.
+  const userDefines: Record<string, string> = {}
+  for (const [key, value] of Object.entries(
+    ((globalThis as any).__vxrnNativeUserDefine || {}) as Record<string, unknown>
+  )) {
+    userDefines[key] = typeof value === 'string' ? value : JSON.stringify(value)
+  }
+
   const mode = dev ? 'development' : 'production'
 
   // Match One's Vite client contract: load public values from process.env and
@@ -174,6 +183,9 @@ export function getNativeTransformConfig(
       runtime: 'classic' as const,
     },
     define: {
+      // first in the map, so nothing the user set can shadow a platform-owned
+      // key below.
+      ...userDefines,
       // Public values are applied first so platform-owned keys cannot inherit
       // the SSR values used while loading One's Vite config.
       ...envDefines,
@@ -237,6 +249,8 @@ function getNativePlugins(
     // type argument intact. stripping Flow first would erase it (which is why the
     // codegen "didn't run for <Component>" warning fired).
     vxrnCompilerPlugin(platform, dev, root, sourceMaps),
+    // react-native codegen: transforms TurboModule / Fabric specs before Flow stripping
+    rnCodegenPlugin({ projectRoot: root }),
     // strip Flow from any react-native / @react-native `.js` the compiler didn't
     // handle, the guaranteed safety net before rolldown's oxc core parse (which
     // can't parse Flow). now downstream of the compiler, so codegen sees the types.
@@ -247,6 +261,9 @@ function getNativePlugins(
     assetPlugin({ root, platform, assetsDest, onAsset }),
     // hermes compat: transform class properties and private fields
     hermesCompatSWCPlugin(dev, sourceMaps),
+    // hermes compat: per-iteration loop bindings. runs last so it also covers
+    // loops the earlier lowering steps emit.
+    hermesLoopsPlugin(sourceMaps),
   ]
 }
 
@@ -268,12 +285,10 @@ function getNativeOutputOptions(prelude: string, sourcemap: boolean): OutputOpti
  * - DevSettings stripping → stripDevSettingsPlugin
  */
 export function normalizeNativeCommonJSInterop(code: string): string {
-  // Rolldown can mark ESM default imports from internal CommonJS modules as
-  // Node-mode conversions in both dev and production. Babel CommonJS packages
-  // expose their actual default behind `exports.default`; Node mode instead
-  // returns the whole exports object and React receives `{ default: Component }`.
+  // native packages expose Babel defaults through exports.default. apply the
+  // same interop to bundled require helpers and HMR's runtime export lookups.
   return code.replace(
-    /(\b__toESM(?:\$\d+)?\(\s*require[\w$]*\(\)\s*),\s*1(\s*\))/g,
+    /(\b__toESM(?:\$\d+)?\(\s*(?:require[\w$]*\(\)|__rolldown_runtime__\.loadExports\("(?:\\.|[^"\\])*"\))\s*),\s*1(\s*\))/g,
     '$1$2'
   )
 }
@@ -373,34 +388,16 @@ async function downlevelClassFieldsInBundle(code: string): Promise<string> {
   const runtimeSection = code.slice(startIdx, runtimeEnd)
   const originalNewlines = runtimeSection.match(/\n/g)?.length ?? 0
 
-  const swc = await import('@swc/core')
-  const result = await swc.transform(runtimeSection, {
-    filename: 'rolldown-runtime.js',
-    configFile: false,
-    swcrc: false,
-    sourceMaps: false,
-    inputSourceMap: false,
-    isModule: false,
-    // Compact only Rolldown's generated runtime, then restore its original
-    // newline count below. This keeps every application module at the exact
-    // generated line recorded by Rolldown's source map while still lowering
-    // runtime class fields for Hermes.
-    minify: true,
-    env: {
-      targets: { node: 9999 },
-      // dev-only runtime prelude: the class set only, no prod bytecode transforms
-      include: [...HERMES_CLASS_TRANSFORMS],
-    },
-    jsc: {
-      parser: { syntax: 'ecmascript' },
-      transform: { react: { runtime: 'preserve' } },
-      externalHelpers: false,
-      assumptions: {
-        setPublicClassFields: true,
-        privateFieldsAsProperties: true,
-      },
+  const { transformSync } = await import('oxc-transform')
+  const result = transformSync('rolldown-runtime.js', runtimeSection, {
+    target: 'es2020',
+    assumptions: {
+      setPublicClassFields: true,
     },
   })
+  if (result.errors?.length) {
+    throw new Error(result.errors.map((e) => e.message).join('\n'))
+  }
   const transformedCode = result.code.trimEnd()
   // SWC minification strips comments, but the dev bundle scope wrapper uses
   // this generated-runtime marker as its structural boundary.
@@ -585,7 +582,7 @@ try {
           onHmrUpdate?.({
             type: 'hmr:update',
             clientId,
-            code: update.code,
+            code: normalizeNativeCommonJSInterop(update.code),
             changedIds: update.changedIds,
             seq: update.seq,
           })
@@ -1018,50 +1015,150 @@ export function vxrnCompilerPlugin(
 
       let babelOptions = compiler.getBabelOptions(props)
 
-      if (needsRefresh) {
-        // merge react-refresh/babel into the existing plugins (or create new options)
-        const existingPlugins = babelOptions?.plugins || []
-        babelOptions = {
-          ...babelOptions,
-          plugins: [
-            ...existingPlugins,
-            [
-              'react-refresh/babel',
-              {
-                skipEnvCheck: true,
-                refreshReg: '__vxrnRefreshReg',
-                refreshSig: '__vxrnRefreshSig',
-              },
-            ],
-          ],
+      let curCode = code
+      const intermediateMaps: any[] = []
+
+      const isWorkletPlugin = (entry: any) => {
+        if (!entry) return false
+        const name =
+          typeof entry === 'string' ? entry : Array.isArray(entry) ? entry[0] : null
+        return (
+          typeof name === 'string' &&
+          (name.includes('react-native-worklets') ||
+            name.includes('react-native-reanimated'))
+        )
+      }
+      const workletEntry = babelOptions?.plugins?.find(isWorkletPlugin)
+      const workletPluginOptions = Array.isArray(workletEntry) ? workletEntry[1] : undefined
+      const useWorklets =
+        compiler.isNativeWorkletsEnabled() &&
+        (Boolean(workletEntry) || compiler.shouldTransformWorklets({ id, code }))
+      const compilerPluginIndex =
+        babelOptions?.plugins?.findIndex(
+          (x) => Array.isArray(x) && x[0] === 'babel-plugin-react-compiler'
+        ) ?? -1
+
+      if (compilerPluginIndex !== -1) {
+        // preserve automatic worklet candidates before react compiler hoists them.
+        if (useWorklets) {
+          const prepared = compiler.prepareWorkletsForReactCompiler(id, curCode, sourceMaps)
+          if (prepared) {
+            curCode = prepared.code
+            if (prepared.map) intermediateMaps.push(prepared.map)
+          }
+        }
+        const compilerTarget =
+          (babelOptions!.plugins![compilerPluginIndex] as any[])[1]?.target ?? '19'
+        const compilerOut = await compiler.transformOxcReactCompiler(
+          id, curCode, compilerTarget, sourceMaps
+        )
+        if (compilerOut?.code) {
+          curCode = compilerOut.code
+          if (sourceMaps && compilerOut.map) intermediateMaps.push(compilerOut.map)
+        }
+        babelOptions!.plugins!.splice(compilerPluginIndex, 1)
+        if (babelOptions!.plugins!.length === 0) babelOptions = null
+      }
+
+      if (useWorklets) {
+        const workletOut = await compiler.transformWorklets(id, curCode, sourceMaps, {
+          projectRoot,
+          ...workletPluginOptions,
+        })
+        if (workletOut?.code) {
+          curCode = workletOut.code
+          if (sourceMaps && workletOut.map) intermediateMaps.push(workletOut.map)
+        }
+        if (babelOptions?.plugins) {
+          babelOptions.plugins = babelOptions.plugins.filter(
+            (entry) => !isWorkletPlugin(entry)
+          )
+          if (babelOptions.plugins.length === 0) babelOptions = null
         }
       }
 
-      if (!babelOptions) return
+      if (!babelOptions && !needsRefresh) {
+        if (curCode !== code) {
+          let finalMap: any = undefined
+          if (sourceMaps && intermediateMaps.length > 0) {
+            if (intermediateMaps.length === 1) {
+              finalMap = intermediateMaps[0]
+            } else {
+              const remapping = (await import('@jridgewell/remapping')).default
+              finalMap = remapping(intermediateMaps.slice().reverse(), () => null)
+            }
+          }
+          return { code: curCode, map: finalMap }
+        }
+        return
+      }
 
-      if (sourceMaps) {
-        // Rolldown composes plugin maps in transform order. Without this map,
-        // every module Babel changes is attributed only to Babel's generated
-        // output, which makes production Hermes frames miss the original
-        // source line even though the bundle command emits a `.map` file.
+      if (sourceMaps && babelOptions) {
+        // Individual stage maps are collected in intermediateMaps and composed
+        // once via remapping([wrapMap, refreshMap, ...intermediateMaps.reverse()]).
+        // Do not pass intermediateMaps as inputSourceMap to Babel, which would
+        // cause Babel to pre-compose and remapping to double-compose the compiler map.
         babelOptions = {
           ...babelOptions,
           sourceMaps: true,
           sourceFileName: id,
         }
+        delete (babelOptions as any).inputSourceMap
       }
 
-      const result = await compiler.transformBabel(id, code, babelOptions)
+      if (babelOptions) {
+        const result = await compiler.transformBabel(id, curCode, babelOptions)
+        if (result?.code) {
+          curCode = result.code
+          if (sourceMaps && result.map) {
+            intermediateMaps.push(result.map)
+          }
+          if (!needsRefresh) {
+            let finalMap: any = undefined
+            if (sourceMaps && intermediateMaps.length > 0) {
+              if (intermediateMaps.length === 1) {
+                finalMap = intermediateMaps[0]
+              } else {
+                const remapping = (await import('@jridgewell/remapping')).default
+                finalMap = remapping(intermediateMaps.slice().reverse(), () => null)
+              }
+            }
+            return { code: curCode, map: finalMap }
+          }
+        }
+      }
 
-      if (result?.code) {
-        let out = result.code
+      if (needsRefresh) {
+        const { transformSync } = await import('oxc-transform-react')
+        const jsxImportSource =
+          compiler.configuration?.enableNativewind && !id.includes('node_modules')
+            ? 'nativewind'
+            : 'react'
+
+        const res = transformSync(id, curCode, {
+          jsx: {
+            development: dev,
+            runtime: 'automatic',
+            importSource: jsxImportSource,
+            refresh: {
+              refreshReg: '__vxrnRefreshReg',
+              refreshSig: '__vxrnRefreshSig',
+            },
+          },
+          reactCompiler: false,
+          sourcemap: sourceMaps,
+        })
 
-        if (needsRefresh) {
-          // wrap with per-file $RefreshReg$ that includes the file path as unique ID
-          // and schedule performReactRefresh() after HMR patch re-execution
-          const escapedId = id.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
-          out = `
-var __prevRefreshReg = globalThis.$RefreshReg$;
+        if (res.fatal) {
+          throw new Error(
+            `[vxrn:compiler] oxc react transform failed on ${id}: ${(res.errors ?? [])
+              .map((e: any) => e.message ?? String(e))
+              .join(', ')}`
+          )
+        }
+
+        const escapedId = id.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+        const header = `var __prevRefreshReg = globalThis.$RefreshReg$;
 var __prevRefreshSig = globalThis.$RefreshSig$;
 if (globalThis.__ReactRefresh) {
   globalThis.$RefreshReg$ = function(type, id) {
@@ -1073,7 +1170,8 @@ if (globalThis.__ReactRefresh) {
 var __vxrnRefreshReg = globalThis.$RefreshReg$;
 var __vxrnRefreshSig = globalThis.$RefreshSig$;
 
-${out}
+`
+        const footer = `
 
 globalThis.$RefreshReg$ = __prevRefreshReg;
 globalThis.$RefreshSig$ = __prevRefreshSig;
@@ -1085,24 +1183,48 @@ if (import.meta.hot) {
   });
 }
 `
+        let out: string
+        let finalMap: any = undefined
+
+        if (sourceMaps) {
+          const MagicString = (await import('magic-string')).default
+          const ms = new MagicString(res.code)
+          ms.prepend(header)
+          ms.append(footer)
+          out = ms.toString()
+          const wrapMap = ms.generateMap({ source: id, hires: true })
+
+          const allMaps = [
+            wrapMap,
+            res.map,
+            ...intermediateMaps.slice().reverse(),
+          ].filter(Boolean)
+          const remapping = (await import('@jridgewell/remapping')).default
+          finalMap = remapping(allMaps, () => null)
+        } else {
+          out = header + res.code + footer
         }
 
-        return { code: out, map: sourceMaps ? result.map : undefined }
+        return { code: out, map: finalMap }
       }
     },
   }
 }
 
 /**
- * Strip Flow types from react-native source files.
- * Uses hermes-parser which is already a dep of react-native.
+ * Strip Flow types from react-native and other Flow-authored source files.
+ *
+ * The `.vxrn.original` patch step rewrites some of these packages in
+ * node_modules ahead of time, but that step is best-effort and skips a module
+ * whose transform throws. Deciding here on the file's own contents means the
+ * bundle no longer depends on that mutation having succeeded.
  */
 function flowStripPlugin(): Plugin {
   return {
     name: 'vxrn:flow-strip',
     transform: {
       async handler(code, id) {
-        if (!FLOW_FILE_PATTERN.test(id)) return
+        if (!shouldStripFlow(id, code)) return
 
         const fft = await import('fast-flow-transform')
         const result = await fft.default({
@@ -1389,7 +1511,7 @@ function copyNativeAssetFiles(
  * Inspired by rollipop's swc-plugin.ts.
  */
 export function hermesCompatSWCPlugin(dev: boolean, sourceMaps = false): Plugin {
-  let swc: typeof import('@swc/core') | null = null
+  let oxc: typeof import('oxc-transform') | null = null
 
   return {
     name: 'vxrn:hermes-compat',
@@ -1398,43 +1520,73 @@ export function hermesCompatSWCPlugin(dev: boolean, sourceMaps = false): Plugin
       if (id.includes('\0') || id.includes('virtual:')) return
       // skip files that don't need transformation
       const hasClass = code.includes('class ') || code.includes('class{')
-      const hasAsync = code.includes('async ')
+      const hasAsync = code.includes('async')
       const hasBlockScopedLoop = /\bfor\s*\(\s*(?:const|let)\b/.test(code)
       if (!hasClass && !hasAsync && !hasBlockScopedLoop) return
-      // skip very large prebuilt files
-      if (code.length > 500_000) return
-
-      if (!swc) swc = await import('@swc/core')
-
-      // app modules: the Hermes class and async sets in both modes.
-      const envIncludes = getHermesSWCIncludes(dev)
-
-      const result = await swc.transform(code, {
-        filename: id,
-        configFile: false,
-        swcrc: false,
-        // Return the transform-to-input map and let Rolldown compose it with
-        // earlier plugin maps. `inputSourceMap` stays false deliberately:
-        // feeding the prior map to SWC as well would compose it twice.
-        sourceMaps,
-        sourceFileName: sourceMaps ? id : undefined,
-        inputSourceMap: false,
-        env: {
-          targets: { node: 9999 },
-          include: envIncludes,
-        },
-        jsc: {
-          parser: { syntax: 'typescript', tsx: true },
-          transform: { react: { runtime: 'preserve' } },
-          externalHelpers: false,
-          assumptions: {
-            setPublicClassFields: true,
-            privateFieldsAsProperties: true,
-          },
-        },
-        isModule: !id.endsWith('.cjs'),
-      })
-      return { code: result.code, map: sourceMaps ? result.map : undefined }
+      let output: { code: string; map?: any } | undefined
+      // keep the existing oxc limit for large prebuilt files. async lowering
+      // below has no size exemption and runs after the worklet transform.
+      if (code.length <= 500_000) {
+        if (!oxc) oxc = await import('oxc-transform')
+        const lang = /\.[cm]?ts$/.test(id) ? 'ts' : id.endsWith('.tsx') ? 'tsx' : 'jsx'
+        const result = oxc.transformSync(id, code, {
+          lang,
+          target: 'es2020',
+          assumptions: { setPublicClassFields: true },
+          jsx: 'preserve',
+          sourcemap: sourceMaps,
+          sourceType: id.endsWith('.cjs') ? 'script' : 'module',
+        })
+        if (result.errors?.length) {
+          const err = result.errors[0]
+          throw new Error(err.message + (err.codeframe ? `\n${err.codeframe}` : ''))
+        }
+        output = { code: result.code, map: sourceMaps ? result.map : undefined }
+      }
+      const lowered = await transformHermesAsync(output?.code ?? code, id, sourceMaps)
+      if (!lowered) return output
+      if (lowered.map && output?.map) {
+        const remapping = (await import('@jridgewell/remapping')).default
+        lowered.map = remapping([lowered.map, output.map], () => null)
+      }
+      return lowered
+    },
+  }
+}
+
+export const hermesCompatPlugin = hermesCompatSWCPlugin
+
+/**
+ * Hermes gives a loop one environment, not one per iteration, so every closure
+ * created in a loop body sees the binding's final value. zod installs its schema
+ * methods with `for (const key in methods) defineProperty(proto, key, {get(){...}})`,
+ * and without this every method on every zod schema resolved to the last one:
+ * `string().nullish()` called `apply` and the app red-screened at startup.
+ * See @vxrn/compiler's transformHermesLoops for the bytecode evidence.
+ *
+ * Rolldown's own interop helpers are emitted after this runs, but they are
+ * already `var`-based with `.bind(null, key)`, so they need no rewriting.
+ */
+export function hermesLoopsPlugin(sourceMaps = false): Plugin {
+  let compiler: typeof import('@vxrn/compiler') | null = null
+
+  return {
+    name: 'vxrn:hermes-loops',
+    async transform(code, id) {
+      if (!/\.[cm]?[jt]sx?$/.test(id)) return
+      if (id.includes('\0') || id.includes('virtual:')) return
+
+      if (!compiler) compiler = await import('@vxrn/compiler')
+      const result = compiler.transformHermesLoops(code, id)
+      if (!result) return
+
+      if (!sourceMaps) return { code: result.code, map: null }
+      if (result.maps.length === 1) return { code: result.code, map: result.maps[0] as any }
+      const remapping = (await import('@jridgewell/remapping')).default
+      return {
+        code: result.code,
+        map: remapping(result.maps.slice().reverse(), () => null) as any,
+      }
     },
   }
 }

package/src/utils/patches.test.ts

@@ -10,6 +10,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 vi.mock('@vxrn/compiler', () => ({ transformSWC: vi.fn() }))
 vi.mock('@vxrn/vite-flow', () => ({ transformFlowBabel: vi.fn() }))
 
+import { transformSWC } from '@vxrn/compiler'
 import {
   type DepPatch,
   applyDependencyPatches,
@@ -336,4 +337,36 @@ describe('applyDependencyPatches', () => {
     expect(warn.mock.calls.flat().join(' ')).not.toContain('stale')
     warn.mockRestore()
   })
+
+  // a patch is written to node_modules once and then read by every later build,
+  // so it must be transformed as production. the dev JSX runtime emits `jsxDEV`,
+  // which React's production build exports as `void 0`, so a patched dependency
+  // rendering JSX threw "undefined is not a function" from render in every
+  // production bundle while dev builds stayed green.
+  it('transforms strategy-array patches as production, never the dev JSX runtime', async () => {
+    const mockedTransform = vi.mocked(transformSWC)
+    mockedTransform.mockClear()
+    mockedTransform.mockResolvedValue({ code: 'transformed' } as never)
+
+    await setupAndPatch({
+      patches: [{ module: 'test-pkg', patchFiles: { 'index.js': ['swc'] } }],
+      setupFs: async (nm) => {
+        const pkgDir = join(nm, 'test-pkg')
+        await FSExtra.ensureDir(pkgDir)
+        await FSExtra.writeFile(
+          join(pkgDir, 'package.json'),
+          makePkg('test-pkg', '1.0.0')
+        )
+        await FSExtra.writeFile(
+          join(pkgDir, 'index.js'),
+          'export default () => <div />'
+        )
+      },
+    })
+
+    expect(mockedTransform).toHaveBeenCalled()
+    for (const call of mockedTransform.mock.calls) {
+      expect(call[2]).toMatchObject({ production: true })
+    }
+  })
 })

package/src/utils/patches.ts

@@ -260,8 +260,10 @@ export async function applyDependencyPatches(
                     patchedContent = patchDef
                   } else if (Array.isArray(patchDef)) {
                     // strategy-array patches (flow/jsx/swc transforms) are non-critical
-                    // if they fail (e.g. babel + lru-cache incompatibility on Node 24+),
-                    // warn and skip rather than crashing the whole patch process
+                    // if they fail, warn and skip rather than crashing the whole patch
+                    // process. the message carries the real error: a skipped Flow strip
+                    // here leaves raw Flow in node_modules, and the only sign of it used
+                    // to be a bundler parse failure several steps later.
                     try {
                       let contents = sourceContent
                       for (const strategy of patchDef) {
@@ -277,6 +279,16 @@ export async function applyDependencyPatches(
                                 forceJSX: strategy === 'jsx',
                                 noHMR: true,
                                 fixNonTypeSpecificImports: true,
+                                // a patch is written to node_modules ONCE and then read by
+                                // every later build, dev and production alike, so its output
+                                // has to be valid in both. the automatic JSX runtime is not:
+                                // its dev form emits `jsxDEV` from react/jsx-dev-runtime, and
+                                // React's production build exports `jsxDEV = void 0`, so a
+                                // patched dependency that renders JSX throws "undefined is not
+                                // a function" from render in any production bundle. `jsx`/`jsxs`
+                                // work in both builds, and refresh is already off for
+                                // node_modules, so the stable runtime is the only correct output.
+                                production: true,
                               })
                             )?.code || contents
                         }
@@ -288,11 +300,10 @@ export async function applyDependencyPatches(
                       if (!transformWarnedModules.has(patch.module)) {
                         transformWarnedModules.add(patch.module)
                         console.warn(
-                          `  ⚠ Patch transform failed for ${patch.module} (likely Node version compat), skipping non-critical patch`
+                          `  ⚠ Patch transform failed for ${patch.module} in ${relativePath}, skipping non-critical patch: ${
+                            (transformErr as Error)?.stack ?? transformErr
+                          }`
                         )
-                        if (process.env.DEBUG) {
-                          console.warn(transformErr)
-                        }
                       }
                       return
                     }

package/src/utils/scanDepsToOptimize.ts

@@ -55,6 +55,15 @@ export const EXCLUDE_LIST = [
   '@vxrn/vite-native-hmr',
   '@vxrn/compiler',
   '@vxrn/vite-native-client',
+
+  // build-time only, and they load native .node addons the ssr dep optimizer
+  // cannot parse. apps list vxrn as a dependency because it is their dev
+  // server, which is exactly why it must never be pre-bundled for ssr.
+  'vxrn',
+  '@vxrn/vite-plugin-metro',
+  'oxc-transform',
+  'oxc-parser',
+
   'react-native-ios-utilities',
   'react-native-ios-modal',
   'react-native-ios-context-menu',

package/types/index.d.ts

@@ -17,5 +17,7 @@ export * from './utils/environmentUtils';
 export * from './utils/getServerEntry';
 export * from './plugins/rollupRemoveUnusedImports';
 export * from './plugins/autoDepOptimizePlugin';
+export * from './plugins/rnCodegenPlugin';
+export * from './plugins/workletImportsPlugin';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAA;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAE/D,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,WAAW,GACZ,MAAM,2BAA2B,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AAEtC,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAE/C,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAA;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAE/D,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,WAAW,GACZ,MAAM,2BAA2B,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA;AAEtC,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,2BAA2B,CAAA;AACzC,cAAc,gCAAgC,CAAA;AAE9C,cAAc,SAAS,CAAA"}

package/types/patches/builtInDepPatches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builtInDepPatches.d.ts","sourceRoot":"","sources":["../../src/patches/builtInDepPatches.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAiC,MAAM,kBAAkB,CAAA;AAE/E,eAAO,MAAM,iBAAiB,EAAE,QAAQ,EAqoBvC,CAAA"}
+{"version":3,"file":"builtInDepPatches.d.ts","sourceRoot":"","sources":["../../src/patches/builtInDepPatches.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAiC,MAAM,kBAAkB,CAAA;AAE/E,eAAO,MAAM,iBAAiB,EAAE,QAAQ,EA8pBvC,CAAA"}

package/types/plugins/reactNativeDevServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactNativeDevServer.d.ts","sourceRoot":"","sources":["../../src/plugins/reactNativeDevServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,MAAM,EAAiB,MAAM,MAAM,CAAA;AAO1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAkBnE,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4B9D;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,CAAC,EAAE,OAAO,CACf,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,aAAa,GAAG,kBAAkB,GAAG,SAAS,CAAC,CACrF,GACA,MAAM,CAmSR"}
+{"version":3,"file":"reactNativeDevServer.d.ts","sourceRoot":"","sources":["../../src/plugins/reactNativeDevServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,MAAM,EAAiB,MAAM,MAAM,CAAA;AAO1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAA;AAkBnE,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4B9D;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,CAAC,EAAE,OAAO,CACf,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,aAAa,GAAG,kBAAkB,GAAG,SAAS,CAAC,CACrF,GACA,MAAM,CA+SR"}

package/types/plugins/rnCodegenPlugin.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+export { transformReactNativeCodegen } from '@vxrn/compiler';
+export declare function rnCodegenPlugin(options?: {
+    projectRoot?: string;
+}): Plugin;
+//# sourceMappingURL=rnCodegenPlugin.d.ts.map

package/types/plugins/rnCodegenPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rnCodegenPlugin.d.ts","sourceRoot":"","sources":["../../src/plugins/rnCodegenPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAMlC,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAA;AAE5D,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAW1E"}

package/types/plugins/rnCodegenPlugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rnCodegenPlugin.test.d.ts.map

package/types/plugins/rnCodegenPlugin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rnCodegenPlugin.test.d.ts","sourceRoot":"","sources":["../../src/plugins/rnCodegenPlugin.test.ts"],"names":[],"mappings":""}

package/types/plugins/workletImportsPlugin.d.ts

@@ -0,0 +1,8 @@
+import { type Plugin } from 'rolldown';
+/**
+ * bundles selected, synchronous pure-function exports for normal worklets mode.
+ * install in native.bundlerOptions.plugins. the replacement module exposes only
+ * the configured exports; each entry owns its complete dependency graph.
+ */
+export declare function workletImportsPlugin(imports: Record<string, readonly string[]>): Plugin;
+//# sourceMappingURL=workletImportsPlugin.d.ts.map