vite-plugin-taro 0.3.2 → 0.4.0

package/src/node/targets/wx/dev-server/vite-bundled-dev-adapter.ts

@@ -1,203 +0,0 @@
-import path from 'node:path'
-import type { ResolvedConfig, ViteDevServer } from 'vite'
-import { wxPagePreloadFile, wxUpdateControlFile, wxUpdateFile } from '../development-files.ts'
-import type { WxOutputFile } from './output.ts'
-import { wxRolldownRuntimeSource } from './rolldown-runtime-source.ts'
-
-const clientId = 'vite-plugin-taro-wx'
-
-/** HMR boundary shape returned by Vite's private WX DevEngine integration. */
-type WxDevEngineBoundary = {
-    boundary: string
-    acceptedVia: string
-}
-
-/** Update result shape returned by Vite's private bundled-development engine. */
-export type WxDevEngineUpdate =
-    | { type: 'Noop' }
-    | { type: 'FullReload'; reason?: string }
-    | {
-          type: 'Patch'
-          code: string
-          filename: string
-          hmrBoundaries: WxDevEngineBoundary[]
-      }
-
-type WxDevEngineInternal = {
-    registerModules(clientId: string, modules: string[]): void
-    ensureCurrentBuildFinish(): Promise<void>
-    ensureLatestBuildOutput(): Promise<unknown>
-    getBundleState(): Promise<{ lastBuildErrored: boolean }>
-    triggerFullBuild(): void
-}
-
-type WxRolldownOptions = {
-    output?: Record<string, unknown> | Array<Record<string, unknown>>
-    experimental?: {
-        devMode?: boolean | Record<string, unknown>
-        [key: string]: unknown
-    }
-    [key: string]: unknown
-}
-
-type WxDevEngineClient = {
-    send(payload: unknown): void
-}
-
-type ViteBundledDevInternal = {
-    _devEngine?: WxDevEngineInternal
-    clients: {
-        setupIfNeeded(client: WxDevEngineClient, clientId: string): void
-    }
-    getRolldownOptions(): Promise<WxRolldownOptions>
-    storeOutputFiles(output: WxOutputFile[]): void
-    handleHmrOutput(client: WxDevEngineClient, files: string[], output: WxDevEngineUpdate, info?: unknown): void
-    listen(): Promise<void>
-}
-
-type ViteBundledDevCallbacks = {
-    onOutput(output: WxOutputFile[]): void
-    onPatch(files: string[], output: WxDevEngineUpdate): boolean
-    onError(message: string): void
-    waitForInitialBundle(): Promise<void>
-}
-
-/** Isolates the private Vite bundled-development API used by the WX session. */
-export class ViteBundledDevAdapter {
-    private bundledDev: ViteBundledDevInternal | undefined
-
-    constructor(
-        private readonly config: ResolvedConfig,
-        private readonly server: ViteDevServer,
-        private readonly callbacks: ViteBundledDevCallbacks
-    ) {}
-
-    install(): void {
-        const bundledDev = this.server.environments.client.bundledDev as unknown as ViteBundledDevInternal | undefined
-        if (!bundledDev) throw new Error('vite-plugin-taro requires Vite bundled development for WX development.')
-        if (
-            typeof bundledDev.getRolldownOptions !== 'function' ||
-            typeof bundledDev.storeOutputFiles !== 'function' ||
-            typeof bundledDev.handleHmrOutput !== 'function'
-        ) {
-            throw new Error('vite-plugin-taro does not support this Vite bundled-development API shape.')
-        }
-        this.bundledDev = bundledDev
-        this.installOptions(bundledDev)
-        this.installOutput(bundledDev)
-        this.installPatches(bundledDev)
-        this.installListener(bundledDev)
-    }
-
-    registerBundleModules(output: WxOutputFile[]): number {
-        const moduleIds = new Set<string>()
-        for (const item of output) {
-            if (item.type !== 'chunk') continue
-            for (const id of Object.keys(item.modules ?? {})) moduleIds.add(toStableModuleId(id, this.config.root))
-        }
-        this.registerModules([...moduleIds])
-        return moduleIds.size
-    }
-
-    registerPatchModules(code: string): void {
-        const moduleIds = new Set<string>()
-        for (const match of code.matchAll(/create(?:Esm|Cjs)Initializer\("([^"]+)"/g)) moduleIds.add(match[1])
-        this.registerModules([...moduleIds])
-    }
-
-    private registerModules(moduleIds: string[]): void {
-        if (moduleIds.length) this.bundledDev?._devEngine?.registerModules(clientId, moduleIds)
-    }
-
-    async rebuild(): Promise<void> {
-        const engine = this.bundledDev?._devEngine
-        if (!engine) return
-        engine.triggerFullBuild()
-        await engine.ensureLatestBuildOutput()
-    }
-
-    private installOptions(bundledDev: ViteBundledDevInternal): void {
-        const getRolldownOptions = bundledDev.getRolldownOptions.bind(bundledDev)
-        bundledDev.getRolldownOptions = async () => {
-            const options = await getRolldownOptions()
-            if (!options.output) options.output = {}
-            const output = getFirstOutput(options)
-            const configuredOutput = this.config.build.rolldownOptions.output
-            const desiredOutput = Array.isArray(configuredOutput) ? configuredOutput[0] : configuredOutput
-            Object.assign(output, desiredOutput, {
-                format: 'cjs',
-                sourcemap: false,
-                minify: false,
-                banner: createWxDevelopmentBanner
-            })
-            options.experimental ??= {}
-            options.experimental.devMode = {
-                ...(typeof options.experimental.devMode === 'object' ? options.experimental.devMode : {}),
-                lazy: false,
-                // Rolldown compiles this source into runtime.js before any Taro/React module executes.
-                implement: wxRolldownRuntimeSource
-            }
-            return options
-        }
-    }
-
-    private installOutput(bundledDev: ViteBundledDevInternal): void {
-        const storeOutputFiles = bundledDev.storeOutputFiles.bind(bundledDev)
-        bundledDev.storeOutputFiles = (output) => {
-            storeOutputFiles(output)
-            this.callbacks.onOutput(output)
-        }
-    }
-
-    private installPatches(bundledDev: ViteBundledDevInternal): void {
-        const handleHmrOutput = bundledDev.handleHmrOutput.bind(bundledDev)
-        bundledDev.handleHmrOutput = (client, files, output, info) => {
-            if (output.type === 'Noop') return
-            if (this.callbacks.onPatch(files, output)) handleHmrOutput(client, files, output, info)
-        }
-    }
-
-    private installListener(bundledDev: ViteBundledDevInternal): void {
-        const listen = bundledDev.listen.bind(bundledDev)
-        bundledDev.listen = async () => {
-            await listen()
-            bundledDev.clients.setupIfNeeded({ send: (payload) => this.handlePayload(payload) }, clientId)
-            const engine = bundledDev._devEngine
-            if (!engine) throw new Error('vite-plugin-taro expected Vite to initialize the WX DevEngine.')
-            await engine.ensureCurrentBuildFinish()
-            if ((await engine.getBundleState()).lastBuildErrored) {
-                throw new Error('The initial WX bundled-development build failed.')
-            }
-            await this.callbacks.waitForInitialBundle()
-        }
-    }
-
-    private handlePayload(payload: unknown): void {
-        if (typeof payload !== 'object' || payload === null) return
-        const candidate = payload as { type?: unknown; err?: { message?: unknown } }
-        if (candidate.type === 'error' && typeof candidate.err?.message === 'string') {
-            this.callbacks.onError(candidate.err.message)
-        }
-    }
-}
-
-function toStableModuleId(id: string, root: string): string {
-    const normalizedId = id.replace(/\\/g, '/')
-    if (normalizedId.startsWith('\0') || !path.posix.isAbsolute(normalizedId)) return normalizedId
-    return path.posix.relative(root.replace(/\\/g, '/'), normalizedId)
-}
-
-function getFirstOutput(options: WxRolldownOptions): Record<string, unknown> {
-    if (!Array.isArray(options.output)) return options.output as Record<string, unknown>
-    const output = options.output[0] ?? {}
-    options.output[0] = output
-    return output
-}
-
-/** Adds native direct dependencies whose execution order cannot be represented through the Rolldown graph. */
-function createWxDevelopmentBanner(chunk: { fileName: string }): string {
-    if (chunk.fileName === 'app.js') return `require(${JSON.stringify(`./${wxUpdateControlFile}`)});`
-    if (!chunk.fileName.startsWith('pages/') || !chunk.fileName.endsWith('.js')) return ''
-    const prefix = '../'.repeat(chunk.fileName.split('/').length - 1)
-    return `require(${JSON.stringify(`${prefix}runtime.js`)});require(${JSON.stringify(`${prefix}${wxPagePreloadFile}`)});require(${JSON.stringify(`${prefix}${wxUpdateFile}`)});`
-}

package/src/node/targets/wx/development-files.ts

@@ -1,11 +0,0 @@
-/** Plugin-owned files added only to a WX development output. */
-export const wxDevelopmentDirectory = 'vpt-hmr'
-
-/** App-only metadata containing the local transport URL, token, and build ID. */
-export const wxUpdateControlFile = `${wxDevelopmentDirectory}/control.js`
-
-/** Stable page-component initialization required before replaying retained updates. */
-export const wxPagePreloadFile = `${wxDevelopmentDirectory}/preload.js`
-
-/** The one mutable, literal JavaScript update dependency required by every page. */
-export const wxUpdateFile = `${wxDevelopmentDirectory}/update.js`

package/src/node/targets/wx/plugin.ts

@@ -1,164 +0,0 @@
-import path from 'node:path'
-import type { Plugin, PluginOption, UserConfig } from 'vite'
-import type { BuildContext } from '../../build-context.ts'
-import { normalizeModuleId, stripVirtualPrefix } from '../../utils/modules.ts'
-import { packageRequire } from '../../utils/packages.ts'
-import { emitWxCompanionAssets, type WxBundle } from './companion-assets.ts'
-import { WxDevelopmentSession } from './dev-server/development-session.ts'
-import { transformWxReactRefreshModule } from './react-refresh.ts'
-import { emitWxEntryChunks, isWxVirtualModuleId, loadWxVirtualModule, virtualWxAppId } from './virtual-modules.ts'
-
-const taroWxComponentsPath = packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react')
-const vitePluginTaroSourcePath = normalizeModuleId(path.dirname(packageRequire.resolve('vite-plugin-taro')))
-const taroVersion = String(packageRequire('@tarojs/runtime/package.json').version)
-
-/** Creates the plugins that own the complete WX build and development lifecycle. */
-export function createWxTargetPlugins(context: BuildContext): PluginOption[] {
-    return [createWxTargetPlugin(context)]
-}
-
-function createWxTargetPlugin(context: BuildContext): Plugin {
-    let developmentSession: WxDevelopmentSession | undefined
-
-    return {
-        name: 'vite-plugin-taro:wx',
-
-        resolveId: {
-            order: 'pre',
-            handler(id) {
-                return isWxVirtualModuleId(id) ? `\0${id}` : undefined
-            }
-        },
-
-        load: {
-            order: 'post',
-            handler(id) {
-                const cleanId = stripVirtualPrefix(id)
-
-                emitWxEntryChunks(this, context, cleanId)
-
-                return loadWxVirtualModule(cleanId, context)
-            }
-        },
-
-        transform: {
-            order: 'post',
-            async handler(code, id) {
-                if (!context.development) return
-
-                const transformed = await transformWxReactRefreshModule(code, id, context.project.appComponentFile)
-                return transformed === code ? undefined : transformed
-            }
-        },
-
-        generateBundle: {
-            order: 'post',
-            async handler(_, bundle) {
-                await emitWxCompanionAssets(this, bundle as WxBundle, context)
-            }
-        },
-
-        configureServer: {
-            order: 'post',
-            handler(server) {
-                developmentSession = new WxDevelopmentSession(context, server)
-                developmentSession.install()
-            }
-        },
-
-        closeBundle() {
-            return developmentSession?.close()
-        }
-    }
-}
-
-/** Supplies the complete WX target configuration from the same target owner as its plugin. */
-export function createWxViteConfig(context: BuildContext): UserConfig {
-    return {
-        define: createWxTaroDefines(),
-        experimental: context.development ? { bundledDev: true } : undefined,
-        css: {
-            lightningcss: {
-                visitor: {
-                    // keep CSS3 style single colon :before, :after
-                    // while WeChat Mini Program does not support the double colons versions
-                    Selector(selector) {
-                        return selector.map((component) => {
-                            if (
-                                component.type === 'pseudo-element' &&
-                                (component.kind === 'before' || component.kind === 'after')
-                            ) {
-                                return {
-                                    type: 'pseudo-element' as const,
-                                    kind: 'custom' as const,
-                                    name: component.kind
-                                }
-                            }
-                            return component
-                        })
-                    }
-                }
-            }
-        },
-        resolve: {
-            alias: [{ find: /^@tarojs\/components$/, replacement: taroWxComponentsPath }]
-        },
-        build: {
-            target: 'es2018',
-            assetsInlineLimit: 1024,
-            cssCodeSplit: false,
-            // weapp-tailwindcss has no minifier setting; retain Vite's production CSS minification.
-            cssMinify: context.development ? false : 'lightningcss',
-            minify: !context.development,
-            rolldownOptions: {
-                input: { app: virtualWxAppId },
-                experimental: {
-                    // remove vite virtual module \0 in comments, which causes WeChat DevTools failed to compile
-                    attachDebugInfo: 'none'
-                },
-                output: {
-                    format: 'cjs',
-                    entryFileNames: '[name].js',
-                    assetFileNames: 'assets/[name][extname]',
-                    chunkFileNames: ({ name }) => `${name === 'rolldown-runtime' ? 'runtime' : name}.js`,
-                    strictExecutionOrder: true,
-                    codeSplitting: {
-                        includeDependenciesRecursively: false,
-                        minSize: 0,
-                        groups: [
-                            { name: 'taro', test: isWxTaroChunkModule, priority: 100 },
-                            { name: 'vendors', test: isNodeModule, priority: 10 },
-                            { name: 'common', minShareCount: 2, minModuleSize: 1, priority: 1 }
-                        ]
-                    }
-                }
-            }
-        }
-    }
-}
-
-function createWxTaroDefines(): Record<string, string> {
-    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),
-        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'
-    }
-}
-
-function isWxTaroChunkModule(id: string): boolean {
-    const normalizedId = normalizeModuleId(id)
-    return normalizedId.includes('/node_modules/@tarojs/') || normalizedId.startsWith(`${vitePluginTaroSourcePath}/`)
-}
-
-function isNodeModule(id: string): boolean {
-    return normalizeModuleId(id).includes('/node_modules/')
-}

