vite-plugin-taro 0.2.2 → 0.3.1

package/src/node/targets/wx/companion-assets.ts

@@ -0,0 +1,170 @@
+import path from 'node:path'
+import { recursiveMerge } from '@tarojs/helper'
+import { Weapp as WxPlatform } from '@tarojs/plugin-platform-weapp'
+import type { JsonObject } from '../../../options.ts'
+import type { BuildContext } from '../../build-context.ts'
+import { normalizeModuleId } from '../../utils/modules.ts'
+import { packageRequire } from '../../utils/packages.ts'
+
+type WxAssetSource = string | Uint8Array
+
+export type WxBundle = Record<
+    string,
+    {
+        type: 'asset' | 'chunk'
+        source?: WxAssetSource
+        modules?: Record<string, { renderedExports?: string[] }>
+    }
+>
+
+type WxAssetEmitter = {
+    emitFile(asset: { type: 'asset'; fileName: string; source: WxAssetSource }): string
+    warn(message: string): void
+}
+
+type WxTemplateComponentConfig = {
+    includes: Set<string>
+    exclude: Set<string>
+    thirdPartyComponents: Map<string, Set<string>>
+    includeAll: boolean
+}
+
+const taroWxComponentsPath = packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react')
+const templateBuilder = createWxTemplateBuilder()
+
+export function emitWxCompanionAssets(emitter: WxAssetEmitter, bundle: WxBundle, context: BuildContext): void {
+    for (const asset of createWxCompanionAssets(bundle, context)) {
+        if (!asset) continue
+        if (asset.source === undefined) {
+            emitter.warn(
+                `[vite-plugin-taro] WX companion asset "${asset.fileName}" is missing its source and was not emitted.`
+            )
+            continue
+        }
+        emitter.emitFile({ type: 'asset', fileName: asset.fileName, source: asset.source })
+    }
+}
+
+function createWxCompanionAssets(
+    bundle: WxBundle,
+    context: BuildContext
+): ({ fileName: string; source: WxAssetSource } | undefined)[] {
+    const json = (value: JsonObject) => (context.development ? JSON.stringify(value, null, 2) : JSON.stringify(value))
+
+    return [
+        { fileName: 'app.json', source: json(context.project.appConfig) },
+        { fileName: 'app.wxss', source: collectWxBundleStyles(bundle) },
+        {
+            fileName: 'base.wxml',
+            source: templateBuilder.buildTemplate(collectWxTemplateComponentConfig(bundle))
+        },
+        { fileName: 'utils.wxs', source: templateBuilder.buildXScript() },
+        { fileName: 'comp.wxml', source: templateBuilder.buildBaseComponentTemplate('.wxml') },
+        { fileName: 'comp.json', source: json(createWxComponentConfig()) },
+        { fileName: 'project.config.json', source: json(createWxProjectConfig(context)) },
+        context.project.projectPrivateConfigJson
+            ? { fileName: 'project.private.config.json', source: json(context.project.projectPrivateConfigJson) }
+            : undefined,
+        { fileName: 'sitemap.json', source: json(context.project.sitemapJson) },
+        ...context.project.pages.flatMap((page) => [
+            {
+                fileName: `${page.path}.wxml`,
+                source: templateBuilder.buildPageTemplate(relativeWxRootAsset(page.path, 'base.wxml'), {
+                    content: page.config,
+                    path: page.path
+                })
+            },
+            {
+                fileName: `${page.path}.json`,
+                source: json({
+                    ...page.config,
+                    usingComponents: { comp: relativeWxRootAsset(page.path, 'comp') }
+                })
+            },
+            { fileName: `${page.path}.wxss`, source: '' }
+        ])
+    ]
+}
+
+function createWxProjectConfig(context: BuildContext): JsonObject {
+    const projectConfig = context.project.projectConfigJson
+    const setting = isJsonObject(projectConfig.setting) ? projectConfig.setting : {}
+    return {
+        ...projectConfig,
+        setting: { ...setting, compileHotReLoad: true }
+    }
+}
+
+function isJsonObject(value: unknown): value is JsonObject {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function createWxTemplateBuilder() {
+    const platform = new WxPlatform(
+        { helper: { recursiveMerge }, modifyWebpackChain() {}, registerPlatform() {} },
+        {},
+        {}
+    )
+    platform.modifyTemplate({})
+    return platform.template
+}
+
+function relativeWxRootAsset(pagePath: string, rootAsset: string): string {
+    const relativePath = path.posix.relative(path.posix.dirname(pagePath), rootAsset)
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+}
+
+function collectWxTemplateComponentConfig(bundle: WxBundle): WxTemplateComponentConfig {
+    const config: WxTemplateComponentConfig = {
+        includes: new Set([
+            'view',
+            'catch-view',
+            'static-view',
+            'pure-view',
+            'click-view',
+            'scroll-view',
+            'image',
+            'static-image',
+            'text',
+            'static-text'
+        ]),
+        exclude: new Set(),
+        thirdPartyComponents: new Map(),
+        includeAll: false
+    }
+    const components = findBundleModule(bundle, taroWxComponentsPath)
+    for (const name of components?.renderedExports ?? []) config.includes.add(toDashed(name))
+    return config
+}
+
+function findBundleModule(bundle: WxBundle, resolvedId: string): { renderedExports?: string[] } | undefined {
+    const normalizedResolvedId = normalizeModuleId(resolvedId)
+    for (const item of Object.values(bundle)) {
+        if (item.type !== 'chunk') continue
+        const found = Object.entries(item.modules ?? {}).find(([id]) => normalizeModuleId(id) === normalizedResolvedId)
+        if (found) return found[1]
+    }
+}
+
+function toDashed(value: string): string {
+    return value.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
+}
+
+function createWxComponentConfig(): JsonObject {
+    return {
+        component: true,
+        styleIsolation: 'apply-shared',
+        usingComponents: { comp: './comp' }
+    }
+}
+
+function collectWxBundleStyles(bundle: WxBundle): string {
+    const styles: string[] = []
+    for (const [fileName, item] of Object.entries(bundle)) {
+        if (item.type !== 'asset' || !fileName.endsWith('.css')) continue
+        const source = typeof item.source === 'string' ? item.source : new TextDecoder().decode(item.source)
+        if (source) styles.push(source)
+        delete bundle[fileName]
+    }
+    return styles.join('\n')
+}

package/src/node/targets/wx/dev-server/development-session.ts

@@ -0,0 +1,253 @@
+/**
+ * Top-level owner of one WX development lifecycle.
+ *
+ * It serializes every output write, connects DevEngine patches to the update transport, and coalesces conservative full
+ * rebuilds. No other module writes plugin-generated WX development files directly.
+ */
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import colors from 'picocolors'
+import type { ViteDevServer } from 'vite'
+import type { BuildContext } from '../../../build-context.ts'
+import { SerializedTaskQueue } from '../../../utils/async.ts'
+import {
+    copyDirectoryIfExists,
+    copyFileOrRemove,
+    writeFileAtomically,
+    writeFilesAtomically
+} from '../../../utils/filesystem.ts'
+import { wxDevelopmentDirectory, wxUpdateControlFile, wxUpdateFile } from '../development-files.ts'
+import { FullBuildScheduler } from './full-build-scheduler.ts'
+import { transformWxCompatibleJavaScript, transformWxOutputChunks } from './js-utils.ts'
+import { isWxFullBuildOutput, normalizeWxBundleStyles, setWxAppStyles, type WxOutputFile } from './output.ts'
+import { WxUpdateTransport } from './update-transport.ts'
+import { ViteBundledDevAdapter, type WxDevEngineUpdate } from './vite-bundled-dev-adapter.ts'
+
+const maxRetainedDeltaCount = 1_000
+const maxRetainedDeltaBytes = 16 * 1024 * 1024
+const fullBuildDebounceDelay = 100
+
+type WxDevServerContext = Pick<BuildContext, 'vite' | 'css'>
+type SessionSnapshot = Readonly<{
+    lifecycle: 'open' | 'closed'
+    outputPhase: 'starting' | 'ready'
+    latestAppStyles: string
+}>
+
+/** Owns one WX bundled-development graph and all writes to its fixed output directory. */
+export class WxDevelopmentSession {
+    private readonly adapter: ViteBundledDevAdapter
+    private readonly updateTransport: WxUpdateTransport
+    private readonly outDir: string
+    private readonly initialBundle = Promise.withResolvers<void>()
+    private readonly outputQueue: SerializedTaskQueue
+    private readonly fullBuildScheduler: FullBuildScheduler
+    private originalPrintUrls: (() => void) | undefined
+    private snapshot: SessionSnapshot = { lifecycle: 'open', outputPhase: 'starting', latestAppStyles: '' }
+
+    constructor(
+        private readonly context: WxDevServerContext,
+        private readonly server: ViteDevServer
+    ) {
+        const config = context.vite
+        this.outDir = path.resolve(config.root, config.build.outDir)
+        this.outputQueue = new SerializedTaskQueue((error) => this.reportOutputError(error))
+        this.updateTransport = new WxUpdateTransport(
+            server,
+            () => this.requestFullBuild(),
+            (buildId, source) =>
+                this.outputQueue.enqueue(async () => {
+                    // A full build queued before this write invalidates the old batch instead of letting it overwrite
+                    // the new build's empty update.js.
+                    if (!this.updateTransport.isCurrentBuild(buildId)) return
+                    await writeFileAtomically(path.join(this.outDir, wxUpdateFile), source)
+                })
+        )
+        this.adapter = new ViteBundledDevAdapter(config, server, {
+            onOutput: (output) => this.handleBundleOutput(output),
+            onPatch: (files, output) => this.handlePatch(files, output),
+            onError: (message) => this.handleError(message),
+            waitForInitialBundle: () => this.waitForInitialBundle()
+        })
+        this.fullBuildScheduler = new FullBuildScheduler(
+            fullBuildDebounceDelay,
+            () => this.adapter.rebuild(),
+            (error) => this.reportRebuildError(error)
+        )
+    }
+
+    private get config() {
+        return this.context.vite
+    }
+
+    install(): void {
+        this.updateTransport.install()
+        this.server.httpServer?.once('listening', this.handleHttpListening)
+        this.adapter.install()
+        this.originalPrintUrls = this.server.printUrls.bind(this.server)
+        this.server.printUrls = this.printUrls
+        if (this.config.publicDir) this.server.watcher.add(this.config.publicDir)
+        this.server.watcher.on('change', this.handleWatchedFile)
+        this.server.watcher.on('add', this.handleWatchedFile)
+        this.server.watcher.on('unlink', this.handleWatchedFile)
+    }
+
+    async close(): Promise<void> {
+        if (this.snapshot.lifecycle === 'closed') return
+        this.snapshot = { ...this.snapshot, lifecycle: 'closed' }
+        this.server.watcher.off('change', this.handleWatchedFile)
+        this.server.watcher.off('add', this.handleWatchedFile)
+        this.server.watcher.off('unlink', this.handleWatchedFile)
+        this.server.httpServer?.off('listening', this.handleHttpListening)
+        if (this.server.printUrls === this.printUrls && this.originalPrintUrls) {
+            this.server.printUrls = this.originalPrintUrls
+        }
+        this.updateTransport.close()
+        await this.fullBuildScheduler.close()
+        await this.outputQueue.waitForIdle()
+    }
+
+    private readonly printUrls = (): void => {
+        this.originalPrintUrls?.()
+        const projectDirectory = relativeToViteConfig(this.outDir, this.config.configFile, this.config.root)
+        this.server.config.logger.info(
+            `  ${colors.green('➜')}  ${colors.bold('WeChat DevTools')}: ${colors.cyan(projectDirectory)}`
+        )
+    }
+
+    private readonly handleHttpListening = (): void => {
+        this.outputQueue.enqueue(() =>
+            writeFileAtomically(path.join(this.outDir, wxUpdateControlFile), this.updateTransport.createControlSource())
+        )
+    }
+
+    private readonly handleWatchedFile = (file: string): void => {
+        if (isFileInside(file, this.config.publicDir)) {
+            const destination = path.join(this.outDir, path.relative(this.config.publicDir, file))
+            this.outputQueue.enqueue(() => copyFileOrRemove(file, destination))
+            this.requestFullBuild()
+        }
+    }
+
+    private handleBundleOutput(output: WxOutputFile[]): void {
+        const appStyles = normalizeWxBundleStyles(output)
+        if (appStyles !== undefined) this.snapshot = { ...this.snapshot, latestAppStyles: appStyles }
+        if (isWxFullBuildOutput(output) && this.snapshot.latestAppStyles) {
+            setWxAppStyles(output, this.snapshot.latestAppStyles)
+        }
+
+        if (!isWxFullBuildOutput(output)) {
+            this.outputQueue.enqueue(async () => {
+                await transformWxOutputChunks(output)
+                await writeDevelopmentOutput(this.outDir, output)
+            })
+            return
+        }
+
+        const buildId = this.updateTransport.createBuildId()
+        setDevelopmentAsset(output, wxUpdateControlFile, this.updateTransport.createControlSource(buildId))
+        setDevelopmentAsset(output, wxUpdateFile, 'void 0;\n')
+        this.outputQueue.enqueue(async () => {
+            await transformWxOutputChunks(output)
+            if (this.snapshot.outputPhase === 'starting') {
+                // The directory is plugin-owned; clearing it once removes stale files from previous protocol designs.
+                await fs.rm(path.join(this.outDir, wxDevelopmentDirectory), { recursive: true, force: true })
+            }
+            // Invalidate old HTTP reports before writing the new build epoch into the fixed DevTools directory.
+            this.updateTransport.commitFullBuild(buildId)
+            await writeDevelopmentOutput(this.outDir, output)
+            await copyDirectoryIfExists(this.config.publicDir, this.outDir)
+            const moduleCount = this.adapter.registerBundleModules(output)
+            this.snapshot = { ...this.snapshot, outputPhase: 'ready' }
+            this.initialBundle.resolve()
+            this.server.config.logger.info(
+                `[vite-plugin-taro] WX bundle ready (${moduleCount} modules, ${output.length} files)`
+            )
+        })
+    }
+
+    private handlePatch(files: string[], output: WxDevEngineUpdate): boolean {
+        if (!isSafeJavaScriptPatch(files, output)) {
+            this.requestFullBuild()
+            return false
+        }
+
+        this.adapter.registerPatchModules(output.code)
+        this.outputQueue.enqueue(async () => {
+            const transformed = await this.context.css.transformWxClassNames(output.code, output.filename)
+            const compatibleCode = await transformWxCompatibleJavaScript(transformed.code, output.filename)
+            if (
+                this.updateTransport.retainedDeltaCount >= maxRetainedDeltaCount ||
+                this.updateTransport.retainedDeltaBytes + Buffer.byteLength(compatibleCode) >= maxRetainedDeltaBytes
+            ) {
+                this.requestFullBuild()
+                return
+            }
+            this.updateTransport.addDelta(compatibleCode)
+        })
+        return true
+    }
+
+    private handleError(message: string): void {
+        this.server.config.logger.error('[vite-plugin-taro] WX update failed', { error: new Error(message) })
+    }
+
+    private requestFullBuild(): void {
+        this.fullBuildScheduler.request()
+    }
+
+    private async waitForInitialBundle(): Promise<void> {
+        await this.initialBundle.promise
+        await this.outputQueue.waitForIdle()
+    }
+
+    private reportOutputError(error: unknown): void {
+        const normalizedError = error instanceof Error ? error : new Error(String(error))
+        this.server.config.logger.error(
+            `[vite-plugin-taro] WX development output failed: ${normalizedError.stack ?? normalizedError.message}`
+        )
+    }
+
+    private reportRebuildError(error: unknown): void {
+        const normalizedError = error instanceof Error ? error : new Error(String(error))
+        this.server.config.logger.error('[vite-plugin-taro] WX rebuild failed', { error: normalizedError })
+    }
+}
+
+function writeDevelopmentOutput(outDir: string, output: WxOutputFile[]): Promise<void> {
+    return writeFilesAtomically(
+        output.map((item) => ({
+            file: path.join(outDir, item.fileName),
+            source: item.type === 'chunk' ? item.code : item.source
+        }))
+    )
+}
+
+function setDevelopmentAsset(output: WxOutputFile[], fileName: string, source: string): void {
+    const index = output.findIndex((item) => item.type === 'asset' && item.fileName === fileName)
+    const asset: WxOutputFile = { type: 'asset', fileName, source }
+    if (index >= 0) output[index] = asset
+    else output.push(asset)
+}
+
+function relativeToViteConfig(outDir: string, configFile: string | undefined, root: string): string {
+    const configDirectory = configFile ? path.dirname(configFile) : root
+    const relativePath = path.relative(configDirectory, outDir).replaceAll('\\', '/')
+    if (!relativePath) return '.'
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+}
+
+function isFileInside(file: string, directory: string): boolean {
+    if (!directory) return false
+    const relative = path.relative(directory, file)
+    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)
+}
+
+function isSafeJavaScriptPatch(
+    files: string[],
+    output: WxDevEngineUpdate
+): output is Extract<WxDevEngineUpdate, { type: 'Patch' }> {
+    if (output.type !== 'Patch' || output.hmrBoundaries.length === 0) return false
+    if (output.code.includes('__vite__updateStyle') || output.code.includes('.updateStyle(')) return false
+    return files.every((file) => /\.[cm]?[jt]sx?$/.test(file))
+}

