vite-plugin-taro 0.3.2 → 0.4.0

package/src/node/plugins/wx/placement/placer.ts

@@ -0,0 +1,172 @@
+import type { Rolldown } from 'vite'
+import { getWxExecutionKind, isTransportModule } from '../module.ts'
+import {
+    createPlacementPlan,
+    getSubpackageName,
+    isGeneratedSubpackageFile,
+    type ModuleGraph,
+    mainPackage,
+    type PackageLocation,
+    type PlacementPlan
+} from './plan.ts'
+
+/** Native app.json declaration for one generated code-only subpackage. */
+export type GeneratedSubpackage = {
+    /** Stable native alias derived from the generated root hash. */
+    name: string
+    /** Physical directory containing this subpackage's emitted capsules. */
+    root: string
+    /** Marks this as a code-only subpackage with no native Page routes. */
+    pages: readonly []
+}
+
+/**
+ * Creates the stateful adapter between graph planning and Rolldown's output lifecycle:
+ *
+ * - renderStart analyzes transformed modules before chunking.
+ * - codeSplitting prevents modules assigned to different packages from being merged.
+ * - filename callbacks materialize planned subpackage roots.
+ * - renderChunk derives native loading mode from those physical paths.
+ * - generateBundle reconciles the plan with chunks that survived tree shaking.
+ */
+export function createPlacer() {
+    // Filename and output callbacks run after analyze and read this immutable plan through their shared closure.
+    let plan: PlacementPlan = new Map()
+
+    /**
+     * Reduces module ownership to one package for filename generation. Unknown Rolldown-generated modules default to
+     * main, empty chunks default to main, and a chunk containing multiple known owners is rejected before paths diverge.
+     */
+    function getChunkLocation(chunk: Rolldown.PreRenderedChunk): PackageLocation {
+        let location: PackageLocation | undefined
+        for (const moduleId of chunk.moduleIds) {
+            const moduleLocation = plan.get(moduleId) ?? mainPackage
+            if (!location) {
+                location = moduleLocation
+                continue
+            }
+            if (!hasSameLocation(location, moduleLocation)) {
+                throw new Error(`wx chunk mixes package owners: ${chunk.moduleIds.join(', ')}`)
+            }
+        }
+        return location ?? mainPackage
+    }
+
+    return {
+        /** Assigns every transformed module to main or one generated, size-bounded subpackage. */
+        analyze(graph: ModuleGraph): void {
+            plan = createPlacementPlan(graph)
+        },
+
+        /**
+         * Complete Rolldown fragment required to preserve package placement and native entry semantics.
+         *
+         * ```text
+         * native App/Page/Component shell entry
+         *   └─ static import / runtime importSync() ─▶ explicit capsule entry + static closure [main, no TLA]
+         *                                                └─ System.import() ─▶ lazy-a [package A, TLA allowed]
+         *                                                                      └─ static import ─▶ lazy-b [package B]
+         *
+         * name()                              assigns lazy-a and lazy-b to their planned package groups
+         * includeDependenciesRecursively      false: does not pull lazy-b back into package A
+         * preserveEntrySignatures             allows cross-chunk bindings without weakening native entry exports
+         *
+         * package A capsule
+         *   └─ SystemJS dependency ─▶ package B capsule
+         *                                ▲
+         *                                └─ main transport obtains registration with require.async()
+         * ```
+         *
+         * Explicit entries preserve the shell/capsule rendering boundary while their static edge executes synchronously
+         * from main. Once a dynamic boundary is crossed, physical fetches may be asynchronous and modules may use
+         * top-level await. SystemJS still links that complete static lazy graph before execution, even across packages.
+         */
+        rolldownOptions: {
+            output: {
+                /**
+                 * Gives every generated subpackage a distinct Rolldown chunk group. Recursive dependency capture must
+                 * stay disabled: lazy static dependencies may belong to other subpackages and SystemJS links them
+                 * asynchronously.
+                 */
+                codeSplitting: {
+                    groups: [
+                        {
+                            name(moduleId: string): string | null {
+                                const location = plan.get(moduleId)
+                                return location?.kind === 'subpackage' ? getSubpackageName(location.root) : null
+                            },
+                            // Do not let Rolldown pull a lazy group's static closure into one chunk. Past the nested dynamic
+                            // boundary, transport may obtain registrations from several packages asynchronously before
+                            // SystemJS links and executes the original graph, including cycles and top-level await.
+                            includeDependenciesRecursively: false
+                        }
+                    ]
+                },
+                // strictExecutionOrder deliberately has no plugin default. When an application enables it through normal
+                // Rolldown output options, the generated helper runtime becomes amphibious: CommonJS evaluates it once and
+                // transport publishes that cached namespace to SystemJS.
+                /** Preserves exact native shell paths while hashing transport and explicit capsule entries. */
+                entryFileNames(chunk: Rolldown.PreRenderedChunk): string {
+                    return getWxExecutionKind(chunk) === 'native' && !isTransportModule(chunk)
+                        ? '[name]'
+                        : 'assets/[name]-[hash].js'
+                },
+                /** Converts the planned owner into its physical main or generated subpackage filename template. */
+                chunkFileNames(chunk: Rolldown.PreRenderedChunk): string {
+                    const location = getChunkLocation(chunk)
+                    if (location.kind === 'main') {
+                        return 'assets/[name]-[hash].js'
+                    }
+                    // The containing subpackage already supplies a stable identity. Do not leak the Rolldown group name
+                    // into every physical chunk filename; content identity alone is sufficient beneath that root.
+                    return `${location.root}/assets/[hash].js`
+                },
+                // Keep generic assets independent of stylesheet conventions. The CSS adapter sees Tailwind's final
+                // mutation and owns the exact global `app.wxss` identity without confusing native Page companions.
+                assetFileNames: 'assets/[name]-[hash][extname]'
+            },
+            // Rolldown rejects strict entry signatures when code-splitting groups disable recursive dependency capture.
+            // allow-extension retains required native-entry exports while permitting the extra cross-chunk bindings used
+            // to split lazy static closures across physical packages.
+            preserveEntrySignatures: 'allow-extension' as const
+        },
+
+        /**
+         * Selects loading mode from physical output rather than graph intent. Transport executes in main, so main files
+         * use require() and every generated subpackage file uses require.async().
+         */
+        getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async' {
+            return isGeneratedSubpackageFile(chunk.fileName) ? 'async' : 'sync'
+        },
+
+        /**
+         * Reconciles planned ownership with final chunks through module IDs. Tree-shaken subpackages disappear naturally,
+         * while roots are deduplicated and sorted before becoming deterministic app.json declarations.
+         */
+        getSubpackages(bundle: Rolldown.OutputBundle): GeneratedSubpackage[] {
+            const emittedSubpackageRoots = new Set<string>()
+            for (const output of Object.values(bundle)) {
+                if (output.type !== 'chunk') {
+                    continue
+                }
+                for (const moduleId of output.moduleIds) {
+                    const location = plan.get(moduleId)
+                    if (location?.kind === 'subpackage') {
+                        emittedSubpackageRoots.add(location.root)
+                    }
+                }
+            }
+
+            return [...emittedSubpackageRoots].sort().map((root) => ({
+                name: getSubpackageName(root),
+                root,
+                pages: []
+            }))
+        }
+    }
+}
+
+/** Compares main by discriminant and generated subpackages by their unique physical root. */
+function hasSameLocation(left: PackageLocation, right: PackageLocation): boolean {
+    return left.kind === 'main' ? right.kind === 'main' : right.kind === 'subpackage' && left.root === right.root
+}

