vite-plugin-taro 0.3.2 → 0.4.1

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

@@ -0,0 +1,46 @@
+import type { Rolldown } from 'vite';
+/** Identifies one generated code-only subpackage by its physical output root. */
+export type SubpackageLocation = {
+    /** Discriminates generated subpackages from main. */
+    kind: 'subpackage';
+    /** Native subpackage root relative to the Mini Program output directory. */
+    root: string;
+};
+/** Physical package ownership for one transformed module. */
+export type PackageLocation = {
+    kind: 'main';
+} | SubpackageLocation;
+/** Immutable module-to-package ownership produced before Rolldown creates chunks. */
+export type PlacementPlan = ReadonlyMap<string, PackageLocation>;
+/** Minimal Rolldown graph interface consumed by the subpackage planner. */
+export type ModuleGraph = {
+    /** Every transformed module known after graph construction. */
+    moduleIds: Iterable<string>;
+    /** Reads static edges, dynamic edges, transformed code, and entry ownership. */
+    getModuleInfo(moduleId: string): Rolldown.ModuleInfo | null;
+    /** Adds non-JavaScript output owned by a transformed module to its package weight. */
+    getAdditionalModuleBytes?: (info: Rolldown.ModuleInfo) => number;
+};
+/** Shared main-package value used for every eager or output-generated module. */
+export declare const mainPackage: {
+    readonly kind: 'main';
+};
+/**
+ * Creates one deterministic subpackage placement plan:
+ *
+ * 1. Snapshot Rolldown's transformed module graph.
+ * 2. Reserve every explicit shell and capsule entry together with its static closure in main.
+ * 3. Treat dynamic imports as asynchronous roots, then annotate their modules with affinity.
+ * 4. Pack those lazy modules independently under the planning budget.
+ * 5. Return only module ownership; chunks and native manifests are reconciled later.
+ *
+ * Static cycles are deliberately not atomic only after a genuine nested dynamic boundary. System.import() may obtain their
+ * registrations from several packages and await top-level execution while preserving the original static ESM graph.
+ */
+export declare function createPlacementPlan({ moduleIds, getModuleInfo, getAdditionalModuleBytes, planningBudgetBytes }: ModuleGraph & {
+    planningBudgetBytes?: number;
+}): PlacementPlan;
+/** Uses the generated root directory itself as the native subpackage alias. */
+export declare function getSubpackageName(root: string): string;
+/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
+export declare function isGeneratedSubpackageFile(fileName: string): boolean;

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