package/src/node/targets/wx/dev-server/full-build-scheduler.ts

@@ -0,0 +1,62 @@
+/** Full-build scheduling owned by one WX development session. */
+
+type FullBuildPhase = 'idle' | 'scheduled' | 'building' | 'building-with-pending-request' | 'closed'
+
+/** Coalesces trailing-edge requests while guaranteeing one full build at a time. */
+export class FullBuildScheduler {
+    private readonly delay: number
+    private readonly runBuild: () => Promise<void>
+    private readonly reportError: (error: unknown) => void
+    private phase: FullBuildPhase = 'idle'
+    private timer: NodeJS.Timeout | undefined
+    private work: Promise<void> | undefined
+
+    constructor(delay: number, runBuild: () => Promise<void>, reportError: (error: unknown) => void) {
+        this.delay = delay
+        this.runBuild = runBuild
+        this.reportError = reportError
+    }
+
+    request(): void {
+        switch (this.phase) {
+            case 'closed':
+                return
+            case 'building':
+                this.phase = 'building-with-pending-request'
+                return
+            case 'building-with-pending-request':
+                return
+            case 'idle':
+            case 'scheduled':
+                if (this.timer) clearTimeout(this.timer)
+                this.phase = 'scheduled'
+                this.timer = setTimeout(() => this.start(), this.delay)
+        }
+    }
+
+    async close(): Promise<void> {
+        if (this.phase === 'closed') {
+            await this.work
+            return
+        }
+        this.phase = 'closed'
+        if (this.timer) clearTimeout(this.timer)
+        this.timer = undefined
+        await this.work
+    }
+
+    private start(): void {
+        if (this.phase !== 'scheduled') return
+        this.timer = undefined
+        this.phase = 'building'
+        this.work = this.runBuild()
+            .catch(this.reportError)
+            .finally(() => {
+                this.work = undefined
+                if (this.phase === 'closed') return
+                const repeat = this.phase === 'building-with-pending-request'
+                this.phase = 'idle'
+                if (repeat) this.request()
+            })
+    }
+}