package/src/node/targets/wx/react-refresh.ts

@@ -1,51 +0,0 @@
-import { transformWithOxc } from 'vite'
-import { normalizeModuleId } from '../../utils/modules.ts'
-
-/** Rewrites Vite's browser-oriented Refresh output for the WX App Service global environment. */
-export async function transformWxReactRefreshModule(
-    code: string,
-    id: string,
-    appComponentFile: string
-): Promise<string> {
-    const appFile = normalizeModuleId(appComponentFile)
-    const instrumented = normalizeModuleId(id) === appFile ? await instrumentWxAppComponent(code, appFile) : code
-    return instrumented
-        .replaceAll('window.$Refresh', 'globalThis.$Refresh')
-        .replaceAll('window.__registerBeforePerformReactRefresh', 'globalThis.__registerBeforePerformReactRefresh')
-        .replaceAll('window.__getReactRefreshIgnoredExports', 'globalThis.__getReactRefreshIgnoredExports')
-        .replace(
-            'export function register(type, id) {',
-            'export function register(type, id) {\n  if (globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?.blockRefreshRegistration) return'
-        )
-        .replace(
-            '\n  performReactRefresh()\n',
-            '\n  globalThis.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?.afterRefresh?.(performReactRefresh())\n'
-        )
-}
-
-/** Creates the virtual preamble that installs React Refresh before the generated WX App entry executes. */
-export function createWxReactRefreshPreambleSource(): string {
-    return `import RefreshRuntime from '/@react-refresh'
-RefreshRuntime.injectIntoGlobalHook(globalThis)
-globalThis.$RefreshReg$ = () => {}
-globalThis.$RefreshSig$ = () => (type) => type
-`
-}
-
-/** Adds Refresh registration to JSX-free App modules that Vite's normal JSX transform would otherwise skip. */
-async function instrumentWxAppComponent(code: string, appFile: string): Promise<string> {
-    const transformed = await transformWithOxc(code, appFile, {
-        lang: 'js',
-        sourcemap: false,
-        jsx: { refresh: true }
-    })
-    return `import {
-    createSignatureFunctionForTransform as __wxCreateRefreshSignature,
-    register as __wxRegisterRefreshType
-} from '/@react-refresh'
-const $RefreshReg$ = (type, id) => __wxRegisterRefreshType(type, ${JSON.stringify(`${appFile} `)} + id)
-const $RefreshSig$ = __wxCreateRefreshSignature
-${transformed.code}
-if (import.meta.hot) import.meta.hot.accept()
-`
-}