package/src/node/plugins/wx/placement/plan.ts

@@ -0,0 +1,306 @@
+import { createHash } from 'node:crypto'
+import type { Rolldown } from 'vite'
+
+// Leave headroom below WeChat's 2M subpackage limit for capsule wrappers and bundler-generated code.
+const subpackagePlanningBudget = 1_900_000
+const generatedSubpackageRootPrefix = 'sub/p_'
+
+/** Identifies one generated code-only subpackage by its physical output root. */
+export type SubpackageLocation = {
+    /** Discriminates generated subpackages from main. */
+    kind: 'subpackage'
+    /** Native subpackage root relative to the Mini Program output directory. */
+    root: string
+}
+
+/** Physical package ownership for one transformed module. */
+export type PackageLocation = { kind: 'main' } | SubpackageLocation
+
+/** Immutable module-to-package ownership produced before Rolldown creates chunks. */
+export type PlacementPlan = ReadonlyMap<string, PackageLocation>
+
+/** Minimal Rolldown graph interface consumed by the subpackage planner. */
+export type ModuleGraph = {
+    /** Every transformed module known after graph construction. */
+    moduleIds: Iterable<string>
+    /** Reads static edges, dynamic edges, transformed code, and entry ownership. */
+    getModuleInfo(moduleId: string): Rolldown.ModuleInfo | null
+    /** Adds non-JavaScript output owned by a transformed module to its package weight. */
+    getAdditionalModuleBytes?: (info: Rolldown.ModuleInfo) => number
+}
+
+/** One independently placeable lazy module together with size and co-location preferences. */
+type PlaceableModule = {
+    /** Stable module identity and final ownership key. */
+    moduleId: string
+    /** UTF-8 size of transformed source used as the bin-packing estimate. */
+    estimatedBytes: number
+    /** Dynamic roots whose static closures contain this module. */
+    consumers: ReadonlySet<string>
+    /** Lazy modules connected by a direct static import in either direction. */
+    neighbors: ReadonlySet<string>
+}
+
+/** Mutable subpackage candidate used only while best-fit packing is in progress. */
+type SubpackageBin = {
+    /** Modules currently assigned to this candidate. */
+    moduleIds: string[]
+    /** Accumulated transformed-source estimate. */
+    estimatedBytes: number
+    /** Dynamic roots represented by at least one assigned module. */
+    consumers: Set<string>
+}
+
+/** Final membership and stable physical location for one generated subpackage. */
+type PackedSubpackage = SubpackageLocation & {
+    /** Sorted membership used both for stable hashing and ownership assignment. */
+    moduleIds: readonly string[]
+}
+
+/** Shared main-package value used for every eager or output-generated module. */
+export const mainPackage = { kind: 'main' } as const
+
+/**
+ * Creates one deterministic subpackage placement plan:
+ *
+ * 1. Snapshot Rolldown's transformed module graph.
+ * 2. Reserve every explicit shell and capsule entry together with its static closure in main.
+ * 3. Treat dynamic imports as asynchronous roots, then annotate their modules with affinity.
+ * 4. Pack those lazy modules independently under the planning budget.
+ * 5. Return only module ownership; chunks and native manifests are reconciled later.
+ *
+ * Static cycles are deliberately not atomic only after a genuine nested dynamic boundary. System.import() may obtain their
+ * registrations from several packages and await top-level execution while preserving the original static ESM graph.
+ */
+export function createPlacementPlan({
+    moduleIds,
+    getModuleInfo,
+    getAdditionalModuleBytes,
+    planningBudgetBytes = subpackagePlanningBudget
+}: ModuleGraph & { planningBudgetBytes?: number }): PlacementPlan {
+    // Materialize the iterable once because every later phase needs stable random access by module ID.
+    const infos = new Map<string, Rolldown.ModuleInfo>()
+    for (const moduleId of moduleIds) {
+        const info = getModuleInfo(moduleId)
+        if (info) {
+            infos.set(moduleId, info)
+        }
+    }
+
+    // Eager ownership is a hard constraint; consumer and neighbor sets below are soft packing preferences only.
+    const eagerModules = findEagerModules(infos)
+    const consumersByModule = findLazyConsumers({ infos, eagerModules })
+    const neighborsByModule = findLazyNeighbors({ infos, eagerModules })
+    const placeableModules = [...infos.entries()]
+        .filter(([moduleId]) => !eagerModules.has(moduleId))
+        .map(([moduleId, info]) => ({
+            moduleId,
+            estimatedBytes: Buffer.byteLength(info.code ?? '', 'utf8') + (getAdditionalModuleBytes?.(info) ?? 0),
+            consumers: consumersByModule.get(moduleId) ?? new Set([moduleId]),
+            neighbors: neighborsByModule.get(moduleId) ?? new Set<string>()
+        }))
+
+    // Packing operates at module granularity, so a large lazy closure or cycle may span several subpackages.
+    const subpackages = packSubpackages({ modules: placeableModules, planningBudgetBytes }).map(createPackedSubpackage)
+    const locationByModule = new Map<string, PackageLocation>()
+    for (const moduleId of eagerModules) {
+        locationByModule.set(moduleId, mainPackage)
+    }
+    for (const subpackage of subpackages) {
+        for (const moduleId of subpackage.moduleIds) {
+            locationByModule.set(moduleId, subpackage)
+        }
+    }
+
+    return locationByModule
+}
+
+/**
+ * Finds modules that must remain in main. Native shells and capsules are explicit entries, and static traversal keeps their
+ * complete eager closures synchronous. Every dynamic import is therefore a genuine lazy boundary whose graph may use
+ * subpackages and top-level await.
+ */
+function findEagerModules(infos: ReadonlyMap<string, Rolldown.ModuleInfo>): Set<string> {
+    const eagerModules = new Set<string>()
+    const pending = [...infos.values()].filter((info) => info.isEntry).map((info) => info.id)
+    while (pending.length > 0) {
+        const moduleId = pending.pop()
+        if (!moduleId || eagerModules.has(moduleId)) {
+            continue
+        }
+
+        const info = infos.get(moduleId)
+        if (!info) {
+            continue
+        }
+        eagerModules.add(moduleId)
+        pending.push(...info.importedIds)
+    }
+    return eagerModules
+}
+
+/**
+ * Records demand after the eager importSync closure has been removed. Every remaining dynamic target starts one lazy root
+ * traversal; that traversal follows static edges only and stops before another dynamic boundary. A shared module records
+ * every root that can request it. These consumer sets improve co-location but never prevent subpackage splitting.
+ */
+function findLazyConsumers({
+    infos,
+    eagerModules
+}: {
+    infos: ReadonlyMap<string, Rolldown.ModuleInfo>
+    eagerModules: ReadonlySet<string>
+}): Map<string, Set<string>> {
+    const dynamicRoots = new Set<string>()
+    for (const info of infos.values()) {
+        for (const importedId of info.dynamicallyImportedIds) {
+            if (infos.has(importedId) && !eagerModules.has(importedId)) {
+                dynamicRoots.add(importedId)
+            }
+        }
+    }
+
+    const consumersByModule = new Map<string, Set<string>>()
+    for (const dynamicRoot of [...dynamicRoots].sort()) {
+        const visited = new Set<string>()
+        const pending = [dynamicRoot]
+        while (pending.length > 0) {
+            const moduleId = pending.pop()
+            if (!moduleId || visited.has(moduleId) || eagerModules.has(moduleId)) {
+                continue
+            }
+
+            const info = infos.get(moduleId)
+            if (!info) {
+                continue
+            }
+            visited.add(moduleId)
+            const consumers = consumersByModule.get(moduleId) ?? new Set<string>()
+            consumers.add(dynamicRoot)
+            consumersByModule.set(moduleId, consumers)
+            pending.push(...info.importedIds)
+        }
+    }
+    return consumersByModule
+}
+
+/**
+ * Converts each lazy static edge into an undirected affinity. Direction is irrelevant for co-location scoring, while the
+ * original directed dependency remains in Rolldown and later in SystemJS. Cycles are therefore preferences, not atoms.
+ */
+function findLazyNeighbors({
+    infos,
+    eagerModules
+}: {
+    infos: ReadonlyMap<string, Rolldown.ModuleInfo>
+    eagerModules: ReadonlySet<string>
+}): Map<string, Set<string>> {
+    const neighborsByModule = new Map<string, Set<string>>()
+    for (const [moduleId, info] of infos) {
+        if (eagerModules.has(moduleId)) {
+            continue
+        }
+        for (const importedId of info.importedIds) {
+            if (!infos.has(importedId) || eagerModules.has(importedId)) {
+                continue
+            }
+            addNeighbor(neighborsByModule, moduleId, importedId)
+            addNeighbor(neighborsByModule, importedId, moduleId)
+        }
+    }
+    return neighborsByModule
+}
+
+/** Adds one side of an undirected lazy-module affinity edge. */
+function addNeighbor(neighborsByModule: Map<string, Set<string>>, moduleId: string, neighborId: string): void {
+    const neighbors = neighborsByModule.get(moduleId) ?? new Set<string>()
+    neighbors.add(neighborId)
+    neighborsByModule.set(moduleId, neighbors)
+}
+
+/**
+ * Packs lazy modules with deterministic best-fit decreasing:
+ *
+ * 1. Visit larger transformed modules first, with module ID as the stable tie-breaker.
+ * 2. Consider only existing bins that stay within the planning budget.
+ * 3. Prefer the bin with the least remaining space, minimizing subpackage count in the usual best-fit heuristic.
+ * 4. When remaining space ties, prefer shared dynamic consumers and then static neighbors.
+ * 5. Create a new bin when no existing bin fits; an individually oversized module receives its own bin.
+ */
+function packSubpackages({
+    modules,
+    planningBudgetBytes
+}: {
+    modules: readonly PlaceableModule[]
+    planningBudgetBytes: number
+}): SubpackageBin[] {
+    const bins: SubpackageBin[] = []
+    const sortedModules = [...modules].sort((left, right) => {
+        return right.estimatedBytes - left.estimatedBytes || left.moduleId.localeCompare(right.moduleId)
+    })
+
+    for (const module of sortedModules) {
+        const candidate = bins
+            .filter((bin) => bin.estimatedBytes + module.estimatedBytes <= planningBudgetBytes)
+            .map((bin) => ({
+                bin,
+                remainingBytes: planningBudgetBytes - bin.estimatedBytes - module.estimatedBytes,
+                affinity: getAffinity(bin, module)
+            }))
+            .sort((left, right) => {
+                return left.remainingBytes - right.remainingBytes || right.affinity - left.affinity
+            })[0]?.bin
+
+        const bin = candidate ?? {
+            moduleIds: [],
+            estimatedBytes: 0,
+            consumers: new Set<string>()
+        }
+        if (!candidate) {
+            bins.push(bin)
+        }
+        bin.moduleIds.push(module.moduleId)
+        bin.estimatedBytes += module.estimatedBytes
+        for (const consumer of module.consumers) {
+            bin.consumers.add(consumer)
+        }
+    }
+    return bins
+}
+
+/** Scores dynamic-root overlap above direct static adjacency when equally full bins compete. */
+function getAffinity(bin: SubpackageBin, module: PlaceableModule): number {
+    let affinity = 0
+    for (const consumer of module.consumers) {
+        if (bin.consumers.has(consumer)) {
+            affinity += 2
+        }
+    }
+    for (const neighbor of module.neighbors) {
+        if (bin.moduleIds.includes(neighbor)) {
+            affinity += 1
+        }
+    }
+    return affinity
+}
+
+/** Freezes bin membership and derives a stable subpackage root from sorted module IDs. */
+function createPackedSubpackage(bin: SubpackageBin): PackedSubpackage {
+    const moduleIds = [...bin.moduleIds].sort()
+    const hash = createHash('sha256').update(moduleIds.join('\0')).digest('hex').slice(0, 8)
+    return {
+        kind: 'subpackage',
+        root: `${generatedSubpackageRootPrefix}${hash}`,
+        moduleIds
+    }
+}
+
+/** Uses the generated root directory itself as the native subpackage alias. */
+export function getSubpackageName(root: string): string {
+    return root.slice(root.lastIndexOf('/') + 1)
+}
+
+/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
+export function isGeneratedSubpackageFile(fileName: string): boolean {
+    return fileName.startsWith(generatedSubpackageRootPrefix)
+}

