vite-plugin-taro 0.6.18 → 0.6.19

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

@@ -1,164 +0,0 @@
-import { normalizePath, transformWithOxc } from 'vite';
-import { esTarget } from '../../../utils/constant.js';
-import { memoize } from '../../../utils/memoize.js';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { pageShellPath, rolldownRuntimeId } from '../module/module.js';
-import { createWxDevHost } from './dev-host.js';
-import { developmentAppWxssFileName } from './hmr-files.js';
-import { createWxReactRefreshTransforms } from './react-refresh.js';
-/** Selects the sole Vite environment that owns the physical Mini Program development project. */
-export function isWxClientEnvironment(environment) {
-    return environment.name === 'client';
-}
-/**
- * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
- * Page HMR activation, and React Refresh adaptation transforms.
- *
- * The shared style pipeline already owns the resolver's ordered App/Page cascade policy, so the host does not reconstruct it
- * from unrelated Rolldown shell and transport entries.
- */
-export function createWxDevelopmentPlugin(options, styles) {
-    /*
-     * Vite creates this plugin descriptor before a server or DevEngine exists, then invokes configureServer and closeBundle on
-     * different lifecycle stacks. This mutable handle transfers the one client-owned host between those hooks: configureServer
-     * assigns it after asynchronous construction, and closeBundle reads it to drain the same engine. Environment scoping ensures
-     * only the client hook pair participates. Capturing a construction Promise would start too early, while recreating the host
-     * in closeBundle would lose every live action, patch, style, and client frontier owned by the running instance.
-     */
-    let host = null;
-    // Portable hook filters stay broad; these exact identities exclude similarly named user modules.
-    const normalizedPageShellPath = normalizePath(pageShellPath);
-    return [
-        {
-            name: 'vpt:wx-dev',
-            apply: 'serve',
-            // The physical WX DevEngine is a client build. Native environment scoping gives its shared host exactly one
-            // generate/close lifecycle instead of admitting hooks from Vite's unrelated SSR environment.
-            applyToEnvironment: isWxClientEnvironment,
-            config() {
-                return {
-                    build: {
-                        // The development output is the live Mini Program project opened by WeChat DevTools, not a disposable
-                        // build artifact. Deleting and recreating its directory tree during a dev-server restart disrupts
-                        // DevTools' hot-reload watcher; recreating the same paths does not reliably attach that watcher again.
-                        // The host then continues writing hmr/patches.js, but DevTools no longer observes it and therefore never
-                        // re-executes the Page shell that consumes and acknowledges the patches. Keep the watched paths present
-                        // across host restarts and let the initial complete build overwrite active outputs. This plugin applies
-                        // only to `serve`; production builds retain Vite's normal output cleanup.
-                        emptyOutDir: false,
-                        // Disable maps in resolved environment config as well as final output so Oxc and Babel skip producing
-                        // intermediate maps that Rolldown would discard.
-                        sourcemap: false
-                    },
-                    experimental: {
-                        // Ask Vite to resolve its bundled-development graph and expose the private adapter instance. The wx
-                        // configureServer hook replaces only its startup method with the directly writing DevEngine.
-                        bundledDev: true
-                    }
-                };
-            },
-            configureServer: {
-                // Install after Vite and user plugins have finished configuring the environment, but before server.listen()
-                // asks bundledDev to create its hard-coded skip-write DevEngine.
-                order: 'post',
-                async handler(server) {
-                    host = await createWxDevHost({
-                        server: server,
-                        options: options,
-                        styles: styles
-                    });
-                }
-            },
-            generateBundle: {
-                order: 'post',
-                handler(_, bundle) {
-                    // `vpt:wx` emits the production App wrapper during every complete build: initial startup and each
-                    // recovery build, not just once when this plugin instance is created. Development transfers that file
-                    // to the host so its only physical write happens after the matching build identity is durable.
-                    removeDevelopmentAppWxss(bundle);
-                }
-            },
-            closeBundle() {
-                return host?.close();
-            }
-        },
-        {
-            name: 'vpt:wx-runtime-lowering',
-            apply: 'serve',
-            transform: {
-                order: 'post',
-                // The dev-mode transform assembles the runtime chunk (Rolldown's base runtime
-                // plus our injected implement) as this module's transform output, which
-                // bypasses the build's es2018 lowering. Real-device engines and WeChat's
-                // upload parser predate class fields and nullish operators, so the assembled
-                // runtime is lowered here — the only module that needs it. The exact id
-                // filter needs no code scan; the id must stay in sync with rolldownRuntimeId
-                // in module.ts (kept as a regex for the Rolldown-side filter).
-                filter: { id: /^\0rolldown\/runtime\.js(?:\?|$)/ },
-                handler(code) {
-                    // The `setPublicClassFields` assumption emits plain `this.x = ...`
-                    // assignments instead of external helpers, whose references the later
-                    // minifier would mangle.
-                    return fixRolldownRuntime(code);
-                }
-            }
-        },
-        {
-            name: 'vpt:wx-page-shell-hmr',
-            apply: 'serve',
-            transform: {
-                order: 'post',
-                filter: { id: /\/runtime\/wx\/native\/page\.js(?:\?|$)/ },
-                handler(code, id) {
-                    if (normalizeModuleId(id) !== normalizedPageShellPath)
-                        return;
-                    return injectPageShellHmr(code);
-                }
-            }
-        },
-        ...createWxReactRefreshTransforms()
-    ];
-}
-/**
- * Transfers development ownership of `app.wxss` from complete output to the dev host.
- *
- * The ordinary WX output hook emits the static production wrapper during every complete build. In development, the existing
- * physical wrapper instead contains the previous build ID. If the static asset remained in this bundle, the DevEngine would:
- *
- * 1. replace the versioned wrapper with static production bytes while JavaScript and HMR metadata are still being finalized;
- * 2. let DevTools observe that root-style change and reload the App against the previous build identity;
- * 3. let the host replace the wrapper again with the new build ID, causing a second App reload.
- *
- * Deleting only the in-memory bundle entry avoids both premature writes. Development sets `emptyOutDir: false`, so the prior
- * physical `app.wxss` remains available while the complete output is written. The host replaces it exactly once after
- * `hmr/patches.js` and `hmr/info.js` are durable. Incremental HMR never enters this complete-output hook and continues changing
- * only `assets/global.wxss`, which preserves the App heap. The serve-only plugin leaves production output unchanged.
- */
-export function removeDevelopmentAppWxss(bundle) {
-    delete bundle[developmentAppWxssFileName];
-}
-/** Injects the retained snapshot at the exact native Page registration edge. */
-export function injectPageShellHmr(code) {
-    const registration = 'Page(pageConfig)';
-    if (!code.includes(registration)) {
-        throw new Error('WX native Page shell must register pageConfig');
-    }
-    return {
-        code: code.replace(registration, 'Page(__rolldown_runtime__.injectPageHmr(pageConfig))'),
-        map: null
-    };
-}
-/*
- * memoize owns a mutable one-entry-by-input cache. The assembled runtime source is byte-identical across complete generations
- * because both the Rolldown base and injected implementation are immutable for the server lifetime. Reusing its lowered result
- * avoids repeating the only large Oxc transform on every rebuild; keying by source still invalidates correctly if a future Vite
- * generation changes the runtime, unlike a module-global cached string detached from its actual input.
- */
-const fixRolldownRuntime = memoize((code) => {
-    return transformWithOxc(code, rolldownRuntimeId, {
-        lang: 'js',
-        target: esTarget,
-        sourcemap: false,
-        assumptions: { setPublicClassFields: true }
-    });
-});