package/src/node/targets/wx/virtual-modules.ts

@@ -1,152 +0,0 @@
-/**
- * Defines the generated WX application graph.
- *
- * App, page, and component IDs become native entry chunks. The Refresh preamble is an App bootstrap module, while the
- * page-preload ID deliberately becomes its own development file with a later, page-only execution phase.
- */
-import type { VitePluginTaroPageOption } from '../../../options.ts'
-import type { BuildContext } from '../../build-context.ts'
-import { createPageComponentImportPath, toViteFileImportPath } from '../../utils/modules.ts'
-import { resolvePackageFile } from '../../utils/packages.ts'
-import { wxPagePreloadFile } from './development-files.ts'
-import { createWxReactRefreshPreambleSource } from './react-refresh.ts'
-
-const wxTaroRuntimeImportPath = runtimeImportPath('taro-runtime.js')
-const wxPageUpdateImportPath = runtimeImportPath('page-update.js')
-const wxUpdateClientImportPath = runtimeImportPath('update-client.js')
-
-/** Generated native App entry. */
-export const virtualWxAppId = 'virtual:vite-plugin-taro/wx/app'
-
-/** Generated recursive Taro component entry. */
-const virtualWxComponentId = 'virtual:vite-plugin-taro/wx/component'
-
-/** Prefix for one generated native entry per configured page route. */
-const virtualWxPageIdPrefix = 'virtual:vite-plugin-taro/wx/page/'
-
-/** App bootstrap module that installs React Refresh globals before application modules execute. */
-const virtualWxRefreshPreambleId = 'virtual:vite-plugin-taro/wx/refresh-preamble'
-
-/** Development-only entry that initializes all configured page components before update replay. */
-const virtualWxPagePreloadId = 'virtual:vite-plugin-taro/wx/page-preload'
-
-type WxChunkEmitter = {
-    emitFile(chunk: { type: 'chunk'; id: string; fileName: string; implicitlyLoadedAfterOneOf: string[] }): string
-}
-
-export function isWxVirtualModuleId(id: string): boolean {
-    return (
-        id === virtualWxAppId ||
-        id === virtualWxComponentId ||
-        id === virtualWxRefreshPreambleId ||
-        id === virtualWxPagePreloadId ||
-        id.startsWith(virtualWxPageIdPrefix)
-    )
-}
-
-export function loadWxVirtualModule(id: string, context: BuildContext): string | undefined {
-    if (id === virtualWxRefreshPreambleId) {
-        return createWxReactRefreshPreambleSource()
-    }
-    if (id === virtualWxAppId) {
-        return createWxAppEntrySource(context)
-    }
-    if (id === virtualWxComponentId) {
-        return createWxComponentEntrySource()
-    }
-    if (id === virtualWxPagePreloadId) {
-        return createWxPagePreloadSource(context)
-    }
-
-    if (id.startsWith(virtualWxPageIdPrefix)) {
-        const pagePath = id.slice(virtualWxPageIdPrefix.length)
-
-        const page = context.project.pages.find((candidate) => candidate.path === pagePath)
-        if (page) {
-            return createWxPageEntrySource(page, context)
-        }
-    }
-}
-
-/** Registers every configured page and the shared recursive component as eager WX entry chunks. */
-export function emitWxEntryChunks(emitter: WxChunkEmitter, context: BuildContext, id: string): void {
-    if (id !== virtualWxAppId) return
-
-    for (const page of context.project.pages) {
-        emitter.emitFile({
-            type: 'chunk',
-            id: `${virtualWxPageIdPrefix}${page.path}`,
-            fileName: `${page.path}.js`,
-            implicitlyLoadedAfterOneOf: [id]
-        })
-    }
-
-    emitter.emitFile({
-        type: 'chunk',
-        id: virtualWxComponentId,
-        fileName: 'comp.js',
-        implicitlyLoadedAfterOneOf: [id]
-    })
-
-    if (context.development) {
-        emitter.emitFile({
-            type: 'chunk',
-            id: virtualWxPagePreloadId,
-            fileName: wxPagePreloadFile,
-            implicitlyLoadedAfterOneOf: [id]
-        })
-    }
-}
-
-function createWxAppEntrySource(context: BuildContext): string {
-    const refreshPreamble = context.development ? `import ${JSON.stringify(virtualWxRefreshPreambleId)}\n` : ''
-    const updateClient = context.development
-        ? `import { startWxUpdateClient } from ${JSON.stringify(wxUpdateClientImportPath)}\n`
-        : ''
-    return `${refreshPreamble}${updateClient}import { createReactApp, ReactDOM } from ${JSON.stringify(wxTaroRuntimeImportPath)}
-import React from 'react'
-import AppComponent from ${JSON.stringify(toViteFileImportPath(context.project.appComponentFile))}
-
-const appConfig = ${JSON.stringify(context.project.appConfig)}
-App(createReactApp(AppComponent, React, ReactDOM, appConfig))
-${context.development ? 'startWxUpdateClient()' : ''}
-`
-}
-
-function createWxPageEntrySource(page: VitePluginTaroPageOption, context: BuildContext): string {
-    const hotUpdateImport = context.development
-        ? `import { decorateWxPageConfig, registerWxPage } from ${JSON.stringify(wxPageUpdateImportPath)}\n`
-        : ''
-    const createConfig = `createPageConfig(PageComponent, '${page.path}', { root: { cn: [] } }, pageConfig)`
-    const pageRegistration = context.development
-        ? `registerWxPage(${JSON.stringify(page.path)}, () => Page(taroPageConfig))`
-        : 'Page(taroPageConfig)'
-    return `${hotUpdateImport}import { createPageConfig } from ${JSON.stringify(wxTaroRuntimeImportPath)}
-import PageComponent from ${JSON.stringify(createPageComponentImportPath(page.path))}
-
-const pageConfig = ${JSON.stringify(page.config)}
-const taroPageConfig = ${context.development ? `decorateWxPageConfig(${createConfig})` : createConfig}
-if (PageComponent && PageComponent.behaviors) {
-  taroPageConfig.behaviors = (taroPageConfig.behaviors || []).concat(PageComponent.behaviors)
-}
-${pageRegistration}
-`
-}
-
-function createWxPagePreloadSource(context: BuildContext): string {
-    const imports = context.project.pages.map((page, index) => {
-        return `import Page${index} from ${JSON.stringify(createPageComponentImportPath(page.path))}`
-    })
-    return `${imports.join('\n')}\nvoid [${context.project.pages.map((_, index) => `Page${index}`).join(', ')}]\n`
-}
-
-function runtimeImportPath(fileName: string): string {
-    return toViteFileImportPath(resolvePackageFile('dist/runtime/wx', fileName))
-}
-
-function createWxComponentEntrySource(): string {
-    return `import { createRecursiveComponentConfig } from ${JSON.stringify(wxTaroRuntimeImportPath)}
-
-Component(createRecursiveComponentConfig())
-`
-}