package/src/node/targets/wx/dev-server/js-utils.ts

@@ -0,0 +1,33 @@
+import { transformWithOxc } from 'vite'
+import type { WxOutputFile } from './output.ts'
+
+const wxJavaScriptTarget = 'es2018'
+
+/** Lowers generated JavaScript syntax that WeChat's upload parser does not accept. */
+export async function transformWxCompatibleJavaScript(code: string, filename: string): Promise<string> {
+    const result = await transformWithOxc(code, filename, {
+        lang: 'js',
+        target: wxJavaScriptTarget,
+        sourcemap: false,
+        assumptions: {
+            // Avoid external Oxc helpers when lowering public class fields in already-bundled chunks.
+            setPublicClassFields: true
+        }
+    })
+    return result.code
+}
+
+/** Applies the compatibility transform to every JavaScript chunk in a DevEngine output batch. */
+export async function transformWxOutputChunks(output: WxOutputFile[]): Promise<void> {
+    await Promise.all(
+        output.map(async (item, index) => {
+            if (item.type !== 'chunk') return
+            output[index] = {
+                type: 'chunk',
+                fileName: item.fileName,
+                modules: item.modules,
+                code: await transformWxCompatibleJavaScript(item.code, item.fileName)
+            }
+        })
+    )
+}

