vite-plugin-taro 0.5.16 → 0.6.1

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

@@ -2,9 +2,10 @@ import path from 'node:path'
 import { types } from '@babel/core'
 import type { Rolldown } from 'vite'
 import { type AstTransformResult, replaceWithAst } from '../../../utils/transform.ts'
+import { toLogicalChunkId } from '../chunk-path.ts'
 import { getWxExecutionKind } from '../module.ts'
 
-const transportPlaceholder = '__VITE_PLUGIN_TARO_TRANSPORT__'
+const transportPlaceholder = '__VPT_TRANSPORT__'
 const moduleIdParameter = 'moduleId'
 const exportBindingParameter = 'exportBinding'
 
@@ -14,8 +15,11 @@ type TransportedChunk = {
 }
 
 /**
- * Materializes transport while Rolldown's preliminary hash placeholders are still active, so every injected physical
- * reference participates in final hash calculation instead of changing code after its filename has been fixed.
+ * Materializes transport while Rolldown's preliminary hash placeholders are still active. Each switch case deliberately has
+ * two IDs: the package-neutral preliminary filename without its `assets/` directory becomes the SystemJS registration
+ * identity, while the LTHP-selected assets/package-qualified filename becomes the literal native require path. Rolldown
+ * substitutes both hashes after this transform, so the
+ * generated transport code and its own content hash describe the exact files that `generateBundle` later materializes.
  *
  * This intentionally creates broad hash invalidation: changing one capsule can rename transport, then bootstrap, then
  * chunks that import bootstrap. A Mini Program ships one application package rather than independently cached HTTP
@@ -26,14 +30,18 @@ export async function materializeTransport({
     transportChunk,
     chunks,
     getLoadMode,
+    getPhysicalChunkId = (chunk) => chunk.fileName,
     sourcemap = true
 }: {
     code: string
     transportChunk: Rolldown.RenderedChunk
     chunks: Readonly<Record<string, Rolldown.RenderedChunk>>
     getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async'
+    getPhysicalChunkId?: (chunk: Rolldown.RenderedChunk) => string
     sourcemap?: boolean
 }): Promise<AstTransformResult> {
+    const physicalTransportId = getPhysicalChunkId(transportChunk)
+
     // Babel constructs and safely serializes an expression shaped like:
     // (moduleId) => {
     //     switch (moduleId) {
@@ -48,13 +56,19 @@ export async function materializeTransport({
         .sort((left, right) => left.chunk.fileName.localeCompare(right.chunk.fileName))
         .map(({ chunk, kind }) => {
             const loadMode = getLoadMode(chunk)
+
+            const logicalChunkId = toLogicalChunkId(chunk.fileName)
+            // Only native loading crosses the logical/physical boundary and receives the assets/package-qualified path.
+            const physicalChunkId = getPhysicalChunkId(chunk)
+
             if (kind === 'amphibious' && loadMode !== 'sync') {
                 throw new Error(`Amphibious wx module must be in the main package: ${chunk.fileName}`)
             }
 
             return createTransportCase({
-                chunkId: chunk.fileName,
-                transportFileName: transportChunk.fileName,
+                chunkId: logicalChunkId,
+                transportFileName: physicalTransportId,
+                physicalChunkId: physicalChunkId,
                 loadMode,
                 kind
             })
@@ -92,19 +106,21 @@ function getTransportedChunks(chunks: Readonly<Record<string, Rolldown.RenderedC
     return transportedChunks
 }
 
-/** Creates one canonical-ID switch case while keeping its native require argument literal. */
+/** Creates one logical-ID switch case while keeping its physical native require argument literal. */
 function createTransportCase({
     chunkId,
     transportFileName,
     loadMode,
-    kind
+    kind,
+    physicalChunkId
 }: {
     chunkId: string
     transportFileName: string
     loadMode: 'sync' | 'async'
+    physicalChunkId: string
     kind: 'capsule' | 'amphibious'
 }): ReturnType<typeof types.switchCase> {
-    const requirePath = toNativeRequirePath(transportFileName, chunkId)
+    const requirePath = toNativeRequirePath(transportFileName, physicalChunkId)
 
     const requireCallee =
         loadMode === 'sync'

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

@@ -1,5 +1,5 @@
 import { normalizePath } from 'vite'
-import type { VitePluginTaroOptions, VitePluginTaroPageOption } from '../../../../options.ts'
+import type { VptOptions, VptPageOption } from '../../../../options.ts'
 import { normalizeModuleId, resolveAppComponentPath, resolvePageComponentPath } from '../../../utils/modules.ts'
 import { createAppConfig } from '../../../utils/project-config.ts'
 import { appComponentId } from '../../client/constant.ts'
@@ -25,7 +25,7 @@ import { specializePageCapsule } from './specialize-page-capsule.ts'
 type PrivateIdResolver = (importer: string | undefined, projectRoot: string) => string
 
 /** Creates the resolver and source specializer for the wx module graph. */
-export function createResolver(options: VitePluginTaroOptions) {
+export function createResolver(options: VptOptions) {
     const normalizedBootstrapPath = normalizePath(bootstrapPath)
     const normalizedPageCapsulePath = normalizePath(pageCapsulePath)
 
@@ -87,7 +87,7 @@ export function createResolver(options: VitePluginTaroOptions) {
 }
 
 /** Declares output entries and the ordered application subset that can own user styles. */
-function createEntryGraph(pages: readonly VitePluginTaroPageOption[]) {
+function createEntryGraph(pages: readonly VptPageOption[]) {
     const pageEntries = pages.map((page) => {
         return {
             capsuleId: createRouteModuleId({ moduleId: pageCapsulePath, pagePath: page.path }),
@@ -128,8 +128,8 @@ function requireConfiguredPage({
     pageByPath
 }: {
     moduleId: string | undefined
-    pageByPath: ReadonlyMap<string, VitePluginTaroPageOption>
-}): VitePluginTaroPageOption {
+    pageByPath: ReadonlyMap<string, VptPageOption>
+}): VptPageOption {
     const queryIndex = moduleId?.indexOf('?') ?? -1
     const pagePath = queryIndex === -1 ? undefined : new URLSearchParams(moduleId?.slice(queryIndex + 1)).get('route')
     const page = pagePath ? pageByPath.get(pagePath) : undefined

package/src/node/plugins/wx/resolve/specialize-bootstrap.ts

@@ -1,8 +1,8 @@
 import { types } from '@babel/core'
-import type { JsonObject } from '../../../../options.ts'
+import type { VptJsonObject } from '../../../../options.ts'
 import { type AstTransformResult, replaceWithAst } from '../../../utils/transform.ts'
 
-const appConfigPlaceholder = '__VITE_PLUGIN_TARO_APP_CONFIG__'
+const appConfigPlaceholder = '__VPT_APP_CONFIG__'
 
 /** Specializes the amphibious bootstrap with the shared App configuration. */
 export function specializeBootstrap({
@@ -13,7 +13,7 @@ export function specializeBootstrap({
 }: {
     code: string
     id: string
-    appConfig: JsonObject
+    appConfig: VptJsonObject
     sourcemap?: boolean
 }): Promise<AstTransformResult> {
     return replaceWithAst(

package/src/node/plugins/wx/resolve/specialize-page-capsule.ts

@@ -1,9 +1,9 @@
 import { types } from '@babel/core'
-import type { VitePluginTaroPageOption } from '../../../../options.ts'
+import type { VptPageOption } from '../../../../options.ts'
 import { type AstTransformResult, replaceWithAst } from '../../../utils/transform.ts'
 
-const pagePathPlaceholder = '__VITE_PLUGIN_TARO_PAGE_PATH__'
-const pageConfigPlaceholder = '__VITE_PLUGIN_TARO_PAGE_CONFIG__'
+const pagePathPlaceholder = '__VPT_PAGE_PATH__'
+const pageConfigPlaceholder = '__VPT_PAGE_CONFIG__'
 
 /** Specializes the Page capsule for one configured route. */
 export function specializePageCapsule({
@@ -14,7 +14,7 @@ export function specializePageCapsule({
 }: {
     code: string
     id: string
-    page: VitePluginTaroPageOption
+    page: VptPageOption
     sourcemap?: boolean
 }): Promise<AstTransformResult> {
     return replaceWithAst(

package/src/node/utils/modules.ts

@@ -11,14 +11,6 @@ type PageComponentPathOptions = {
     projectRoot: string
 }
 
-/** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
-export function resolveChunkReference(importerChunkId: string, reference: string): string {
-    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)
-}
-
 /** Resolves the source file for the configured App component. */
 export function resolveAppComponentPath({ appPath, projectRoot }: AppComponentPathOptions): string {
     return path.resolve(projectRoot, appPath)

package/src/node/utils/project-config.ts

@@ -1,7 +1,7 @@
-import type { JsonObject, VitePluginTaroOptions } from '../../options.ts'
+import type { VptJsonObject, VptOptions } from '../../options.ts'
 
 /** Creates shared App configuration with configured Page order as the authoritative value. */
-export function createAppConfig(options: VitePluginTaroOptions): JsonObject {
+export function createAppConfig(options: VptOptions): VptJsonObject {
     const { subPackages: _subPackages, subpackages: _subpackages, ...appJson } = options.appJson
     return {
         ...appJson,

package/src/node/{vite-plugin.ts → vpt.ts}

@@ -1,13 +1,13 @@
 import react from '@vitejs/plugin-react'
 import type { PluginOption } from 'vite'
-import type { VitePluginTaroOptions } from '../options.ts'
+import type { VptOptions } from '../options.ts'
 import { createClientTaroPlugin } from './plugins/client/client-taro.ts'
 import { createConditionalDirectivePlugin } from './plugins/conditional/conditional-directives.ts'
 import { createH5TargetPlugins } from './plugins/h5/plugins.ts'
 import { createWxTargetPlugins } from './plugins/wx/plugins.ts'
 
 /** Creates the Vite plugins for one Taro target. */
-export default function vitePluginTaro(options: VitePluginTaroOptions): PluginOption[] {
+export default function vpt(options: VptOptions): PluginOption[] {
     return [
         createConditionalDirectivePlugin(options.target),
         createClientTaroPlugin(options.target),

package/src/options.ts

@@ -1,24 +1,82 @@
 /** A JSON object used by generated target configs. */
-export type JsonObject = Record<string, unknown>
+export type VptJsonObject = Record<string, unknown>
 
 /** Build target handled by this plugin. */
-export type VitePluginTaroTarget = 'wx' | 'h5'
+export type VptTarget = 'wx' | 'h5'
 
 /** Configures one Taro page. */
-export type VitePluginTaroPageOption = {
-    /** Taro route and output path without a file extension. */
+export type VptPageOption = {
+    /**
+     * Taro route and output path without a file extension.
+     *
+     * The plugin resolves the page component from `src/${path}.tsx`, relative to the Vite project root. For example,
+     * `pages/home/index` resolves to `src/pages/home/index.tsx` and is emitted under `pages/home/index` for `wx`.
+     */
     path: string
 
-    config: JsonObject
+    /**
+     * Target-independent Taro page configuration.
+     *
+     * For `wx`, these values form the generated `<path>.json`; the plugin augments `usingComponents` with its generated
+     * component registrations. For `h5`, the values are added to the corresponding Taro router entry.
+     */
+    config: VptJsonObject
 }
 
-/** Configures the Vite Taro plugin. */
-export interface VitePluginTaroOptions {
-    target: VitePluginTaroTarget
+/** Configures vpt for one build target. */
+export interface VptOptions {
+    /**
+     * Platform produced by the current Vite invocation.
+     *
+     * Use `wx` to emit a WeChat Mini Program or `h5` to emit a browser application. The selected target controls Taro
+     * module resolution, conditional compilation, runtime bootstrapping, style processing, and output generation.
+     */
+    target: VptTarget
+
+    /**
+     * Source module that default-exports the root React application component.
+     *
+     * Relative paths are resolved from Vite's project root, for example `src/app.tsx`. The component wraps the active
+     * page through its `children` prop and is the appropriate place to import application-wide styles.
+     */
     app: string
-    pages: VitePluginTaroPageOption[]
-    appJson: JsonObject
-    projectConfigJson: JsonObject
-    projectPrivateConfigJson?: JsonObject
-    sitemapJson: JsonObject
+
+    /**
+     * Complete ordered list of application pages.
+     *
+     * The declared order becomes the `pages` order in the generated `app.json`, the H5 route order, and the Page order
+     * in the application style cascade. Each Page source is resolved according to its `path`.
+     */
+    pages: VptPageOption[]
+
+    /**
+     * Target-independent Taro application configuration.
+     *
+     * For `wx`, these values form the generated `app.json`. For `h5`, they configure the Taro application and router.
+     * The plugin always derives `pages` from {@link pages}; caller-provided `pages`, `subPackages`, and `subpackages`
+     * values are discarded because the build pipeline owns page order and generated package placement.
+     */
+    appJson: VptJsonObject
+
+    /**
+     * WeChat DevTools project configuration written to `project.config.json` without merging.
+     *
+     * This option is required so one configuration shape can be shared between targets, but it is only emitted for a
+     * `wx` build and is ignored for `h5`.
+     */
+    projectConfigJson: VptJsonObject
+
+    /**
+     * Local WeChat DevTools overrides written to `project.private.config.json` without merging.
+     *
+     * The file is emitted only when this value is provided for a `wx` build. It is ignored for `h5`.
+     */
+    projectPrivateConfigJson?: VptJsonObject
+
+    /**
+     * WeChat Mini Program indexing rules written to `sitemap.json` without merging.
+     *
+     * The file is emitted only when this value is provided for a `wx` build. It is ignored for `h5`.
+     */
+    sitemapJson?: VptJsonObject
 }

package/src/runtime/h5/app.ts

@@ -8,16 +8,16 @@ import ReactDOM from 'react-dom/client'
 // @ts-expect-error: The H5 build resolves this private App component.
 import AppComponent from '\0vpt:app-component'
 
-declare const __VITE_PLUGIN_TARO_H5_APP_CONFIG__: SpaRouterConfig
-declare const __VITE_PLUGIN_TARO_H5_ROUTES__: Route[]
+declare const __VPT_H5_APP_CONFIG__: SpaRouterConfig
+declare const __VPT_H5_ROUTES__: Route[]
 
 const browserWindow = window as unknown as Window &
     typeof window & {
         __taroAppConfig: SpaRouterConfig
     }
-const config = __VITE_PLUGIN_TARO_H5_APP_CONFIG__
+const config = __VPT_H5_APP_CONFIG__
 browserWindow.__taroAppConfig = config
-config.routes = __VITE_PLUGIN_TARO_H5_ROUTES__
+config.routes = __VPT_H5_ROUTES__
 const app = createReactApp(AppComponent, React, ReactDOM, config)
 const history = createHashHistory({ window: browserWindow })
 handleAppMount(config, history)

package/src/runtime/wx/amphibious/bootstrap.ts

@@ -2,10 +2,10 @@
 import '../systemjs/system-core.js'
 import { transport } from './transport.ts'
 
-declare const __VITE_PLUGIN_TARO_APP_CONFIG__: Record<string, unknown>
+declare const __VPT_APP_CONFIG__: Record<string, unknown>
 
 /** Shares one App configuration object between the specialized bootstrap and App capsule. */
-export const appConfig = __VITE_PLUGIN_TARO_APP_CONFIG__
+export const appConfig = __VPT_APP_CONFIG__
 
 // WX has no modulepreload transport. Genuine application import() boundaries retain System.import() and may load
 // asynchronous subpackage or top-level-await graphs through this identity wrapper.

package/src/runtime/wx/amphibious/transport.ts

@@ -2,9 +2,7 @@
 // amphibious boundary that publishes native namespaces to SystemJS without re-evaluating their module bodies.
 
 /** Materialized from the preliminary output graph before Rolldown finalizes content hashes. */
-declare const __VITE_PLUGIN_TARO_TRANSPORT__: (
-    moduleId: string
-) => System.Registration | PromiseLike<System.Registration>
+declare const __VPT_TRANSPORT__: (moduleId: string) => System.Registration | PromiseLike<System.Registration>
 
 /** Dispatches to one generated literal require and bridges amphibious CommonJS namespaces inline. */
-export const transport = __VITE_PLUGIN_TARO_TRANSPORT__
+export const transport = __VPT_TRANSPORT__

package/src/runtime/wx/capsule/page.ts

@@ -5,14 +5,9 @@ import './app.ts'
 import PageComponent from '\0vpt:page-component'
 import { createPageConfig } from './taro-runtime.ts'
 
-declare const __VITE_PLUGIN_TARO_PAGE_PATH__: string
-declare const __VITE_PLUGIN_TARO_PAGE_CONFIG__: Record<string, unknown>
+declare const __VPT_PAGE_PATH__: string
+declare const __VPT_PAGE_CONFIG__: Record<string, unknown>
 
-const config = createPageConfig(
-    PageComponent,
-    __VITE_PLUGIN_TARO_PAGE_PATH__,
-    { root: { cn: [] } },
-    __VITE_PLUGIN_TARO_PAGE_CONFIG__
-)
+const config = createPageConfig(PageComponent, __VPT_PAGE_PATH__, { root: { cn: [] } }, __VPT_PAGE_CONFIG__)
 
 export default config

package/src/vite.ts

@@ -1,2 +1,2 @@
-export { default } from './node/vite-plugin.ts'
-export type { VitePluginTaroOptions, VitePluginTaroPageOption, VitePluginTaroTarget } from './options.ts'
+export { default } from './node/vpt.ts'
+export type { VptJsonObject, VptOptions, VptPageOption, VptTarget } from './options.ts'

package/dist/node/plugins/wx/placement/placer.d.ts

@@ -1,78 +0,0 @@
-import type { Rolldown } from 'vite';
-import { type ModuleGraph } from './plan.ts';
-/** Native app.json declaration for one generated code-only subpackage. */
-export type GeneratedSubpackage = {
-    /** Stable native alias derived from the generated root hash. */
-    name: string;
-    /** Physical directory containing this subpackage's emitted capsules. */
-    root: string;
-    /** Marks this as a code-only subpackage with no native Page routes. */
-    pages: readonly [];
-};
-/**
- * Creates the stateful adapter between graph planning and Rolldown's output lifecycle:
- *
- * - renderStart analyzes transformed modules before chunking.
- * - codeSplitting prevents modules assigned to different packages from being merged.
- * - filename callbacks materialize planned subpackage roots.
- * - renderChunk derives native loading mode from those physical paths.
- * - generateBundle reconciles the plan with chunks that survived tree shaking.
- */
-export declare function createPlacer(): {
-    /** Assigns every transformed module to main or one generated, size-bounded subpackage. */
-    analyze(graph: ModuleGraph): void;
-    /**
-     * Complete Rolldown fragment required to preserve package placement and native entry semantics.
-     *
-     * ```text
-     * native App/Page/Component shell entry
-     *   └─ static import / runtime importSync() ─▶ explicit capsule entry + static closure [main, no TLA]
-     *                                                └─ System.import() ─▶ lazy-a [package A, TLA allowed]
-     *                                                                      └─ static import ─▶ lazy-b [package B]
-     *
-     * name()                              assigns lazy-a and lazy-b to their planned package groups
-     * includeDependenciesRecursively      false: does not pull lazy-b back into package A
-     * preserveEntrySignatures             allows cross-chunk bindings without weakening native entry exports
-     *
-     * package A capsule
-     *   └─ SystemJS dependency ─▶ package B capsule
-     *                                ▲
-     *                                └─ main transport obtains registration with require.async()
-     * ```
-     *
-     * Explicit entries preserve the shell/capsule rendering boundary while their static edge executes synchronously
-     * from main. Once a dynamic boundary is crossed, physical fetches may be asynchronous and modules may use
-     * top-level await. SystemJS still links that complete static lazy graph before execution, even across packages.
-     */
-    rolldownOptions: {
-        output: {
-            /**
-             * Gives every generated subpackage a distinct Rolldown chunk group. Recursive dependency capture must
-             * stay disabled: lazy static dependencies may belong to other subpackages and SystemJS links them
-             * asynchronously.
-             */
-            codeSplitting: {
-                groups: {
-                    name(moduleId: string): string | null;
-                    includeDependenciesRecursively: boolean;
-                }[];
-            };
-            /** Preserves exact native shell paths while hashing transport and explicit capsule entries. */
-            entryFileNames(chunk: Rolldown.PreRenderedChunk): string;
-            /** Converts the planned owner into its physical main or generated subpackage filename template. */
-            chunkFileNames(chunk: Rolldown.PreRenderedChunk): string;
-            assetFileNames: string;
-        };
-        preserveEntrySignatures: 'allow-extension';
-    };
-    /**
-     * Selects loading mode from physical output rather than graph intent. Transport executes in main, so main files
-     * use require() and every generated subpackage file uses require.async().
-     */
-    getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
-    /**
-     * Reconciles planned ownership with final chunks through module IDs. Tree-shaken subpackages disappear naturally,
-     * while roots are deduplicated and sorted before becoming deterministic app.json declarations.
-     */
-    getSubpackages(bundle: Rolldown.OutputBundle): GeneratedSubpackage[];
-};

package/dist/node/plugins/wx/placement/placer.js

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