package/src/node/utils/async.ts

@@ -1,19 +0,0 @@
-/** Generic asynchronous coordination helpers for Node-side plugin services. */
-export class SerializedTaskQueue {
-    private readonly reportError: (error: unknown) => void
-    private tail = Promise.resolve()
-
-    constructor(reportError: (error: unknown) => void) {
-        this.reportError = reportError
-    }
-
-    enqueue(task: () => Promise<void>): Promise<void> {
-        const work = this.tail.then(task)
-        this.tail = work.catch(this.reportError)
-        return work
-    }
-
-    async waitForIdle(): Promise<void> {
-        await this.tail
-    }
-}

package/src/node/utils/filesystem.ts

@@ -1,45 +0,0 @@
-/** Node-only filesystem helpers shared by build targets and development services. */
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-type FileSource = string | Uint8Array
-type FileWrite = { file: string; source: FileSource }
-
-/** Writes through a sibling temporary file so observers never read partial contents. */
-export async function writeFileAtomically(file: string, source: FileSource): Promise<void> {
-    await fs.mkdir(path.dirname(file), { recursive: true })
-    const temporaryFile = `${file}.tmp`
-    await fs.writeFile(temporaryFile, source)
-    await fs.rename(temporaryFile, file)
-}
-
-export async function writeFilesAtomically(files: FileWrite[]): Promise<void> {
-    await Promise.all(files.map(({ file, source }) => writeFileAtomically(file, source)))
-}
-
-/** Copies a directory when present and treats a missing optional source as empty. */
-export async function copyDirectoryIfExists(source: string, destination: string): Promise<void> {
-    if (!source) return
-    try {
-        await fs.cp(source, destination, { recursive: true, force: true })
-    } catch (error) {
-        if (!isMissingFileError(error)) throw error
-    }
-}
-
-/** Mirrors one optional file: copy existing files, ignore directories, and remove a missing source's destination. */
-export async function copyFileOrRemove(source: string, destination: string): Promise<void> {
-    try {
-        const stat = await fs.stat(source)
-        if (stat.isDirectory()) return
-        await fs.mkdir(path.dirname(destination), { recursive: true })
-        await fs.copyFile(source, destination)
-    } catch (error) {
-        if (!isMissingFileError(error)) throw error
-        await fs.rm(destination, { recursive: true, force: true })
-    }
-}
-
-function isMissingFileError(error: unknown): error is NodeJS.ErrnoException {
-    return error instanceof Error && 'code' in error && error.code === 'ENOENT'
-}

package/src/runtime/taro/api.ts

@@ -1,13 +0,0 @@
-/** Physical runtime module backing the public `virtual:taro/api` facade. */
-// Ensure Taro's React runtime registers its `initNativeApi` hook before @tarojs/taro is initialized.
-import '@tarojs/plugin-framework-react/dist/runtime'
-import { hooks } from '@tarojs/runtime'
-import Taro from '@tarojs/taro'
-
-if (hooks.isExist('initNativeApi')) {
-    hooks.call('initNativeApi', Taro)
-}
-
-// @ts-expect-error @tarojs/taro declares export= types, but vite-plugin-taro target aliases expose runtime named exports.
-export * from '@tarojs/taro'
-export default Taro

package/src/runtime/taro/components.ts

@@ -1,2 +0,0 @@
-/** Physical runtime module backing the public `virtual:taro/components` facade. */
-export * from '@tarojs/components'