package/src/node/targets/wx/dev-server/output.ts

@@ -0,0 +1,56 @@
+/**
+ * Normalizes private DevEngine output before the development session writes it to the fixed WX project directory.
+ * DevEngine rebuilds may be partial, so these helpers mutate only files present in the current output.
+ */
+
+/** File shape emitted by Vite's private bundled-development engine. */
+export type WxOutputFile =
+    | {
+          type: 'chunk'
+          fileName: string
+          code: string
+          modules?: Record<string, unknown>
+      }
+    | {
+          type: 'asset'
+          fileName: string
+          source: string | Uint8Array
+      }
+
+/** Extracts Vite's development CSS payloads and materializes them as app.wxss. */
+export function normalizeWxBundleStyles(output: WxOutputFile[]): string | undefined {
+    const styles: string[] = []
+    for (let index = output.length - 1; index >= 0; index--) {
+        const item = output[index]
+        if (!item) continue
+        if (item.type === 'asset' && item.fileName.endsWith('.css')) {
+            styles.unshift(typeof item.source === 'string' ? item.source : new TextDecoder().decode(item.source))
+            output.splice(index, 1)
+        } else if (item.type === 'chunk') {
+            styles.push(...collectEmbeddedStyles(item.code))
+        }
+    }
+    if (styles.length === 0) return
+    const source = styles.join('\n')
+    setWxAppStyles(output, source)
+    return source
+}
+
+export function setWxAppStyles(output: WxOutputFile[], source: string): void {
+    const index = output.findIndex((item) => item.type === 'asset' && item.fileName === 'app.wxss')
+    const appStyle: WxOutputFile = { type: 'asset', fileName: 'app.wxss', source }
+    if (index >= 0) output[index] = appStyle
+    else output.push(appStyle)
+}
+
+export function isWxFullBuildOutput(output: WxOutputFile[]): boolean {
+    return output.some((item) => item.fileName === 'app.js')
+}
+
+function collectEmbeddedStyles(code: string): string[] {
+    const styles: string[] = []
+    for (const match of code.matchAll(/__vite__css(?:\$\d+)?\s*=\s*("(?:\\.|[^"\\])*");/g)) {
+        if (match[1]) styles.push(JSON.parse(match[1]) as string)
+    }
+    return styles
+}