@@ -0,0 +1,210 @@
+import { createHash } from 'node:crypto';
+// Leave headroom below WeChat's 2M subpackage limit for capsule wrappers and bundler-generated code.
+const subpackagePlanningBudget = 1_900_000;
+const generatedSubpackageRootPrefix = 'sub/p_';
+/** Shared main-package value used for every eager or output-generated module. */
+export const mainPackage = { kind: 'main' };
+/**
+ * Creates one deterministic subpackage placement plan:
+ *
+ * 1. Snapshot Rolldown's transformed module graph.
+ * 2. Reserve every explicit shell and capsule entry together with its static closure in main.
+ * 3. Treat dynamic imports as asynchronous roots, then annotate their modules with affinity.
+ * 4. Pack those lazy modules independently under the planning budget.
+ * 5. Return only module ownership; chunks and native manifests are reconciled later.
+ *
+ * Static cycles are deliberately not atomic only after a genuine nested dynamic boundary. System.import() may obtain their
+ * registrations from several packages and await top-level execution while preserving the original static ESM graph.
+ */
+export function createPlacementPlan({ moduleIds, getModuleInfo, getAdditionalModuleBytes, planningBudgetBytes = subpackagePlanningBudget }) {
+    // Materialize the iterable once because every later phase needs stable random access by module ID.
+    const infos = new Map();
+    for (const moduleId of moduleIds) {
+        const info = getModuleInfo(moduleId);
+        if (info) {
+            infos.set(moduleId, info);
+        }
+    }
+    // Eager ownership is a hard constraint; consumer and neighbor sets below are soft packing preferences only.
+    const eagerModules = findEagerModules(infos);
+    const consumersByModule = findLazyConsumers({ infos, eagerModules });
+    const neighborsByModule = findLazyNeighbors({ infos, eagerModules });
+    const placeableModules = [...infos.entries()]
+        .filter(([moduleId]) => !eagerModules.has(moduleId))
+        .map(([moduleId, info]) => ({
+        moduleId,
+        estimatedBytes: Buffer.byteLength(info.code ?? '', 'utf8') + (getAdditionalModuleBytes?.(info) ?? 0),
+        consumers: consumersByModule.get(moduleId) ?? new Set([moduleId]),
+        neighbors: neighborsByModule.get(moduleId) ?? new Set()
+    }));
+    // Packing operates at module granularity, so a large lazy closure or cycle may span several subpackages.
+    const subpackages = packSubpackages({ modules: placeableModules, planningBudgetBytes }).map(createPackedSubpackage);
+    const locationByModule = new Map();
+    for (const moduleId of eagerModules) {
+        locationByModule.set(moduleId, mainPackage);
+    }
+    for (const subpackage of subpackages) {
+        for (const moduleId of subpackage.moduleIds) {
+            locationByModule.set(moduleId, subpackage);
+        }
+    }
+    return locationByModule;
+}
+/**
+ * Finds modules that must remain in main. Native shells and capsules are explicit entries, and static traversal keeps their
+ * complete eager closures synchronous. Every dynamic import is therefore a genuine lazy boundary whose graph may use
+ * subpackages and top-level await.
+ */
+function findEagerModules(infos) {
+    const eagerModules = new Set();
+    const pending = [...infos.values()].filter((info) => info.isEntry).map((info) => info.id);
+    while (pending.length > 0) {
+        const moduleId = pending.pop();
+        if (!moduleId || eagerModules.has(moduleId)) {
+            continue;
+        }
+        const info = infos.get(moduleId);
+        if (!info) {
+            continue;
+        }
+        eagerModules.add(moduleId);
+        pending.push(...info.importedIds);
+    }
+    return eagerModules;
+}
+/**
+ * Records demand after the eager importSync closure has been removed. Every remaining dynamic target starts one lazy root
+ * traversal; that traversal follows static edges only and stops before another dynamic boundary. A shared module records
+ * every root that can request it. These consumer sets improve co-location but never prevent subpackage splitting.
+ */
+function findLazyConsumers({ infos, eagerModules }) {
+    const dynamicRoots = new Set();
+    for (const info of infos.values()) {
+        for (const importedId of info.dynamicallyImportedIds) {
+            if (infos.has(importedId) && !eagerModules.has(importedId)) {
+                dynamicRoots.add(importedId);
+            }
+        }
+    }
+    const consumersByModule = new Map();
+    for (const dynamicRoot of [...dynamicRoots].sort()) {
+        const visited = new Set();
+        const pending = [dynamicRoot];
+        while (pending.length > 0) {
+            const moduleId = pending.pop();
+            if (!moduleId || visited.has(moduleId) || eagerModules.has(moduleId)) {
+                continue;
+            }
+            const info = infos.get(moduleId);
+            if (!info) {
+                continue;
+            }
+            visited.add(moduleId);
+            const consumers = consumersByModule.get(moduleId) ?? new Set();
+            consumers.add(dynamicRoot);
+            consumersByModule.set(moduleId, consumers);
+            pending.push(...info.importedIds);
+        }
+    }
+    return consumersByModule;
+}
+/**
+ * Converts each lazy static edge into an undirected affinity. Direction is irrelevant for co-location scoring, while the
+ * original directed dependency remains in Rolldown and later in SystemJS. Cycles are therefore preferences, not atoms.
+ */
+function findLazyNeighbors({ infos, eagerModules }) {
+    const neighborsByModule = new Map();
+    for (const [moduleId, info] of infos) {
+        if (eagerModules.has(moduleId)) {
+            continue;
+        }
+        for (const importedId of info.importedIds) {
+            if (!infos.has(importedId) || eagerModules.has(importedId)) {
+                continue;
+            }
+            addNeighbor(neighborsByModule, moduleId, importedId);
+            addNeighbor(neighborsByModule, importedId, moduleId);
+        }
+    }
+    return neighborsByModule;
+}
+/** Adds one side of an undirected lazy-module affinity edge. */
+function addNeighbor(neighborsByModule, moduleId, neighborId) {
+    const neighbors = neighborsByModule.get(moduleId) ?? new Set();
+    neighbors.add(neighborId);
+    neighborsByModule.set(moduleId, neighbors);
+}
+/**
+ * Packs lazy modules with deterministic best-fit decreasing:
+ *
+ * 1. Visit larger transformed modules first, with module ID as the stable tie-breaker.
+ * 2. Consider only existing bins that stay within the planning budget.
+ * 3. Prefer the bin with the least remaining space, minimizing subpackage count in the usual best-fit heuristic.
+ * 4. When remaining space ties, prefer shared dynamic consumers and then static neighbors.
+ * 5. Create a new bin when no existing bin fits; an individually oversized module receives its own bin.
+ */
+function packSubpackages({ modules, planningBudgetBytes }) {
+    const bins = [];
+    const sortedModules = [...modules].sort((left, right) => {
+        return right.estimatedBytes - left.estimatedBytes || left.moduleId.localeCompare(right.moduleId);
+    });
+    for (const module of sortedModules) {
+        const candidate = bins
+            .filter((bin) => bin.estimatedBytes + module.estimatedBytes <= planningBudgetBytes)
+            .map((bin) => ({
+            bin,
+            remainingBytes: planningBudgetBytes - bin.estimatedBytes - module.estimatedBytes,
+            affinity: getAffinity(bin, module)
+        }))
+            .sort((left, right) => {
+            return left.remainingBytes - right.remainingBytes || right.affinity - left.affinity;
+        })[0]?.bin;
+        const bin = candidate ?? {
+            moduleIds: [],
+            estimatedBytes: 0,
+            consumers: new Set()
+        };
+        if (!candidate) {
+            bins.push(bin);
+        }
+        bin.moduleIds.push(module.moduleId);
+        bin.estimatedBytes += module.estimatedBytes;
+        for (const consumer of module.consumers) {
+            bin.consumers.add(consumer);
+        }
+    }
+    return bins;
+}
+/** Scores dynamic-root overlap above direct static adjacency when equally full bins compete. */
+function getAffinity(bin, module) {
+    let affinity = 0;
+    for (const consumer of module.consumers) {
+        if (bin.consumers.has(consumer)) {
+            affinity += 2;
+        }
+    }
+    for (const neighbor of module.neighbors) {
+        if (bin.moduleIds.includes(neighbor)) {
+            affinity += 1;
+        }
+    }
+    return affinity;
+}
+/** Freezes bin membership and derives a stable subpackage root from sorted module IDs. */
+function createPackedSubpackage(bin) {
+    const moduleIds = [...bin.moduleIds].sort();
+    const hash = createHash('sha256').update(moduleIds.join('\0')).digest('hex').slice(0, 8);
+    return {
+        kind: 'subpackage',
+        root: `${generatedSubpackageRootPrefix}${hash}`,
+        moduleIds
+    };
+}
+/** Uses the generated root directory itself as the native subpackage alias. */
+export function getSubpackageName(root) {
+    return root.slice(root.lastIndexOf('/') + 1);
+}
+/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
+export function isGeneratedSubpackageFile(fileName) {
+    return fileName.startsWith(generatedSubpackageRootPrefix);
+}

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