package/dist/node/plugins/wx/dev/react-refresh.js

@@ -1,231 +0,0 @@
-import { isReferenceIdentifier } from 'oxc-walker';
-import { memoize } from '../../../utils/memoize.js';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { transformWithOxcWalker } from '../../../utils/oxc-transform.js';
-import { reactReconcilerRoot } from '../module/module.js';
-/** The React DevTools hook protocol name; free references must target `global` in wx. */
-const reactDevtoolsHookProtocol = '__REACT_DEVTOOLS_GLOBAL_HOOK__';
-/**
- * Refresh protocol globals that must live on the WeChat `global` object:
- * - `__registerBeforePerformReactRefresh` is assigned at module evaluation so the HMR client can register work that
- *   must finish before a refresh. Leaving it on `window` throws before the refresh runtime can initialize.
- * - `__getReactRefreshIgnoredExports` is an optional extension point read while validating a refresh boundary.
- *   Leaving that read on the nonexistent `window` crashes every update validation pass.
- *
- * Keeping this list explicit prevents the adapter from rewriting unrelated browser accesses if the refresh runtime
- * gains new code. Any future React Refresh protocol addition therefore requires a deliberate compatibility decision.
- */
-const refreshRuntimeWindowGlobals = ['__registerBeforePerformReactRefresh', '__getReactRefreshIgnoredExports'];
-/**
- * Creates the serve-only React Refresh adaptation transforms for the wx target.
- *
- * @vitejs/plugin-react's generated refresh code assumes the web HTML preamble and a browser
- * global scope; wx has neither. Each transform adapts one piece of that contract:
- * - the refresh runtime module (id-filtered): the runtime reads and assigns
- *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation;
- * - React Reconciler: its renderer injection statically depends on the refresh runtime, fixing cold-start order;
- * - react-family modules (filtered on free references): the DevTools hook is read as a free
- *   variable, which the WeChat runtime scope never resolves against `global` — every free
- *   reference becomes an explicit member access;
- * - boundary modules (filtered on the guard): the preamble's `$RefreshReg$` global is not
- *   needed because the transform generates local wrappers over the imported refresh
- *   runtime, so the guard that checks for the global is removed.
- *
- * Filters route every adaptation directly. The Reconciler intentionally receives the renderer dependency first and the
- * global-hook rewrite second; modules outside these explicit domains never reach a handler.
- */
-export function createWxReactRefreshTransforms() {
-    return [
-        {
-            name: 'vpt:wx-react-refresh-runtime',
-            apply: 'serve',
-            transform: {
-                order: 'post',
-                // The refresh runtime module is id-filtered, so no code scan is needed.
-                filter: { id: /^\/@react-refresh(?:\?|$)/ },
-                handler(code, id) {
-                    return fixRefreshRuntime({ code, id });
-                }
-            }
-        },
-        {
-            name: 'vpt:wx-react-refresh-renderer-dependency',
-            apply: 'serve',
-            transform: {
-                order: 'post',
-                filter: { id: /\/react-reconciler\/cjs\/react-reconciler\.development\.js(?:\?|$)/ },
-                handler(code, id) {
-                    const rendererId = `${reactReconcilerRoot}/cjs/react-reconciler.development.js`;
-                    if (normalizeModuleId(id) !== rendererId)
-                        return;
-                    return injectReactRefreshRendererDependency(code);
-                }
-            }
-        },
-        {
-            name: 'vpt:wx-react-devtools-hook',
-            apply: 'serve',
-            transform: {
-                order: 'post',
-                // Matches only free references (react-family modules). The member accesses in
-                // the refresh runtime and the dev runtime chunk never match, so they need no
-                // id exclusion.
-                filter: { code: /(^|[^.\w$])__REACT_DEVTOOLS_GLOBAL_HOOK__/ },
-                handler(code, id) {
-                    return fixReactDevtoolsHook({ code, id });
-                }
-            }
-        },
-        {
-            name: 'vpt:wx-refresh-preamble-guard',
-            apply: 'serve',
-            transform: {
-                order: 'post',
-                // Vite's documented refresh protocol global; the generated guard is its only
-                // occurrence, in boundary modules.
-                filter: { code: /window\.\$RefreshReg\$/ },
-                handler(code, id) {
-                    return removeRefreshPreambleGuard({ code, id });
-                }
-            }
-        }
-    ];
-}
-/**
- * React-family modules: free `__REACT_DEVTOOLS_GLOBAL_HOOK__` reads must target `global`.
- *
- * The renderer checks the hook with `typeof __REACT_DEVTOOLS_GLOBAL_HOOK__` and injects via
- * `hook.inject(...)` — but in the WeChat runtime, free-variable reads never resolve against
- * `global`'s properties (verified: the free lookup is undefined while
- * `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` exists). The renderer would therefore silently
- * skip injection, leaving React Refresh with no renderer on which to schedule re-renders.
- *
- * The protocol name is unique, but only reference identifiers are rewritten. Declaration
- * keys and explicit members such as `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` must remain
- * untouched; rewriting those would either produce invalid syntax or double-prefix the hook.
- * The Reconciler's injected static dependency orders hook injection before renderer initialization independently of Rolldown's
- * final chunking decision.
- */
-function createReactDevtoolsHookVisitor(editor) {
-    return function enter(node, parent) {
-        if (node.type !== 'Identifier' ||
-            node.name !== reactDevtoolsHookProtocol ||
-            !isReferenceIdentifier(node, parent)) {
-            return;
-        }
-        // An explicit member access is required because WeChat does not expose properties of
-        // its global object as free lexical bindings. Removing this edit disables renderer
-        // registration even though the hook object itself still exists.
-        editor.overwrite(node.start, node.end, `global.${reactDevtoolsHookProtocol}`);
-    };
-}
-/**
- * Refresh runtime module: self-inject at evaluation and rewrite its browser protocol globals.
- *
- * In web Vite, an HTML preamble calls `injectIntoGlobalHook(window)` before application
- * modules load. wx has no HTML document or preamble, so nothing performs that bootstrap.
- * The call must live in the refresh runtime module itself:
- * - this module's closure owns `helpersByRendererID`, mounted roots, and the update helpers;
- * - the wx dev-runtime chunk cannot call into it because the refresh module is in a later,
- *   lazily loaded chunk and does not exist when the dev-runtime chunk evaluates.
- *
- * Unlike the preamble's `$RefreshReg$` globals, which boundary modules replace with local
- * wrappers, the renderer-hook machinery has no local equivalent. Without this injected call,
- * the runtime never learns about the renderer or mounted roots and updates cannot refresh UI.
- *
- * Appending the call is safe even when React has already registered its renderer: the refresh
- * runtime replays `hook.renderers` during injection, then its patched commit hooks observe all
- * later mounts and remounts. The same module also contains two browser-only `window` protocol
- * accesses; those must point at `global` or evaluation/update validation throws in WeChat.
- */
-function createRefreshRuntimeVisitor(editor) {
-    // The declarations must execute before self-injection, so the call is appended instead of
-    // prepended. Removing it would leave the web preamble's only essential responsibility
-    // unimplemented in wx.
-    editor.append('\ninjectIntoGlobalHook(global);');
-    return function enter(node) {
-        if (node.type === 'MemberExpression' &&
-            !node.computed &&
-            node.object.type === 'Identifier' &&
-            node.object.name === 'window' &&
-            node.property.type === 'Identifier' &&
-            refreshRuntimeWindowGlobals.some((globalName) => globalName === node.property.name)) {
-            // `global` is the shared wx App heap used by the dev runtime and hook injection. Only
-            // replacing the object range preserves the upstream runtime byte-for-byte otherwise
-            // and prevents unrelated `window` expressions from being silently adapted.
-            editor.overwrite(node.object.start, node.object.end, 'global');
-        }
-    };
-}
-/**
- * Removes the web-only `if (!window.$RefreshReg$) throw Error(...)` assertion from boundary modules.
- *
- * The assertion verifies that Vite's HTML preamble installed global registration helpers.
- * wx has no preamble and evaluating `window` itself fails. The assertion is unnecessary here:
- * @vitejs/plugin-react generates local `$RefreshReg$` and `$RefreshSig$` wrappers that delegate
- * directly to the imported refresh runtime. Removing the whole statement therefore removes
- * only an invalid platform check; component registration continues through those local wrappers.
- * If this edit is removed, every transformed refresh boundary crashes before its module body runs.
- */
-function createRefreshPreambleGuardVisitor(editor) {
-    return function enter(node) {
-        if (node.type !== 'IfStatement' ||
-            node.test.type !== 'UnaryExpression' ||
-            node.test.operator !== '!' ||
-            node.test.argument.type !== 'MemberExpression' ||
-            node.test.argument.computed ||
-            node.test.argument.object.type !== 'Identifier' ||
-            node.test.argument.object.name !== 'window' ||
-            node.test.argument.property.type !== 'Identifier' ||
-            node.test.argument.property.name !== '$RefreshReg$') {
-            return;
-        }
-        // Matching the complete AST shape prevents an unrelated `$RefreshReg$` use from being
-        // removed. Skipping descendants is required because their ranges disappear with the
-        // parent and must not receive overlapping MagicString edits.
-        editor.remove(node.start, node.end);
-        this.skip();
-    };
-}
-/** Makes renderer hook injection statically depend on the refresh runtime. */
-export function injectReactRefreshRendererDependency(code) {
-    if (!/\bhook\.inject\(internals\)/.test(code)) {
-        throw new Error('React Reconciler must inject its renderer into the DevTools hook');
-    }
-    return {
-        code: `import '/@react-refresh'\n${code}`,
-        map: null
-    };
-}
-export function transformRefreshRuntime({ code, id }) {
-    return transformWithOxcWalker({
-        code,
-        filename: id,
-        sourcemap: false,
-        createVisitor: createRefreshRuntimeVisitor
-    });
-}
-export function transformReactDevtoolsHook({ code, id }) {
-    return transformWithOxcWalker({
-        code,
-        filename: id,
-        sourcemap: false,
-        createVisitor: createReactDevtoolsHookVisitor
-    });
-}
-export function removeRefreshPreambleGuard({ code, id }) {
-    return transformWithOxcWalker({
-        code,
-        filename: id,
-        sourcemap: false,
-        createVisitor: createRefreshPreambleGuardVisitor
-    });
-}
-/*
- * Each memoized transform owns a mutable cache keyed only by source bytes. The matching runtime/react-family modules are
- * immutable between complete generations, so reparsing them would repeat O(source bytes) Oxc work without observing new state.
- * Source keys still create a fresh result after a dependency upgrade or real module edit, unlike a once-only cache keyed by ID;
- * keeping separate caches prevents identical text in different transform domains from sharing the wrong adaptation.
- */
-const fixRefreshRuntime = memoize(transformRefreshRuntime, { getCacheKey: ({ code }) => code });
-const fixReactDevtoolsHook = memoize(transformReactDevtoolsHook, { getCacheKey: ({ code }) => code });

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