package/src/node/targets/wx/dev-server/rolldown-runtime-source.ts

@@ -0,0 +1,95 @@
+/**
+ * Self-contained source injected into Rolldown's DevEngine as the WX module bootstrap runtime.
+ *
+ * This TypeScript module runs in Node and only exports source text. The exported JavaScript becomes
+ * `runtime.js`, executes before every application module, and therefore cannot import Taro, React,
+ * or any module that depends on the runtime it is creating.
+ */
+export const wxRolldownRuntimeSource = `
+var BaseDevRuntime = DevRuntime;
+class WxHotContext {
+  callbacks = [];
+  data = {};
+  _internal = { updateStyle() {}, removeStyle() {} };
+  constructor(moduleId) { this.moduleId = moduleId; }
+  accept(...args) {
+    if (args.length === 0) {
+      this.callbacks.push({ deps: this.moduleId, callback: undefined });
+    } else if (args.length === 1 && typeof args[0] === 'function') {
+      this.callbacks.push({ deps: this.moduleId, callback: args[0] });
+    } else if (args.length === 1) {
+      this.callbacks.push({ deps: args[0], callback: undefined });
+    } else {
+      this.callbacks.push({ deps: args[0], callback: args[1] });
+    }
+  }
+  acceptExports(_exports, callback) { this.accept(callback); }
+  dispose() {}
+  prune() {}
+  invalidate() {}
+  on() {}
+  off() {}
+  send() {}
+}
+class WxRolldownRuntime extends BaseDevRuntime {
+  contexts = new Map();
+  patchedModules = new Set();
+  applyingPatch = false;
+
+  createEsmInitializer = (id, initialize, _deduplicate, result) => () => {
+    if (!initialize) return result;
+    if (!this.applyingPatch && this.patchedModules.has(id)) {
+      initialize = undefined;
+      return result;
+    }
+    const callback = initialize;
+    initialize = undefined;
+    result = callback(id);
+    if (this.applyingPatch) this.patchedModules.add(id);
+    return result;
+  };
+
+  createCjsInitializer = (id, initialize, _deduplicate, module) => () => {
+    if (module) return module.exports;
+    if (!this.applyingPatch && this.patchedModules.has(id)) return this.loadExports(id);
+    module = { exports: {} };
+    initialize(module.exports, module, id);
+    if (this.applyingPatch) this.patchedModules.add(id);
+    return module.exports;
+  };
+
+  createModuleHotContext(moduleId) {
+    const previous = this.contexts.get(moduleId);
+    const context = new WxHotContext(moduleId);
+    if (previous) {
+      context.callbacks = previous.callbacks;
+      context.data = previous.data;
+    }
+    this.contexts.set(moduleId, context);
+    return context;
+  }
+
+  beginPatch() { this.applyingPatch = true; }
+  endPatch() { this.applyingPatch = false; }
+
+  applyUpdates(boundaries) {
+    for (const [boundary, acceptedVia] of boundaries) {
+      const context = this.contexts.get(boundary);
+      if (!context) continue;
+      const callbacks = [...context.callbacks];
+      if (boundary === acceptedVia) context.callbacks = [];
+      for (const { deps, callback } of callbacks) {
+        if (!callback) continue;
+        if (Array.isArray(deps)) {
+          if (deps.includes(acceptedVia)) callback(deps.map((id) => this.loadExports(id)));
+        } else if (deps === acceptedVia) {
+          callback(this.loadExports(acceptedVia));
+        }
+      }
+    }
+  }
+}
+// A full DevEngine runtime starts a new page-update generation before any application chunk executes.
+globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__ = { ready: false };
+globalThis.__rolldown_runtime__ = new WxRolldownRuntime(undefined, 'vite-plugin-taro-wx');
+`