@@ -0,0 +1,4 @@
+import type { PluginOption } from 'vite';
+import type { VitePluginTaroOptions } from '../../../options.ts';
+/** Creates the complete plugin set for the wx target. */
+export declare function createWxTargetPlugins(options: VitePluginTaroOptions): PluginOption[];

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

@@ -0,0 +1,137 @@
+import { esTarget } from '../../utils/constant.js';
+import { packageRequire } from '../../utils/packages.js';
+import { clientTaroNativeId } from '../client/constant.js';
+import { createWxDevelopmentPlugin } from './dev/plugin.js';
+import { getWxExecutionKind, isTransportModule } from './module.js';
+import { compileNativeComponentInterface } from './native/compile-native-component-interface.js';
+import { getNativeComponentAssetBytes } from './native/native-component-assets.js';
+import { createOutputFiles } from './output/files.js';
+import { createPlacer } from './placement/placer.js';
+import { renderCapsule } from './render/capsule.js';
+import { renderNative } from './render/native.js';
+import { materializeTransport } from './render/transport.js';
+import { createResolver } from './resolve/resolver.js';
+/** Creates the complete plugin set for the wx target. */
+export function createWxTargetPlugins(options) {
+    return [createWxPlugin(options), createWxDevelopmentPlugin(options)];
+}
+/** Configures the complete wx target build pipeline. */
+function createWxPlugin(options) {
+    const resolver = createResolver(options);
+    const placer = createPlacer();
+    return {
+        name: 'vpt:wx',
+        config(_config, _env) {
+            return {
+                define: createTaroDefines(),
+                appType: 'custom',
+                oxc: { target: esTarget },
+                resolve: {
+                    alias: [
+                        {
+                            find: /^@tarojs\/components$/,
+                            replacement: packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react')
+                        }
+                    ]
+                },
+                build: {
+                    modulePreload: false,
+                    cssCodeSplit: false,
+                    // Let weapp-tailwindcss own final WXSS transformation.
+                    cssMinify: false,
+                    // No base64 assets: Taro warns on image srcs above ~2KB, and inlined
+                    // images bloat the JS bundle toward the mini program package limit.
+                    assetsInlineLimit: 0,
+                    target: esTarget,
+                    rolldownOptions: {
+                        ...placer.rolldownOptions,
+                        input: resolver.input
+                    }
+                }
+            };
+        },
+        resolveId(id, importer) {
+            return resolver.resolveId(id, importer, this.environment.config.root);
+        },
+        transform: {
+            order: 'pre',
+            async handler(code, id) {
+                const sourcemap = Boolean(this.environment.config.build.sourcemap);
+                if (code.includes(clientTaroNativeId)) {
+                    return compileNativeComponentInterface({
+                        code,
+                        id,
+                        sourcemap,
+                        addWatchFile: (file) => this.addWatchFile(file)
+                    });
+                }
+                return resolver.specialize(code, id, sourcemap);
+            }
+        },
+        renderStart() {
+            placer.analyze({
+                moduleIds: this.getModuleIds(),
+                getModuleInfo: (moduleId) => this.getModuleInfo(moduleId),
+                getAdditionalModuleBytes: (info) => getNativeComponentAssetBytes(info.meta)
+            });
+        },
+        renderChunk: {
+            order: 'post',
+            async handler(code, chunk, outputOptions, meta) {
+                const executionKind = getWxExecutionKind(chunk);
+                const sourcemap = Boolean(outputOptions.sourcemap);
+                if (executionKind === 'capsule') {
+                    return renderCapsule(code, chunk, sourcemap);
+                }
+                // Native and amphibious modules share the CommonJS renderer. Amphibious transport exposure is a
+                // separate concern materialized from final output paths after the physical transport itself is rendered.
+                const native = renderNative({ code, chunk, chunks: meta.chunks, sourcemap });
+                if (isTransportModule(chunk)) {
+                    return materializeTransport({
+                        code: native.code,
+                        transportChunk: chunk,
+                        chunks: meta.chunks,
+                        getLoadMode: placer.getLoadMode,
+                        sourcemap
+                    });
+                }
+                return native;
+            }
+        },
+        generateBundle: {
+            order: 'post',
+            async handler(_, bundle) {
+                const subpackages = placer.getSubpackages(bundle);
+                const outputFiles = await createOutputFiles({
+                    bundle,
+                    options,
+                    subpackages,
+                    getModuleInfo: (moduleId) => this.getModuleInfo(moduleId)
+                });
+                outputFiles.forEach((file) => {
+                    this.emitFile(file);
+                });
+            }
+        }
+    };
+}
+/** Creates the build-time constants required by Taro's legacy feature gates. */
+function createTaroDefines() {
+    const taroVersion = String(packageRequire('@tarojs/runtime/package.json').version);
+    return {
+        'process.env.FRAMEWORK': JSON.stringify('react'),
+        'process.env.SUPPORT_TARO_POLYFILL': JSON.stringify('disabled'),
+        'process.env.TARO_ENV': JSON.stringify('weapp'),
+        'process.env.TARO_PLATFORM': JSON.stringify('mini'),
+        'process.env.TARO_VERSION': JSON.stringify(taroVersion),
+        // React's development-only Suspense diagnostics call this browser API without guards.
+        'performance.now': 'Date.now',
+        ENABLE_ADJACENT_HTML: 'false',
+        ENABLE_CLONE_NODE: 'false',
+        ENABLE_CONTAINS: 'false',
+        ENABLE_INNER_HTML: 'false',
+        ENABLE_MUTATION_OBSERVER: 'false',
+        ENABLE_SIZE_APIS: 'false',
+        ENABLE_TEMPLATE_CONTENT: 'false'
+    };
+}