@@ -1,45 +0,0 @@
-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.js

@@ -1,178 +0,0 @@
-import path from 'node:path';
-import { build } from 'rolldown';
-import { viteReporterPlugin } from 'rolldown/experimental';
-import { once } from '../../../utils/once.js';
-import { resolvePackageFile } from '../../../utils/packages.js';
-import { appShellFileName } from '../module/module.js';
-/**
- * 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 }) {
-    /*
-     * 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();
-        const output = ensureSingleOutput(rolldownOptions);
-        const configuredOutput = server.config.build.rolldownOptions.output;
-        if (Array.isArray(configuredOutput)) {
-            throw new Error('wx development supports one configured Rolldown output.');
-        }
-        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. 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, {
-            // Development output is overwritten in place after every complete build. Strip hash placeholders from the
-            // configured asset pattern so old files cannot accumulate and native JSON/WXML references remain stable.
-            assetFileNames: createStableFileNames(configured.assetFileNames, 'assets/[name][extname]'),
-            // Banners create physical CommonJS edges after graph analysis: App initializes the dev runtime and each Page
-            // consumes the stable patch journal without allowing those host-only files into the application chunk graph.
-            banner: createEntryBanner(pageFiles),
-            // Preserve the configured directory/name shape while removing content hashes. Stable chunk paths let DevTools
-            // overwrite executable files and let cumulative HMR patches address one persistent physical module identity.
-            chunkFileNames: createStableFileNames(configured.chunkFileNames, 'assets/[name].js'),
-            // Native entry paths are public Mini Program routes (`app.js`, `pages/.../index.js`); development must never hash
-            // or relocate them because DevTools determines App/Page reload behavior from those exact filenames.
-            entryFileNames: createStableFileNames(configured.entryFileNames, '[name]'),
-            // Keep ESM until the existing WX renderChunk pipeline classifies each final chunk and converts capsules to
-            // System.register data or native/amphibious entries to CommonJS. Choosing CommonJS here would erase that boundary.
-            format: 'es',
-            // Bundled development emits complete physical output repeatedly. Minifying bounds disk transfer and DevTools
-            // compile work; source-level HMR diagnostics still come from Vite/Rolldown before this final output pass.
-            minify: true,
-            // DevTools executes physical WX files and HMR applies module factories rather than browser source maps. Disabling
-            // maps avoids extra output files and prevents Vite's Oxc sourcemap transform from touching generated host code.
-            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 ??= {};
-        const existingDevMode = rolldownOptions.experimental.devMode;
-        rolldownOptions.experimental.devMode = {
-            // Retain unknown user/forward-compatible devMode fields while the three explicit WX invariants below win.
-            ...(typeof existingDevMode === 'object' ? existingDevMode : {}),
-            // Install the WX-adapted self-contained Rolldown runtime. It consumes physical patch journals and reports
-            // acknowledgements/rebuild requests through the host bridge instead of relying on browser globals or sockets.
-            implement: await bundleRuntimeSource(),
-            // Produce a complete output graph on the initial build. Lazy per-request compilation cannot establish the closed
-            // App/Page graph, native companions, style sidecars, and build identity required before any patch is admitted.
-            lazy: false,
-            // Keep Rolldown's common runtime injection because generated application factories call its module registry and
-            // HMR primitives. Skipping it would leave the custom implementation without the runtime surface it extends.
-            skipCommonRuntimeInjection: false
-        };
-        /*
-         * 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; the reporter observes final output
-         * without mutating Vite's retained input list.
-         */
-        rolldownOptions.plugins = [rolldownOptions.plugins, createViteReporter(server)];
-        disableViteOxcSourcemap(rolldownOptions.plugins);
-        return rolldownOptions;
-    };
-}
-/** Returns the configured output after rejecting states unsupported by the physical WX engine. */
-export function requireSingleOutput(rolldownOptions) {
-    if (!rolldownOptions.output || Array.isArray(rolldownOptions.output)) {
-        throw new Error('wx development requires exactly one Rolldown output.');
-    }
-    return rolldownOptions.output;
-}
-/** Creates the one missing output object while rejecting a configured output array. */
-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;
-}
-/**
- * Prepends entry banners after Rolldown's analysis so their native requires remain physical dependencies rather than chunk
- * graph edges. The App initializes the runtime identity, while every Page explicitly applies the watched patch data before its
- * native Page registration.
- */
-function createEntryBanner(pageFiles) {
-    return (chunk) => {
-        if (chunk.name === appShellFileName) {
-            return "__rolldown_runtime__.initialize(require('./hmr/info.js'));\n";
-        }
-        if (pageFiles.has(chunk.name)) {
-            const patchesPath = path.posix.relative(path.posix.dirname(chunk.fileName), 'hmr/patches.js');
-            return `__rolldown_runtime__.applyPatches(require('${patchesPath}'));\n`;
-        }
-        return '';
-    };
-}
-function createStableFileNames(addon, fallback) {
-    if (typeof addon === 'function') {
-        return (value) => toStableFileName(String(addon(value)));
-    }
-    return toStableFileName(typeof addon === 'string' ? addon : fallback);
-}
-function toStableFileName(fileName) {
-    return fileName
-        .replace(/(^|\/)\[hash(?::\d+)?\](?=\.|$)/g, '$1[name]')
-        .replace(/[-_.]\[hash(?::\d+)?\]/g, '')
-        .replace(/\[hash(?::\d+)?\]/g, '[name]');
-}
-function disableViteOxcSourcemap(pluginOption) {
-    if (Array.isArray(pluginOption)) {
-        pluginOption.forEach(disableViteOxcSourcemap);
-        return;
-    }
-    if (!pluginOption || typeof pluginOption !== 'object')
-        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;
-    }
-}
-function createViteReporter(server) {
-    const { build, logger, root } = server.config;
-    return viteReporterPlugin({
-        assetsDir: path.join(build.assetsDir, '/'),
-        chunkLimit: 2000,
-        isLib: Boolean(build.lib),
-        isTty: Boolean(process.stdout.isTTY && !process.env.CI),
-        logInfo: (message) => logger.info(message),
-        reportCompressedSize: false,
-        root,
-        warnLargeChunks: false
-    });
-}
-/*
- * 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({
-        input: resolvePackageFile('dist/runtime/wx/dev/dev-runtime.js'),
-        output: { format: 'iife', minify: true, sourcemap: false },
-        write: false
-    });
-    return result.output[0].code;
-});

package/dist/node/plugins/wx/module/chunk-path.js

@@ -1,18 +0,0 @@
-import path from 'node:path';
-/** Physical directory in which Rolldown writes generated JavaScript chunks inside each native package. */
-export const generatedChunkDirectory = 'assets';
-/** Projects one Rolldown-owned physical candidate path into the package-neutral SystemJS identity. */
-export function toLogicalChunkId(physicalChunkId) {
-    return path.posix.relative(generatedChunkDirectory, physicalChunkId);
-}
-/** Resolves one relative Rolldown-generated import to its preliminary physical chunk path. */
-export function resolvePhysicalChunkReference(importerChunkId, reference) {
-    if (!reference.startsWith('./') && !reference.startsWith('../')) {
-        throw new Error(`Expected a relative chunk reference in ${importerChunkId}: ${reference}`);
-    }
-    return path.posix.join(path.posix.dirname(importerChunkId), reference);
-}
-/** Projects one relative Rolldown-generated import into its package-neutral SystemJS identity. */
-export function resolveLogicalChunkReference(importerChunkId, reference) {
-    return toLogicalChunkId(resolvePhysicalChunkReference(importerChunkId, reference));
-}