package/src/node/plugins/wx/plugins.ts

@@ -0,0 +1,165 @@
+import type { Plugin, PluginOption } from 'vite'
+import type { VitePluginTaroOptions } from '../../../options.ts'
+import { esTarget } from '../../utils/constant.ts'
+import { packageRequire } from '../../utils/packages.ts'
+import { clientTaroNativeId } from '../client/constant.ts'
+import { createWxDevelopmentPlugin } from './dev/plugin.ts'
+import { getWxExecutionKind, isTransportModule } from './module.ts'
+import { compileNativeComponentInterface } from './native/compile-native-component-interface.ts'
+import { getNativeComponentAssetBytes } from './native/native-component-assets.ts'
+import { createOutputFiles } from './output/files.ts'
+import { createPlacer } from './placement/placer.ts'
+import { renderCapsule } from './render/capsule.ts'
+import { renderNative } from './render/native.ts'
+import { materializeTransport } from './render/transport.ts'
+import { createResolver } from './resolve/resolver.ts'
+
+/** Creates the complete plugin set for the wx target. */
+export function createWxTargetPlugins(options: VitePluginTaroOptions): PluginOption[] {
+    return [createWxPlugin(options), createWxDevelopmentPlugin(options)]
+}
+
+/** Configures the complete wx target build pipeline. */
+function createWxPlugin(options: VitePluginTaroOptions): Plugin {
+    const resolver = createResolver(options)
+    const placer = createPlacer()
+
+    return {
+        name: 'vpt:wx',
+
+        config(_config, _env) {
+            return {
+                define: createTaroDefines(),
+
+                appType: 'custom',
+
+                oxc: { target: esTarget },
+
+                resolve: {
+                    alias: [
+                        {
+                            find: /^@tarojs\/components$/,
+                            replacement: packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react')
+                        }
+                    ]
+                },
+
+                build: {
+                    modulePreload: false,
+                    cssCodeSplit: false,
+                    // Let weapp-tailwindcss own final WXSS transformation.
+                    cssMinify: false,
+
+                    // No base64 assets: Taro warns on image srcs above ~2KB, and inlined
+                    // images bloat the JS bundle toward the mini program package limit.
+                    assetsInlineLimit: 0,
+
+                    target: esTarget,
+
+                    rolldownOptions: {
+                        ...placer.rolldownOptions,
+                        input: resolver.input
+                    }
+                }
+            }
+        },
+
+        resolveId(id, importer) {
+            return resolver.resolveId(id, importer, this.environment.config.root)
+        },
+
+        transform: {
+            order: 'pre',
+            async handler(code, id) {
+                const sourcemap = Boolean(this.environment.config.build.sourcemap)
+
+                if (code.includes(clientTaroNativeId)) {
+                    return compileNativeComponentInterface({
+                        code,
+                        id,
+                        sourcemap,
+                        addWatchFile: (file) => this.addWatchFile(file)
+                    })
+                }
+
+                return resolver.specialize(code, id, sourcemap)
+            }
+        },
+
+        renderStart() {
+            placer.analyze({
+                moduleIds: this.getModuleIds(),
+                getModuleInfo: (moduleId) => this.getModuleInfo(moduleId),
+                getAdditionalModuleBytes: (info) => getNativeComponentAssetBytes(info.meta)
+            })
+        },
+
+        renderChunk: {
+            order: 'post',
+            async handler(code, chunk, outputOptions, meta) {
+                const executionKind = getWxExecutionKind(chunk)
+                const sourcemap = Boolean(outputOptions.sourcemap)
+
+                if (executionKind === 'capsule') {
+                    return renderCapsule(code, chunk, sourcemap)
+                }
+
+                // Native and amphibious modules share the CommonJS renderer. Amphibious transport exposure is a
+                // separate concern materialized from final output paths after the physical transport itself is rendered.
+                const native = renderNative({ code, chunk, chunks: meta.chunks, sourcemap })
+
+                if (isTransportModule(chunk)) {
+                    return materializeTransport({
+                        code: native.code,
+                        transportChunk: chunk,
+                        chunks: meta.chunks,
+                        getLoadMode: placer.getLoadMode,
+                        sourcemap
+                    })
+                }
+
+                return native
+            }
+        },
+
+        generateBundle: {
+            order: 'post',
+            async handler(_, bundle) {
+                const subpackages = placer.getSubpackages(bundle)
+
+                const outputFiles = await createOutputFiles({
+                    bundle,
+                    options,
+                    subpackages,
+                    getModuleInfo: (moduleId) => this.getModuleInfo(moduleId)
+                })
+
+                outputFiles.forEach((file) => {
+                    this.emitFile(file)
+                })
+            }
+        }
+    }
+}
+
+/** Creates the build-time constants required by Taro's legacy feature gates. */
+function createTaroDefines(): Record<string, string> {
+    const taroVersion = String((packageRequire('@tarojs/runtime/package.json') as { version: string }).version)
+
+    return {
+        'process.env.FRAMEWORK': JSON.stringify('react'),
+        'process.env.SUPPORT_TARO_POLYFILL': JSON.stringify('disabled'),
+        'process.env.TARO_ENV': JSON.stringify('weapp'),
+        'process.env.TARO_PLATFORM': JSON.stringify('mini'),
+        'process.env.TARO_VERSION': JSON.stringify(taroVersion),
+        // React's development-only Suspense diagnostics call this browser API without guards.
+        'performance.now': 'Date.now',
+        ENABLE_ADJACENT_HTML: 'false',
+        ENABLE_CLONE_NODE: 'false',
+        ENABLE_CONTAINS: 'false',
+        ENABLE_INNER_HTML: 'false',
+        ENABLE_MUTATION_OBSERVER: 'false',
+        ENABLE_SIZE_APIS: 'false',
+        ENABLE_TEMPLATE_CONTENT: 'false'
+    }
+}