package/dist/node/plugins/wx/render/capsule-wrapper.d.ts

@@ -0,0 +1,3 @@
+import { type PluginObject } from '@babel/core';
+/** Wraps System.register as an inert CommonJS capsule tuple with canonical final dependency IDs. */
+export declare function wrapCapsulePlugin(fileName: string): PluginObject;

package/dist/node/plugins/wx/render/capsule-wrapper.js

@@ -0,0 +1,64 @@
+import { types } from '@babel/core';
+import { resolveChunkReference } from '../../../utils/modules.js';
+/** Wraps System.register as an inert CommonJS capsule tuple with canonical final dependency IDs. */
+export function wrapCapsulePlugin(fileName) {
+    return {
+        name: 'vpt:wrap-capsule',
+        visitor: {},
+        post(file) {
+            const program = file.ast.program;
+            const [statement] = program.body;
+            const registration = statement && types.isExpressionStatement(statement) ? statement.expression : undefined;
+            if (program.body.length !== 1 ||
+                !types.isCallExpression(registration) ||
+                !types.isMemberExpression(registration.callee) ||
+                registration.callee.computed ||
+                !types.isIdentifier(registration.callee.object, { name: 'System' }) ||
+                !types.isIdentifier(registration.callee.property, { name: 'register' })) {
+                throw new Error(`Expected one anonymous System.register call in ${fileName}`);
+            }
+            const [dependencies, declaration] = registration.arguments;
+            if (registration.arguments.length !== 2 ||
+                !types.isArrayExpression(dependencies) ||
+                !types.isFunctionExpression(declaration)) {
+                throw new Error(`Expected System.register(dependencies, declaration) in ${fileName}`);
+            }
+            dependencies.elements.forEach((dependency) => {
+                canonicalizeStaticReference(dependency, fileName);
+            });
+            const context = declaration.params[1];
+            if (types.isIdentifier(context)) {
+                file.path.traverse({
+                    CallExpression(callPath) {
+                        const callee = callPath.node.callee;
+                        if (!types.isMemberExpression(callee) ||
+                            callee.computed ||
+                            !types.isIdentifier(callee.object, { name: context.name }) ||
+                            !types.isIdentifier(callee.property, { name: 'import' })) {
+                            return;
+                        }
+                        const [dependency] = callPath.node.arguments;
+                        canonicalizeDynamicReference(dependency, fileName);
+                    }
+                });
+            }
+            program.directives = [];
+            program.body = [
+                types.expressionStatement(types.assignmentExpression('=', types.memberExpression(types.identifier('module'), types.identifier('exports')), types.arrayExpression([dependencies, declaration])))
+            ];
+        }
+    };
+}
+/** Resolves one generated static reference while the final importing chunk filename is known. */
+function canonicalizeStaticReference(reference, fileName) {
+    if (!types.isStringLiteral(reference)) {
+        throw new Error(`Expected a literal System.register dependency in ${fileName}`);
+    }
+    reference.value = resolveChunkReference(fileName, reference.value);
+}
+/** Resolves application literals while preserving runtime-computed IDs injected by the development runtime. */
+function canonicalizeDynamicReference(reference, fileName) {
+    if (types.isStringLiteral(reference) && (reference.value.startsWith('./') || reference.value.startsWith('../'))) {
+        reference.value = resolveChunkReference(fileName, reference.value);
+    }
+}

