vite-plugin-taro 0.6.0 → 0.6.1

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

@@ -0,0 +1,123 @@
+import { getWxExecutionKind, isTransportModule } from '../module.js';
+import { getNativeComponentAssetBytes } from '../native/native-component-assets.js';
+import { createPlacement } from './placement.js';
+/**
+ * Rolldown options owned by WX placement. Every field enforces a distinct output invariant. The plugin returns this object
+ * from its config hook, while direct Rolldown integration tests reuse the same value to exercise the identical lifecycle.
+ */
+export const placementRolldownOptions = {
+    /**
+     * Output-stage naming remains under Rolldown's ownership. These options establish physical candidates and hash
+     * participation only; LTHP mutates the resulting OutputChunk filenames later without replacing the chunks.
+     */
+    output: {
+        /**
+         * Native App/Page/Component shells are files addressed directly by WeChat and must retain the exact names configured
+         * in `input`, such as `app.js` and `pages/home/index.js`. Transport is excluded even though it is CommonJS:
+         * application chunks import its content-hashed path, so it belongs with hashed runtime/capsule entries. `[hash]`
+         * remains a Rolldown placeholder here and is resolved only after renderChunk transforms finish.
+         */
+        entryFileNames(chunk) {
+            return getWxExecutionKind(chunk) === 'native' && !isTransportModule(chunk)
+                ? '[name]'
+                : 'assets/[name]-[hash].js';
+        },
+        /**
+         * Leaves chunk identity and collision handling entirely to Rolldown. This package-neutral physical pattern deliberately
+         * contains no LTHP owner; generateBundle adds only the selected package root to the existing Rolldown filename.
+         */
+        chunkFileNames: 'assets/[name]-[hash].js',
+        /**
+         * Emits generic Rolldown assets under one collision-resistant hashed namespace. Native-component folders are not
+         * governed by this option: createNativeComponentOutput preserves their required relative filenames and relocates the
+         * complete folder beside its owning JavaScript chunk after LTHP finalization.
+         */
+        assetFileNames: 'assets/[name]-[hash][extname]'
+    },
+    /**
+     * Keeps every native entry's required exports while allowing Rolldown to add cross-chunk bindings created by natural code
+     * splitting. `strict` can reject those extensions; `exports-only` can merge away native boundaries; `allow-extension`
+     * preserves the shell/capsule contract without forcing source-module placement groups.
+     */
+    preserveEntrySignatures: 'allow-extension'
+};
+/**
+ * Creates the `vpt:wx-placer` lifecycle owner:
+ *
+ * 1. Its config hook installs package-neutral Rolldown names and entry-signature semantics.
+ * 2. `renderStart` atomically starts a generation in `awaiting-chunks`; no stale placement remains reachable.
+ * 3. Its first pre-order `renderChunk` creates one immutable LTHP placement from the complete tree-shaken graph.
+ * 4. `vpt:wx` asks this plugin only for package ownership, physical relocation, and native loading mode.
+ * 5. Its pre-order `generateBundle` assigns each OutputChunk its package-qualified filename and publishes app.json declarations.
+ *
+ * The discriminated state is the only generation-local mutation: `idle → awaiting-chunks → planned → finalized`. Each hook
+ * performs one whole-state transition, so stale graph state, duplicate planning, and partially reset generations are
+ * unrepresentable.
+ */
+export function createWxPlacementPlugin() {
+    // This one mutable cell is the output-generation state machine described above; hooks replace it atomically by phase.
+    let state = { phase: 'idle' };
+    function requirePlacement() {
+        if (state.phase === 'idle' || state.phase === 'awaiting-chunks') {
+            throw new Error('wx placement is unavailable before Rolldown exposes the final chunk graph');
+        }
+        return state.placement;
+    }
+    return {
+        name: 'vpt:wx-placer',
+        config() {
+            return {
+                build: {
+                    rolldownOptions: placementRolldownOptions
+                }
+            };
+        },
+        renderStart() {
+            state = { phase: 'awaiting-chunks' };
+        },
+        renderChunk: {
+            order: 'pre',
+            handler(_code, _chunk, _outputOptions, meta) {
+                if (state.phase === 'planned') {
+                    return;
+                }
+                if (state.phase !== 'awaiting-chunks') {
+                    throw new Error(`wx placement received final chunks during the ${state.phase} phase`);
+                }
+                state = {
+                    phase: 'planned',
+                    placement: createPlacement({
+                        chunks: meta.chunks,
+                        getAdditionalModuleBytes: (moduleId) => getNativeComponentAssetBytes(this.getModuleInfo(moduleId)?.meta)
+                    })
+                };
+            }
+        },
+        generateBundle: {
+            order: 'pre',
+            handler(_outputOptions, bundle) {
+                const placement = requirePlacement();
+                state = {
+                    phase: 'finalized',
+                    placement: placement,
+                    subpackages: placement.finalize(bundle)
+                };
+            }
+        },
+        getPackageLocation(chunk) {
+            return requirePlacement().getPackageLocation(chunk);
+        },
+        getPhysicalChunkId(chunk) {
+            return requirePlacement().getPhysicalChunkId(chunk);
+        },
+        getLoadMode(chunk) {
+            return requirePlacement().getLoadMode(chunk);
+        },
+        getSubpackages() {
+            if (state.phase !== 'finalized') {
+                throw new Error('wx subpackages are unavailable before output finalization');
+            }
+            return state.subpackages;
+        }
+    };
+}

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

