vite-plugin-taro 0.5.13 → 0.5.16

package/dist/node/plugins/wx/dev/runtime-reports.js

@@ -0,0 +1,45 @@
+import { buffer, debounceTime, filter, Subject } from 'rxjs';
+/**
+ * Conflates runtime receipts without weakening their build identity or recovery semantics.
+ *
+ * Reports are metadata frontiers rather than executable deltas: for one build, the highest applied sequence subsumes lower and
+ * duplicate acknowledgements. A rebuild does not subsume reports from a different build, because delayed Pages may still POST
+ * after session rotation, but it dominates every acknowledgement for its own build. The host validates each retained build ID
+ * against the physical publisher only when its serialized task executes, preserving rotation order.
+ *
+ * Completing the Subject flushes the active window synchronously so shutdown can include its host task before closing Rolldown.
+ * Reduction is O(reports) time and O(distinct builds) retained space per quiet window.
+ */
+export function createRuntimeReportsStream(settleMilliseconds, scheduler, publish) {
+    /*
+     * This Subject is the sole mutable HTTP admission edge. Requests append reports synchronously and finish their responses;
+     * buffer then owns the short-lived window while debounceTime supplies only its quiet-edge signal. Reports are metadata rather
+     * than executable deltas, so the window may be reduced before entering hostActions. Directly mutating PatchPublisher from the
+     * request stack would race patch writes and build rotation; retaining every raw receipt beyond the window would grow with Page
+     * count and duplicate acknowledgements. Completion flushes the final window during phased shutdown.
+     */
+    const reports = new Subject();
+    reports
+        .pipe(buffer(reports.pipe(debounceTime(settleMilliseconds, scheduler))), filter((window) => window.length > 0))
+        .subscribe((window) => publish(reduceRuntimeReportWindow(window)));
+    return reports;
+}
+export function reduceRuntimeReportWindow(window) {
+    /*
+     * This transaction-local mutable Map is bounded by distinct build IDs in one quiet window. Insertion order preserves causal
+     * build order, while replacing a value conflates only that build's monotonic acknowledgement frontier; rebuild becomes its
+     * terminal value. A single global latest report would let delayed Pages erase another build, and retaining the raw window
+     * would make downstream work proportional to duplicate report volume. The Map is discarded immediately after reduction.
+     */
+    const reportsByBuild = new Map();
+    for (const report of window) {
+        const previous = reportsByBuild.get(report.buildId);
+        if (previous?.kind === 'rebuild') {
+            continue;
+        }
+        if (report.kind === 'rebuild' || previous === undefined || report.seq > previous.seq) {
+            reportsByBuild.set(report.buildId, report);
+        }
+    }
+    return [...reportsByBuild.values()];
+}

package/dist/node/plugins/wx/dev/wx-dev-options.d.ts

@@ -2,7 +2,7 @@ import type { InputOptions, OutputOptions, Plugin } from 'rolldown';
 import { type DevEngine } from 'rolldown/experimental';
 import type { ViteDevServer } from 'vite';
 import type { VitePluginTaroOptions } from '../../../../options.ts';