package/dist/node/plugins/wx/render/capsule.d.ts

@@ -0,0 +1,4 @@
+import type { Rolldown } from 'vite';
+import { type AstTransformResult } from '../../../utils/transform.ts';
+/** Renders one ESM chunk as an inert SystemJS capsule. */
+export declare function renderCapsule(code: string, chunk: Rolldown.RenderedChunk, sourcemap?: boolean): AstTransformResult;

package/dist/node/plugins/wx/render/capsule.js

@@ -0,0 +1,13 @@
+import transformDynamicImport from '@babel/plugin-transform-dynamic-import';
+import transformModulesSystemjs from '@babel/plugin-transform-modules-systemjs';
+import { transformWithBabel } from '../../../utils/transform.js';
+import { wrapCapsulePlugin } from './capsule-wrapper.js';
+/** Renders one ESM chunk as an inert SystemJS capsule. */
+export function renderCapsule(code, chunk, sourcemap = true) {
+    return transformWithBabel(code, chunk.fileName, [
+        transformDynamicImport,
+        // Erase Babel's internal plugin pass type.
+        transformModulesSystemjs,
+        wrapCapsulePlugin(chunk.fileName)
+    ], sourcemap);
+}

package/dist/node/plugins/wx/render/native.d.ts

@@ -0,0 +1,9 @@
+import type { Rolldown } from 'vite';
+import { type AstTransformResult } from '../../../utils/transform.ts';
+/** Renders a native module while activating its statically imported capsules through SystemJS. */
+export declare function renderNative({ code, chunk, chunks, sourcemap }: {
+    code: string;
+    chunk: Rolldown.RenderedChunk;
+    chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    sourcemap: boolean;
+}): AstTransformResult;