@@ -4,9 +4,8 @@ import { clientTaroNativeId } from '../client/constant.js';
 import { createWxDevelopmentPlugin } from './dev/plugins.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 { createWxPlacementPlugin } from './placer/placer.js';
 import { renderCapsule } from './render/capsule.js';
 import { renderNative } from './render/native.js';
 import { materializeTransport } from './render/transport.js';
@@ -17,15 +16,16 @@ export function createWxTargetPlugins(options) {
     const resolver = createResolver(options);
     // Reuse the resolver instance's ordered application subset. Rolldown's complete input also contains bootstrap, transport,
     // shell, and component entries; entry membership alone cannot recover which roots define the App/Page CSS cascade.
+    const placement = createWxPlacementPlugin();
     return [
+        placement,
         createWxStylePlugins(),
-        createWxPlugin(options, resolver),
+        createWxPlugin(options, resolver, placement),
         createWxDevelopmentPlugin(options, resolver.applicationEntryIds)
     ];
 }
 /** Configures the complete wx target build pipeline. */
-function createWxPlugin(options, resolver) {
-    const placer = createPlacer();
+function createWxPlugin(options, resolver, placement) {
     return {
         name: 'vpt:wx',
         config(_config, _env) {
@@ -54,7 +54,8 @@ function createWxPlugin(options, resolver) {
                     assetsInlineLimit: 0,
                     target: esTarget,
                     rolldownOptions: {
-                        ...placer.rolldownOptions,
+                        // The dedicated vpt:wx-placer plugin owns output naming and entry-signature semantics. This plugin owns
+                        // only the closed named input set of native shells, lifecycle capsules, bootstrap, and transport entries.
                         input: resolver.input
                     }
                 }
@@ -78,16 +79,10 @@ function createWxPlugin(options, resolver) {
                 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) {
+                // vpt:wx-placer runs first and has already created immutable placement from this complete chunk graph.
                 const executionKind = getWxExecutionKind(chunk);
                 const sourcemap = Boolean(outputOptions.sourcemap);
                 if (executionKind === 'capsule') {
@@ -101,7 +96,8 @@ function createWxPlugin(options, resolver) {
                         code: native.code,
                         transportChunk: chunk,
                         chunks: meta.chunks,
-                        getLoadMode: placer.getLoadMode,
+                        getLoadMode: placement.getLoadMode,
+                        getPhysicalChunkId: placement.getPhysicalChunkId,
                         sourcemap
                     });
                 }
@@ -117,12 +113,16 @@ function createWxPlugin(options, resolver) {
              */
             order: 'post',
             async handler(_, bundle) {
-                const subpackages = placer.getSubpackages(bundle);
+                // LTHP joins OutputChunks to their preliminary logical IDs and assigns Rolldown-owned physical filenames.
+                // createOutputFiles then observes those paths to relocate native component folders, emit placeholders, and
+                // declare only surviving package roots in app.json. No JavaScript chunk is manually emitted or copied.
+                const subpackages = placement.getSubpackages();
                 const outputFiles = await createOutputFiles({
                     bundle,
                     options,
                     subpackages,
-                    getModuleInfo: (moduleId) => this.getModuleInfo(moduleId)
+                    getModuleInfo: (moduleId) => this.getModuleInfo(moduleId),
+                    getPackageLocation: placement.getPackageLocation
                 });
                 outputFiles.forEach((file) => {
                     this.emitFile(file);

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

@@ -1,5 +1,5 @@
 import { types } from '@babel/core';
-import { resolveChunkReference } from '../../../utils/modules.js';
+import { resolveLogicalChunkReference } from '../chunk-path.js';
 /** Wraps System.register as an inert CommonJS capsule tuple with canonical final dependency IDs. */
 export function wrapCapsulePlugin(fileName) {
     return {
@@ -54,11 +54,11 @@ 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);
+    reference.value = resolveLogicalChunkReference(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);
+        reference.value = resolveLogicalChunkReference(fileName, reference.value);
     }
 }

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

@@ -1,7 +1,7 @@
 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 { resolveLogicalChunkReference, resolvePhysicalChunkReference } from '../chunk-path.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 }) {
@@ -17,8 +17,8 @@ function connectNativeCapsulesPlugin(fileName, chunks) {
                 if (!reference.startsWith('./') && !reference.startsWith('../')) {
                     return;
                 }
-                const chunkId = resolveChunkReference(fileName, reference);
-                const importedChunk = chunks[chunkId];
+                const physicalChunkId = resolvePhysicalChunkReference(fileName, reference);
+                const importedChunk = chunks[physicalChunkId];
                 if (!importedChunk || getWxEntryRole(importedChunk) !== 'capsule') {
                     return;
                 }
@@ -26,12 +26,12 @@ function connectNativeCapsulesPlugin(fileName, chunks) {
                 if (importPath.node.specifiers.length !== 1 ||
                     !specifier ||
                     types.isImportNamespaceSpecifier(specifier)) {
-                    throw new Error(`Expected one capsule value import from ${chunkId} in ${fileName}`);
+                    throw new Error(`Expected one capsule value import from ${physicalChunkId} in ${fileName}`);
                 }
                 const imported = types.isImportDefaultSpecifier(specifier)
                     ? types.identifier('default')
                     : specifier.imported;
-                const importedConfig = types.memberExpression(createSyncImport(chunkId), types.cloneNode(imported), types.isStringLiteral(imported));
+                const importedConfig = types.memberExpression(createSyncImport(resolveLogicalChunkReference(fileName, reference)), types.cloneNode(imported), types.isStringLiteral(imported));
                 importPath.replaceWith(types.variableDeclaration('const', [
                     types.variableDeclarator(types.cloneNode(specifier.local), importedConfig)
                 ]));

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

@@ -1,17 +1,21 @@
 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.
+ * 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
  * 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 }: {
+export declare function materializeTransport({ code, transportChunk, chunks, getLoadMode, getPhysicalChunkId, sourcemap }: {
     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>;

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

@@ -1,19 +1,24 @@
 import path from 'node:path';
 import { types } from '@babel/core';
 import { replaceWithAst } from '../../../utils/transform.js';
+import { toLogicalChunkId } from '../chunk-path.js';
 import { getWxExecutionKind } from '../module.js';
 const transportPlaceholder = '__VPT_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.
+ * 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
  * 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 }) {
+export async function materializeTransport({ code, transportChunk, chunks, getLoadMode, getPhysicalChunkId = (chunk) => chunk.fileName, sourcemap = true }) {
+    const physicalTransportId = getPhysicalChunkId(transportChunk);
     // Babel constructs and safely serializes an expression shaped like:
     // (moduleId) => {
     //     switch (moduleId) {
@@ -28,12 +33,16 @@ export async function materializeTransport({ code, transportChunk, chunks, getLo
         .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
         });
@@ -58,9 +67,9 @@ function getTransportedChunks(chunks) {
     }
     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);
+/** Creates one logical-ID switch case while keeping its physical native require argument literal. */
+function createTransportCase({ chunkId, transportFileName, loadMode, kind, physicalChunkId }) {
+    const requirePath = toNativeRequirePath(transportFileName, physicalChunkId);
     const requireCallee = loadMode === 'sync'
         ? types.identifier('require')
         : types.memberExpression(types.identifier('require'), types.identifier('async'));

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

@@ -6,8 +6,6 @@ type PageComponentPathOptions = {
     pagePath: string;
     projectRoot: string;
 };
-/** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
-export declare function resolveChunkReference(importerChunkId: string, reference: string): string;
 /** Resolves the source file for the configured App component. */
 export declare function resolveAppComponentPath({ appPath, projectRoot }: AppComponentPathOptions): string;
 /** Resolves the source file for one configured Page component. */

package/dist/node/utils/modules.js

@@ -1,12 +1,5 @@
 import path from 'node:path';
 import { normalizePath } from 'vite';
-/** Resolves a final relative reference to the canonical output chunk ID used by the WX module registry. */
-export function resolveChunkReference(importerChunkId, reference) {
-    if (!reference.startsWith('./') && !reference.startsWith('../')) {
-        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 }) {
     return path.resolve(projectRoot, appPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat Mini Program and H5 targets.",
   "type": "module",
@@ -76,8 +76,8 @@
     "rxjs": "^7.8.2",
     "tailwindcss": "^4.3.3",
     "weapp-tailwindcss": "^5.2.11",
-    "@tarojs/react": "npm:vite-plugin-taro-react@0.6.0",
-    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.6.0"
+    "@tarojs/plugin-framework-react": "npm:vite-plugin-taro-plugin-framework-react@0.6.1",
+    "@tarojs/react": "npm:vite-plugin-taro-react@0.6.1"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/node/plugins/wx/chunk-path.ts

@@ -0,0 +1,22 @@
+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: string): string {
+    return path.posix.relative(generatedChunkDirectory, physicalChunkId)
+}
+
+/** Resolves one relative Rolldown-generated import to its preliminary physical chunk path. */
+export function resolvePhysicalChunkReference(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)
+}
+
+/** Projects one relative Rolldown-generated import into its package-neutral SystemJS identity. */
+export function resolveLogicalChunkReference(importerChunkId: string, reference: string): string {
+    return toLogicalChunkId(resolvePhysicalChunkReference(importerChunkId, reference))
+}

package/src/node/plugins/wx/dev/wx-dev-options.ts

@@ -68,12 +68,26 @@ export function installWxDevOptions({
          * 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
         })
 
@@ -84,9 +98,16 @@ export function installWxDevOptions({
         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
         }
 

package/src/node/plugins/wx/native/create-native-component-output.ts

@@ -1,16 +1,18 @@
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import type { Rolldown } from 'vite'
-import { isGeneratedSubpackageFile } from '../placement/plan.ts'
+import type { PackageLocation } from '../placer/placement.ts'
 import { getNativeComponentSources } from './native-component-assets.ts'
 
 /** Creates opaque native files and their registrations from each surviving JSX interface module. */
 export async function createNativeComponentOutput({
     bundle,
-    getModuleInfo
+    getModuleInfo,
+    getPackageLocation
 }: {
     bundle: Rolldown.OutputBundle
     getModuleInfo: (moduleId: string) => { meta: Rolldown.CustomPluginOptions } | null
+    getPackageLocation(chunk: Rolldown.OutputChunk): PackageLocation
 }) {
     // Files and registrations accumulate in final chunk order for deterministic output.
     const files: Rolldown.EmittedAsset[] = []
@@ -25,9 +27,8 @@ export async function createNativeComponentOutput({
         if (output.type !== 'chunk') {
             continue
         }
-        const packageRoot = isGeneratedSubpackageFile(output.fileName)
-            ? path.posix.dirname(path.posix.dirname(output.fileName))
-            : undefined
+        const location = getPackageLocation(output)
+        const packageRoot = location.kind === 'subpackage' ? location.root : undefined
 
         for (const moduleId of output.moduleIds) {
             const sources = getNativeComponentSources(getModuleInfo(moduleId)?.meta)

package/src/node/plugins/wx/output/files.ts

@@ -1,7 +1,7 @@
 import type { Rolldown } from 'vite'
 import type { VptOptions } from '../../../../options.ts'
 import { createNativeComponentOutput } from '../native/create-native-component-output.ts'
-import type { GeneratedSubpackage } from '../placement/placer.ts'
+import type { GeneratedSubpackage, PackageLocation } from '../placer/placement.ts'
 import { createJsonAssets } from './json.ts'
 import { createTemplateAssets } from './templates.ts'
 
@@ -10,14 +10,16 @@ export async function createOutputFiles({
     bundle,
     options,
     subpackages,
-    getModuleInfo
+    getModuleInfo,
+    getPackageLocation
 }: {
     bundle: Rolldown.OutputBundle
     options: VptOptions
     subpackages: readonly GeneratedSubpackage[]
     getModuleInfo: (moduleId: string) => { meta: Rolldown.CustomPluginOptions } | null
+    getPackageLocation(chunk: Rolldown.OutputChunk): PackageLocation
 }): Promise<Rolldown.EmittedFile[]> {
-    const nativeOutput = await createNativeComponentOutput({ bundle, getModuleInfo })
+    const nativeOutput = await createNativeComponentOutput({ bundle, getModuleInfo, getPackageLocation })
 
     return [
         {

package/src/node/plugins/wx/output/json.ts

@@ -1,8 +1,7 @@
 import type { Rolldown } from 'vite'
 import type { VptJsonObject, VptOptions, VptPageOption } from '../../../../options.ts'
 import { createAppConfig } from '../../../utils/project-config.ts'
-import type { GeneratedSubpackage } from '../placement/placer.ts'
-import { isGeneratedSubpackageFile } from '../placement/plan.ts'
+import { type GeneratedSubpackage, isGeneratedSubpackageFile } from '../placer/placement.ts'
 import { toRootRelativePath } from './relative-root.ts'
 
 /** Creates every configured native JSON asset. */