-export type BundledDevRolldownOptions = InputOptions & {
+type BundledDevRolldownOptions = InputOptions & {
     experimental?: {
         [key: string]: unknown;
         devMode?: boolean | Record<string, unknown>;
@@ -15,12 +15,16 @@ export type BundledDev = {
     listen(): Promise<void>;
     triggerBundleRegenerationIfStale(): Promise<boolean>;
 };
-/** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
+/**
+ * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
+ * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.
+ */
 export declare function installWxDevOptions({ bundledDev, server, options, hostPlugins }: {
     bundledDev: BundledDev;
     server: ViteDevServer;
     options: VitePluginTaroOptions;
     hostPlugins: Plugin[];
-}): Promise<void>;
+}): void;
 /** Returns the configured output after rejecting states unsupported by the physical WX engine. */
 export declare function requireSingleOutput(rolldownOptions: BundledDevRolldownOptions): OutputOptions;
+export {};

package/dist/node/plugins/wx/dev/wx-dev-options.js

@@ -4,20 +4,17 @@ import { viteReporterPlugin } from 'rolldown/experimental';
 import { once } from '../../../utils/once.js';
 import { resolvePackageFile } from '../../../utils/packages.js';
 import { appShellFileName } from '../module.js';
-import { createWxDevMode } from './create-wx-dev-mode.js';
-/** Installs the physical WX output and runtime conventions over Vite's browser-oriented bundled-development options. */
+/**
+ * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
+ * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.
+ */
 export function installWxDevOptions({ bundledDev, server, options, hostPlugins }) {
-    // The buildEnd hook and its one-shot result belong to the same abstraction. Consumers can await startup without receiving
-    // a resolver capable of settling it externally.
-    const initialBuild = Promise.withResolvers();
-    const settleInitialBuild = once((error) => {
-        if (error) {
-            initialBuild.reject(error);
-        }
-        else {
-            initialBuild.resolve();
-        }
-    });
+    /*
+     * Vite owns this mutable adapter method and calls it later when constructing DevEngine. Replacing that one seam preserves
+     * Vite's resolved graph while applying WX physical-output conventions to every options generation. Capturing and mutating one
+     * options object here would be stale on later complete builds; creating a second engine would duplicate watchers and graphs.
+     * The bound original remains immutable and is invoked exactly once per delegated options request.
+     */
     const original = bundledDev.getRolldownOptions.bind(bundledDev);
     bundledDev.getRolldownOptions = async () => {
         const rolldownOptions = await original();
@@ -28,8 +25,15 @@ export function installWxDevOptions({ bundledDev, server, options, hostPlugins }
         }
         const configured = configuredOutput ?? {};
         // Every page entry must depend on hmr/patches.js: DevTools classifies a changed Page dependency as Page JavaScript
-        // hot reload and re-executes live Pages, which is the only physical patch trigger that preserves the App heap.
+        // hot reload and re-executes live Pages, which is the only physical patch trigger that preserves the App heap. Although
+        // Set provides O(1) membership, exposing it as ReadonlySet prevents mutation after this options generation is resolved.
         const pageFiles = new Set(options.pages.map((page) => `${page.path}.js`));
+        /*
+         * Rolldown passes this mutable output object onward by identity, and nested Vite plugins may already retain it. Mutating
+         * that single object preserves their references while atomically replacing browser-oriented naming and format fields with
+         * stable physical WX conventions. Cloning only our fields would leave retained references on stale hashed filenames;
+         * mutating configuredOutput itself would leak development normalization back into the user's resolved Vite config.
+         */
         Object.assign(output, configured, {
             assetFileNames: createStableFileNames(configured.assetFileNames, 'assets/[name][extname]'),
             banner: createEntryBanner(pageFiles),
@@ -39,24 +43,27 @@ export function installWxDevOptions({ bundledDev, server, options, hostPlugins }
             minify: true,
             sourcemap: false
         });
+        /*
+         * experimental belongs to this transaction-local Rolldown options generation. Materialize it only when absent, then
+         * replace devMode with a new object so user fields survive without mutating a possibly shared configured sub-object.
+         */
         rolldownOptions.experimental ??= {};
-        rolldownOptions.experimental.devMode = createWxDevMode(rolldownOptions.experimental.devMode, await bundleRuntimeSource());
-        const reportInitialBuildPlugin = {
-            name: 'vpt:wx-report-initial-build',
-            buildEnd: settleInitialBuild
+        const existingDevMode = rolldownOptions.experimental.devMode;
+        rolldownOptions.experimental.devMode = {
+            ...(typeof existingDevMode === 'object' ? existingDevMode : {}),
+            implement: await bundleRuntimeSource(),
+            lazy: false,
+            skipCommonRuntimeInjection: false
         };
-        // Preserve the physical paths watched by WeChat DevTools across host restarts; the complete build overwrites every
-        // active output without disrupting the hot-reload watcher.
-        rolldownOptions.plugins = [
-            rolldownOptions.plugins,
-            hostPlugins,
-            reportInitialBuildPlugin,
-            createViteReporter(server)
-        ];
+        /*
+         * The plugin list is mutable configuration consumed once by this engine generation. Replace the top-level reference with
+         * an ordered composite rather than pushing into Vite's potentially shared nested array: existing transforms run first,
+         * host capture observes their final values, and the reporter observes final output without mutating either input list.
+         */
+        rolldownOptions.plugins = [rolldownOptions.plugins, hostPlugins, createViteReporter(server)];
         disableViteOxcSourcemap(rolldownOptions.plugins);
         return rolldownOptions;
     };
-    return initialBuild.promise;
 }
 /** Returns the configured output after rejecting states unsupported by the physical WX engine. */
 export function requireSingleOutput(rolldownOptions) {
@@ -70,6 +77,7 @@ function ensureSingleOutput(rolldownOptions) {
     if (Array.isArray(rolldownOptions.output)) {
         throw new Error('wx development requires one configured Rolldown output.');
     }
+    // Rolldown needs the created object attached to input options by identity; returning a detached fallback would be ignored.
     rolldownOptions.output ??= {};
     return rolldownOptions.output;
 }
@@ -112,6 +120,11 @@ function disableViteOxcSourcemap(pluginOption) {
         return;
     const plugin = pluginOption;
     if (plugin.name === 'builtin:vite-transform' && plugin._options?.transformOptions) {
+        /*
+         * Vite's private builtin retains this mutable transform options object and does not expose a public replacement hook.
+         * Updating its one sourcemap flag prevents Oxc from allocating maps that final WX output always discards; cloning the
+         * descriptor would not update the builtin closure that reads the original object during transforms.
+         */
         plugin._options.transformOptions.sourcemap = false;
     }
 }
@@ -128,7 +141,12 @@ function createViteReporter(server) {
         warnLargeChunks: false
     });
 }
-// The runtime source is immutable for the host's lifetime, so the nested bundle is shared by every complete build.
+/*
+ * once owns a mutable cached Promise, justified because getRolldownOptions may run for multiple complete generations while the
+ * runtime input and build options remain immutable for the process lifetime. Sharing the in-flight/result Promise prevents
+ * concurrent options requests from launching duplicate nested builds; caching source instead of a Rolldown output object avoids
+ * leaking mutable bundle metadata between engines.
+ */
 const bundleRuntimeSource = once(async function bundleRuntimeSource() {
     // write: false keeps this nested helper build from creating a second dist directory in the application project.
     const result = await build({

package/dist/node/plugins/wx/module.d.ts

@@ -1,4 +1,4 @@
-import type { Rolldown } from 'vite';
+import { type Rolldown } from 'vite';
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
 /** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */

package/dist/node/plugins/wx/module.js

@@ -1,10 +1,11 @@
 import path from 'node:path';
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../utils/modules.js';
 import { packageRequire, resolvePackageFile } from '../../utils/packages.js';
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export const rolldownRuntimeId = '\0rolldown/runtime.js';
 /** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */
-export const reactReconcilerRoot = normalizeModuleId(path.dirname(packageRequire.resolve('react-reconciler/package.json')));
+export const reactReconcilerRoot = normalizePath(path.dirname(packageRequire.resolve('react-reconciler/package.json')));
 /** Identifies the amphibious bootstrap that initializes SystemJS and serves every native shell. */
 export const bootstrapPath = resolvePackageFile('dist/runtime/wx/amphibious/bootstrap.js');
 /** Identifies the native transport source materialized before Rolldown finalizes content hashes. */

package/dist/node/plugins/wx/native/compile-native-component-interface.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../../utils/modules.js';
 import { collectNativeComponentAssets, nativeComponentMetaKey } from './native-component-assets.js';
 import { transformNativeComponentInterfaces } from './native-component-interface.js';
@@ -10,7 +11,7 @@ export async function compileNativeComponentInterface({ code, id, sourcemap, add
     nativeComponents.forEach((source) => {
         addWatchFile(source.folder);
         source.assets.forEach((asset) => {
-            addWatchFile(normalizeModuleId(path.join(source.folder, asset.relativePath)));
+            addWatchFile(normalizePath(path.join(source.folder, asset.relativePath)));
         });
     });
     const assetBytes = nativeComponents.reduce((sourceTotal, source) => {

package/dist/node/plugins/wx/native/create-native-component-output.js

@@ -26,6 +26,8 @@ export async function createNativeComponentOutput({ bundle, getModuleInfo }) {
                     fields: source.fields
                 });
                 for (const asset of source.assets) {
+                    // Native folders are intentionally opaque to Rolldown, so no bundle asset contains these bytes to reuse.
+                    // Read each planned source once here to transfer it into the compiler-owned output bundle.
                     files.push({
                         type: 'asset',
                         fileName: path.posix.join(outputFolder, asset.relativePath),

package/dist/node/plugins/wx/native/native-component-assets.d.ts

@@ -1,4 +1,4 @@
-import type { Rolldown } from 'vite';
+import { type Rolldown } from 'vite';
 import type { NativeComponentDefinition } from './native-component-interface.ts';
 type NativeComponentAsset = {
     relativePath: string;

package/dist/node/plugins/wx/native/native-component-assets.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { normalizeModuleId } from '../../../utils/modules.js';
+import { normalizePath } from 'vite';
 export const nativeComponentMetaKey = 'vpt:native-components';
 /** Reads the native contribution to a transformed module's package weight. */
 export function getNativeComponentAssetBytes(meta) {
@@ -16,7 +16,7 @@ export async function collectNativeComponentAssets(definition, interfacePath) {
     await requireNativeComponentEntry(definition);
     // This mutable accumulator is local to one traversal and avoids repeatedly copying growing asset arrays.
     const assets = [];
-    await collectDirectory(definition.folder, [], assets, normalizeModuleId(interfacePath));
+    await collectDirectory(definition.folder, [], assets, normalizePath(interfacePath));
     return { ...definition, assets };
 }
 /** Rejects a missing or non-directory source before Rolldown starts its recursive traversal. */
@@ -65,7 +65,7 @@ async function collectDirectory(folder, segments, assets, interfacePath) {
             continue;
         }
         const sourcePath = path.join(folder, ...entrySegments);
-        if (normalizeModuleId(sourcePath) === interfacePath) {
+        if (normalizePath(sourcePath) === interfacePath) {
             continue;
         }
         assets.push({

package/dist/node/plugins/wx/native/native-component-interface.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { RolldownMagicString } from 'rolldown';
 import { parseAst } from 'rolldown/parseAst';
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../../utils/modules.js';
 import { clientTaroNativeId } from '../../client/constant.js';
 /** Replaces native component interface calls with source-folder names and returns their static metadata. */
@@ -96,7 +97,7 @@ function parseDefinition(call, moduleId, declaredInterfaces, buildError) {
     if (!entryReference) {
         throw buildError('Native component entry must use () => import(...) with a static relative .js path');
     }
-    const entryPath = normalizeModuleId(path.resolve(path.dirname(moduleId), entryReference));
+    const entryPath = normalizePath(path.resolve(path.dirname(moduleId), entryReference));
     return {
         folder: path.posix.dirname(entryPath),
         entry: path.posix.basename(entryPath, '.js'),

package/dist/node/plugins/wx/resolve/resolver.js

@@ -1,3 +1,4 @@
+import { normalizePath } from 'vite';
 import { normalizeModuleId, resolveAppComponentPath, resolvePageComponentPath } from '../../../utils/modules.js';
 import { createAppConfig } from '../../../utils/project-config.js';
 import { appComponentId } from '../../client/constant.js';
@@ -6,8 +7,8 @@ import { specializeBootstrap } from './specialize-bootstrap.js';
 import { specializePageCapsule } from './specialize-page-capsule.js';
 /** Creates the resolver and source specializer for the wx module graph. */
 export function createResolver(options) {
-    const normalizedBootstrapPath = normalizeModuleId(bootstrapPath);
-    const normalizedPageCapsulePath = normalizeModuleId(pageCapsulePath);
+    const normalizedBootstrapPath = normalizePath(bootstrapPath);
+    const normalizedPageCapsulePath = normalizePath(pageCapsulePath);
     // Construct output input and application traversal roots together once so style order cannot drift from route order.
     const entryGraph = createEntryGraph(options.pages);
     // Provide constant-time route validation and access to each configured Page JSON object.

package/dist/node/plugins/wx/styles/plugins.js

@@ -42,6 +42,14 @@ export function createWxStylePlugins() {
  * remain opaque.
  */
 function createWxStyleFinalizer(transformStyle) {
+    /*
+     * DevEngine can omit an unchanged stylesheet from later complete output generations. Absence therefore has two meanings:
+     * the first clean output genuinely has no styles, or a later output is reusing the physical stylesheet already on disk.
+     * The Vite server creates a fresh plugin instance on a clean start, so this one lifecycle bit distinguishes those cases and
+     * resets naturally on restart. Deliberately retain no CSS bytes or graph projection here: memory remains O(1), changed CSS
+     * still arrives as a normal asset, and the dev host remains the only owner of incremental style preparation.
+     */
+    let hasFinalizedOutput = false;
     return {
         name: 'vpt:wx-style-finalizer',
         generateBundle: {
@@ -53,7 +61,17 @@ function createWxStyleFinalizer(transformStyle) {
                     throw new Error('WX builds support at most one compiler-emitted stylesheet');
                 }
                 if (styles.length === 0) {
-                    this.emitFile({ type: 'asset', fileName: 'assets/global.wxss', source: '' });
+                    /*
+                     * A clean first output must materialize the stable import target imported by app.wxss. On later complete
+                     * outputs, DevEngine's physical writer preserves files omitted from the bundle; emitting the same empty
+                     * placeholder would instead overwrite valid unchanged WXSS. Emit nothing in that later case. A source or
+                     * configuration change that really removes all styles is already published as empty by ordinary style HMR,
+                     * while a clean server restart reaches this first-output branch and also clears any stale prior file.
+                     */
+                    if (!hasFinalizedOutput) {
+                        this.emitFile({ type: 'asset', fileName: 'assets/global.wxss', source: '' });
+                    }
+                    hasFinalizedOutput = true;
                     return;
                 }
                 const [style] = styles;
@@ -63,6 +81,7 @@ function createWxStyleFinalizer(transformStyle) {
                 // intact. Only its finalized contents and stable WXSS identity change.
                 style.source = transformedResult.css;
                 style.fileName = 'assets/global.wxss';
+                hasFinalizedOutput = true;
             }
         }
     };

package/dist/node/utils/modules.d.ts

@@ -14,7 +14,7 @@ export declare function resolveAppComponentPath({ appPath, projectRoot }: AppCom
 export declare function resolvePageComponentPath({ pagePath, projectRoot }: PageComponentPathOptions): string;
 /** Creates a portable import for one configured Page component. */
 export declare function createPageComponentImportPath(options: PageComponentPathOptions): string;
-/** Normalizes a file-backed Vite module ID for stable comparisons. */
+/** Converts a file-backed Vite request ID to its normalized physical path for stable comparisons. */
 export declare function normalizeModuleId(id: string): string;
 /** Converts a local file path into Vite's portable file-system import form. */
 export declare function toViteFileImportPath(filePath: string): string;

package/dist/node/utils/modules.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { normalizePath } from 'vite';
 /** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
 export function resolveChunkReference(importerChunkId, reference) {
     if (!reference.startsWith('./') && !reference.startsWith('../')) {
@@ -18,11 +19,11 @@ export function resolvePageComponentPath({ pagePath, projectRoot }) {
 export function createPageComponentImportPath(options) {
     return toViteFileImportPath(resolvePageComponentPath(options));
 }
-/** Normalizes a file-backed Vite module ID for stable comparisons. */
+/** Converts a file-backed Vite request ID to its normalized physical path for stable comparisons. */
 export function normalizeModuleId(id) {
-    return id.replaceAll('\\', '/').replace(/\?.*$/, '');
+    return normalizePath(id.replace(/\?.*$/, ''));
 }
 /** Converts a local file path into Vite's portable file-system import form. */
 export function toViteFileImportPath(filePath) {
-    return `/@fs/${normalizeModuleId(path.resolve(filePath))}`;
+    return `/@fs/${normalizePath(path.resolve(filePath))}`;
 }

package/dist/node/utils/packages.js

@@ -1,9 +1,9 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { normalizeModuleId } from './modules.js';
+import { normalizePath } from 'vite';
 export const packageRequire = createRequire(import.meta.url);
 const packageRoot = path.dirname(packageRequire.resolve('vite-plugin-taro/package.json'));
 /** Resolves a file shipped by this package as a portable Vite module ID. */
 export function resolvePackageFile(...segments) {
-    return normalizeModuleId(path.join(packageRoot, ...segments));
+    return normalizePath(path.join(packageRoot, ...segments));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.5.13",
+  "version": "0.5.16",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat Mini Program and H5 targets.",
   "type": "module",
@@ -73,10 +73,11 @@
     "react-reconciler": "0.33.0",
     "react-refresh": "^0.18.0",
     "rolldown": "1.2.3",
+    "rxjs": "^7.8.2",
     "tailwindcss": "^4.3.3",
     "weapp-tailwindcss": "^5.2.11",
-    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.5.13",
-    "@tarojs/react": "npm:vite-plugin-taro-react@0.5.13"
+    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.5.16",
+    "@tarojs/react": "npm:vite-plugin-taro-react@0.5.16"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/node/plugins/client/client-taro.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite'
+import { normalizePath, type Plugin } from 'vite'
 import type { VitePluginTaroTarget } from '../../../options.ts'
 import { normalizeModuleId } from '../../utils/modules.ts'
 import { resolvePackageFile } from '../../utils/packages.ts'
@@ -21,7 +21,7 @@ import { injectTaroFrameworkApis } from './inject-taro-framework-apis.ts'
 export const clientTaroApiId = 'virtual:taro/api'
 
 const clientTaroApiPath = resolvePackageFile('dist/runtime/client/taro/api.js')
-const normalizedClientTaroApiPath = normalizeModuleId(clientTaroApiPath)
+const normalizedClientTaroApiPath = normalizePath(clientTaroApiPath)
 
 const clientTaroComponentId = 'virtual:taro/components'
 

package/src/node/plugins/h5/create-stencil-client-adapter.ts

@@ -1,6 +1,6 @@
 import type { WalkerEnter } from 'oxc-walker'
 import type { RolldownMagicString } from 'rolldown'
-import type { Plugin } from 'vite'
+import { normalizePath, type Plugin } from 'vite'
 import { normalizeModuleId } from '../../utils/modules.ts'
 import { transformWithOxcWalker } from '../../utils/oxc-transform.ts'
 import { packageRequire } from '../../utils/packages.ts'
@@ -8,7 +8,7 @@ import { packageRequire } from '../../utils/packages.ts'
 const stencilClientPath = packageRequire.resolve('@stencil/core/internal/client', {
     paths: [packageRequire.resolve('@tarojs/components/package.json')]
 })
-const normalizedStencilClientPath = normalizeModuleId(stencilClientPath)
+const normalizedStencilClientPath = normalizePath(stencilClientPath)
 
 /**
  * Creates the compiler-owned adaptation of Stencil's client style insertion.

package/src/node/plugins/h5/resolver/module-resolver.ts

@@ -1,3 +1,4 @@
+import { normalizePath } from 'vite'
 import type { VitePluginTaroOptions } from '../../../../options.ts'
 import { normalizeModuleId, resolveAppComponentPath } from '../../../utils/modules.ts'
 import { appComponentId } from '../../client/constant.ts'
@@ -24,7 +25,7 @@ export function createModuleResolver(options: VitePluginTaroOptions) {
             projectRoot: string
             sourcemap?: boolean
         }) {
-            if (normalizeModuleId(id) === normalizeModuleId(h5AppPath)) {
+            if (normalizeModuleId(id) === normalizePath(h5AppPath)) {
                 return transformH5App({ code, id, options, projectRoot, sourcemap })
             }
         }

package/src/node/plugins/wx/dev/create-hmr-results-stream.ts

@@ -0,0 +1,71 @@
+import type { DevOptions } from 'rolldown/experimental'
+import { buffer, debounceTime, filter, type SchedulerLike, Subject } from 'rxjs'
+
+type HmrUpdatesResult = Parameters<NonNullable<DevOptions['onHmrUpdates']>>[0]
+type HmrUpdates = Exclude<HmrUpdatesResult, Error>
+
+/**
+ * Adapts Rolldown's non-awaited HMR callback into lossless quiet-window publications.
+ *
+ * Debouncing the result stream itself would retain only the final callback and lose incremental patch factories that later
+ * patches provably do not reproduce. Instead, the debounced view is only a closing notifier for `buffer`: every callback is
+ * retained in arrival order, and one configured quiet period emits the complete window to the host's existing serialized
+ * writer. This first stream migration deliberately does not own physical state; `publish` and `reportError` remain synchronous
+ * admission callbacks so the dev host can enqueue both through its single writer.
+ *
+ * DevEngine failures are values, not Observable errors. They represent transient editor generations and carry no executable
+ * patch, so the stream reports the final error but otherwise removes them. Successful callbacks on either side remain ordered
+ * and lossless; Rolldown generated each against its unpublished client frontier, and the host delivers every retained payload.
+ * Completing the returned Subject flushes its current buffer synchronously, allowing host shutdown to await the resulting
+ * serialized task rather than silently dropping an admitted patch.
+ *
+ * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until the quiet edge.
+ */
+export function createHmrResultsStream(
+    settleMilliseconds: number,
+    scheduler: SchedulerLike,
+    publish: (result: HmrUpdates) => void,
+    reportError: (error: Error) => void
+): Subject<HmrUpdatesResult> {
+    /*
+     * This hot Subject is the sole mutable boundary between Rolldown's non-awaited callback and RxJS. Each next preserves one
+     * compiler generation by reference and in arrival order. buffer owns the temporary lossless window; debounceTime observes the
+     * same Subject only to decide when that window closes. Replacing this with a debounced scalar would discard patch factories,
+     * while letting callback Promises mutate host state directly would overlap publications. Completion flushes the final window
+     * before shutdown, after which the Subject is never reused.
+     */
+    const results = new Subject<HmrUpdatesResult>()
+
+    results
+        .pipe(
+            buffer(results.pipe(debounceTime(settleMilliseconds, scheduler))),
+            filter((window) => window.length > 0)
+        )
+        .subscribe((window) => {
+            /*
+             * An Error is one source generation that produced no executable delta; it does not invalidate successful Rolldown
+             * callbacks already admitted on either side of it. Dropping the whole quiet window would therefore discard real
+             * patch factories, while starting a complete build would compile the same known-invalid editor contents. Keep the
+             * old runtime running, report only the latest diagnostic from a repeated parser burst, and continue below with the
+             * successful callback values exactly as if the temporary invalid save had never produced an HMR payload.
+             */
+            const lastFailure = window.findLast((result): result is Error => result instanceof Error)
+            if (lastFailure) {
+                reportError(lastFailure)
+            }
+            const successfulWindow = window.filter((result): result is HmrUpdates => !(result instanceof Error))
+            if (successfulWindow.length > 0) {
+                /*
+                 * flatMap preserves callback arrival order and each callback's internal Rolldown order. Updates must not be
+                 * deduplicated: later undelivered patches are deltas and do not reproduce factories from earlier sequences.
+                 * changedFiles is opaque DevEngine metadata and has no identity semantics in the host, so preserving its raw
+                 * concatenation is both cheaper and more faithful than maintaining a second Set-based interpretation here.
+                 */
+                publish({
+                    updates: successfulWindow.flatMap((result) => result.updates),
+                    changedFiles: successfulWindow.flatMap((result) => result.changedFiles)
+                })
+            }
+        })
+    return results
+}