package/dist/node/plugins/wx/render/native.js

@@ -0,0 +1,45 @@
+import { types } from '@babel/core';
+import transformModulesCommonjs from '@babel/plugin-transform-modules-commonjs';
+import { resolveChunkReference } from '../../../utils/modules.js';
+import { transformWithBabel } from '../../../utils/transform.js';
+import { getWxEntryRole } from '../module.js';
+/** Renders a native module while activating its statically imported capsules through SystemJS. */
+export function renderNative({ code, chunk, chunks, sourcemap }) {
+    return transformWithBabel(code, chunk.fileName, [connectNativeCapsulesPlugin(chunk.fileName, chunks), transformModulesCommonjs], sourcemap);
+}
+/** Converts only cross-runtime static imports; ordinary native dependencies remain CommonJS imports. */
+function connectNativeCapsulesPlugin(fileName, chunks) {
+    return {
+        name: 'vpt:connect-native-capsules',
+        visitor: {
+            ImportDeclaration(importPath) {
+                const reference = importPath.node.source.value;
+                if (!reference.startsWith('./') && !reference.startsWith('../')) {
+                    return;
+                }
+                const chunkId = resolveChunkReference(fileName, reference);
+                const importedChunk = chunks[chunkId];
+                if (!importedChunk || getWxEntryRole(importedChunk) !== 'capsule') {
+                    return;
+                }
+                const [specifier] = importPath.node.specifiers;
+                if (importPath.node.specifiers.length !== 1 ||
+                    !specifier ||
+                    types.isImportNamespaceSpecifier(specifier)) {
+                    throw new Error(`Expected one capsule value import from ${chunkId} in ${fileName}`);
+                }
+                const imported = types.isImportDefaultSpecifier(specifier)
+                    ? types.identifier('default')
+                    : specifier.imported;
+                const importedConfig = types.memberExpression(createSyncImport(chunkId), types.cloneNode(imported), types.isStringLiteral(imported));
+                importPath.replaceWith(types.variableDeclaration('const', [
+                    types.variableDeclarator(types.cloneNode(specifier.local), importedConfig)
+                ]));
+            }
+        }
+    };
+}
+/** Creates one synchronous lookup through the canonical output chunk ID. */
+function createSyncImport(chunkId) {
+    return types.callExpression(types.memberExpression(types.memberExpression(types.identifier('global'), types.identifier('System')), types.identifier('importSync')), [types.stringLiteral(chunkId)]);
+}

package/dist/node/plugins/wx/render/transport.d.ts

@@ -0,0 +1,17 @@
+import type { Rolldown } from 'vite';
+import { type AstTransformResult } from '../../../utils/transform.ts';
+/**
+ * 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.
+ *
+ * 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
+ * chunks, so honest content hashes and automatic graph linking are more valuable than minimizing that hash fan-out.
+ */
+export declare function materializeTransport({ code, transportChunk, chunks, getLoadMode, sourcemap }: {
+    code: string;
+    transportChunk: Rolldown.RenderedChunk;
+    chunks: Readonly<Record<string, Rolldown.RenderedChunk>>;
+    getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async';
+    sourcemap?: boolean;
+}): Promise<AstTransformResult>;

package/dist/node/plugins/wx/render/transport.js

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import { types } from '@babel/core';
+import { replaceWithAst } from '../../../utils/transform.js';
+import { getWxExecutionKind } from '../module.js';
+const transportPlaceholder = '__VITE_PLUGIN_TARO_TRANSPORT__';
+const moduleIdParameter = 'moduleId';
+const exportBindingParameter = 'exportBinding';
+/**
+ * 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.
+ *
+ * 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
+ * chunks, so honest content hashes and automatic graph linking are more valuable than minimizing that hash fan-out.
+ */
+export async function materializeTransport({ code, transportChunk, chunks, getLoadMode, sourcemap = true }) {
+    // Babel constructs and safely serializes an expression shaped like:
+    // (moduleId) => {
+    //     switch (moduleId) {
+    //         case 'assets/app.js': return require('./app.js')
+    //         case 'sub/p_account/page.js': return require.async('../sub/p_account/page.js')
+    //         case 'assets/bootstrap.js':
+    //             return [[], (exportBinding) => ({ execute() { exportBinding(require('./bootstrap.js')) } })]
+    //         default: throw new Error(`Unknown System module: ${moduleId}`)
+    //     }
+    // }
+    const cases = getTransportedChunks(chunks)
+        .sort((left, right) => left.chunk.fileName.localeCompare(right.chunk.fileName))
+        .map(({ chunk, kind }) => {
+        const loadMode = getLoadMode(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,
+            loadMode,
+            kind
+        });
+    });
+    return await replaceWithAst(code, transportChunk.fileName, {
+        [transportPlaceholder]: types.arrowFunctionExpression([types.identifier(moduleIdParameter)], types.blockStatement([
+            types.switchStatement(types.identifier(moduleIdParameter), [
+                ...cases,
+                createUnknownModuleCase(moduleIdParameter)
+            ])
+        ]))
+    }, sourcemap);
+}
+/** Keeps only capsule and amphibious chunks and carries their narrowed kind into source generation. */
+function getTransportedChunks(chunks) {
+    const transportedChunks = [];
+    for (const chunk of Object.values(chunks)) {
+        const kind = getWxExecutionKind(chunk);
+        if (kind !== 'native') {
+            transportedChunks.push({ chunk, kind });
+        }
+    }
+    return transportedChunks;
+}
+/** Creates one canonical-ID switch case while keeping its native require argument literal. */
+function createTransportCase({ chunkId, transportFileName, loadMode, kind }) {
+    const requirePath = toNativeRequirePath(transportFileName, chunkId);
+    const requireCallee = loadMode === 'sync'
+        ? types.identifier('require')
+        : types.memberExpression(types.identifier('require'), types.identifier('async'));
+    const loadedModule = types.callExpression(requireCallee, [types.stringLiteral(requirePath)]);
+    const registration = kind === 'capsule' ? loadedModule : createAmphibiousRegistrationExpression(loadedModule);
+    return types.switchCase(types.stringLiteral(chunkId), [types.returnStatement(registration)]);
+}
+/** Creates a registration that loads and publishes an amphibious CommonJS namespace only when executed. */
+function createAmphibiousRegistrationExpression(namespace) {
+    return types.arrayExpression([
+        types.arrayExpression([]),
+        types.arrowFunctionExpression([types.identifier(exportBindingParameter)], types.objectExpression([
+            types.objectMethod('method', types.identifier('execute'), [], types.blockStatement([
+                types.expressionStatement(types.callExpression(types.identifier(exportBindingParameter), [namespace]))
+            ]))
+        ]))
+    ]);
+}
+/** Rejects module IDs absent from the closed output graph. */
+function createUnknownModuleCase(moduleId) {
+    return types.switchCase(null, [
+        types.throwStatement(types.newExpression(types.identifier('Error'), [
+            types.binaryExpression('+', types.stringLiteral('Unknown System module: '), types.identifier(moduleId))
+        ]))
+    ]);
+}
+/** Converts one preliminary output path to a literal require path relative to transport. */
+function toNativeRequirePath(fromFileName, toFileName) {
+    const relativePath = path.posix.relative(path.posix.dirname(fromFileName), toFileName);
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}