vite-plugin-taro 0.6.0 → 0.6.2

package/src/node/plugins/wx/placer/placement.ts

@@ -0,0 +1,364 @@
+import { createHash } from 'node:crypto'
+import type { Rolldown } from 'vite'
+
+// Leave headroom below WeChat's 2M subpackage limit for rendered wrappers and native assets.
+export const subpackagePlanningBudget = 1_900_000
+const generatedSubpackageRootPrefix = 'sub/p_'
+
+/** 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 final Rolldown chunk. */
+export type PackageLocation = { kind: 'main' } | SubpackageLocation
+
+/** 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 []
+}
+
+/** Immutable ownership and materialization operations for one complete final-chunk graph. */
+export type Placement = Readonly<{
+    getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation
+    getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string
+    getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async'
+    finalize(bundle: Rolldown.OutputBundle): readonly GeneratedSubpackage[]
+}>
+
+/** Shared main-package value used for every synchronously reachable chunk. */
+const mainPackage = { kind: 'main' } as const
+
+type PlaceableChunk = {
+    chunkId: string
+    estimatedBytes: number
+    transitions: ReadonlySet<number>
+}
+
+type ChunkBin = {
+    chunkIds: string[]
+    estimatedBytes: number
+    transitions: Set<number>
+}
+
+type BinCandidate = {
+    bin: ChunkBin
+    overlap: number
+    remainingBytes: number
+}
+
+type PackedSubpackage = SubpackageLocation & {
+    chunkIds: readonly string[]
+}
+
+/**
+ * Applies Load-Transition Hypergraph Partitioning to Rolldown's final preliminary chunk graph:
+ *
+ * 1. Sort preliminary filenames to remove callback and object-enumeration order from every later decision.
+ * 2. Reserve every explicit entry and its complete static closure in main because native startup must load it synchronously.
+ * 3. Treat each dynamic-import edge as one load transition; the target's static closure is that transition's hyperedge.
+ *    Nested dynamic edges remain separate transitions rather than being folded into the parent closure.
+ * 4. Index every lazy chunk by all transitions requiring it. Shared chunks therefore carry global demand rather than being
+ *    assigned according to the first source module or dynamic root that happens to visit them.
+ * 5. Order chunks by transition demand, estimated emitted bytes, then preliminary filename. Place each chunk once into the
+ *    fitting bin with maximum transition overlap, using best-fit remaining capacity only as a tie-breaker.
+ * 6. Hash each bin's sorted preliminary filenames into a deterministic physical package root and return unique ownership.
+ *
+ * Analysis costs the sum of transition static-closure traversals. Packing scans fitting bins and intersects sparse
+ * transition sets; its worst case is O(CBT), while practical graphs have few bins and sparse transition membership.
+ */
+export function createPlacement({
+    chunks,
+    getAdditionalModuleBytes
+}: {
+    chunks: Readonly<Record<string, Rolldown.RenderedChunk>>
+    getAdditionalModuleBytes(moduleId: string): number
+}): Placement {
+    const chunkById = new Map(Object.entries(chunks).sort(([left], [right]) => left.localeCompare(right)))
+    const mainChunkIds = findMainChunkIds(chunkById)
+    const transitionsByChunk = collectTransitionsByChunk({ chunks: chunkById, mainChunkIds: mainChunkIds })
+    const placeableChunks = [...chunkById]
+        .filter(([chunkId]) => !mainChunkIds.has(chunkId))
+        .map(([chunkId, chunk]) => ({
+            chunkId: chunkId,
+            estimatedBytes:
+                estimateChunkBytes(chunk) +
+                chunk.moduleIds.reduce((bytes, moduleId) => bytes + getAdditionalModuleBytes(moduleId), 0),
+            transitions: transitionsByChunk.get(chunkId) ?? new Set<number>()
+        }))
+    const subpackages = packChunks({
+        chunks: placeableChunks,
+        planningBudgetBytes: subpackagePlanningBudget
+    }).map(createPackedSubpackage)
+
+    // This local map accumulates the immutable plan returned to output materialization.
+    const locationByChunk = new Map<string, PackageLocation>()
+    for (const chunkId of mainChunkIds) {
+        locationByChunk.set(chunkId, mainPackage)
+    }
+    for (const subpackage of subpackages) {
+        for (const chunkId of subpackage.chunkIds) {
+            locationByChunk.set(chunkId, subpackage)
+        }
+    }
+    function getLocation(chunkId: string): PackageLocation {
+        const location = locationByChunk.get(chunkId)
+        if (!location) {
+            throw new Error(`wx placement is missing final chunk: ${chunkId}`)
+        }
+        return location
+    }
+
+    /** Resolves typed ownership from Rolldown's preliminary physical filename before or after finalization. */
+    function getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation {
+        return getLocation('preliminaryFileName' in chunk ? chunk.preliminaryFileName : chunk.fileName)
+    }
+
+    return {
+        getPackageLocation: getPackageLocation,
+
+        /** Adds the planned package root to a physical preliminary path without changing the chunk's SystemJS identity. */
+        getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string {
+            const location = getPackageLocation(chunk)
+            return location.kind === 'main' ? chunk.fileName : `${location.root}/${chunk.fileName}`
+        },
+
+        /** Selects the native loading API directly from typed package ownership. */
+        getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async' {
+            return getPackageLocation(chunk).kind === 'subpackage' ? 'async' : 'sync'
+        },
+
+        /** Assigns each final chunk's Rolldown-owned physical filename and declares typed owners that survived output. */
+        finalize(bundle: Rolldown.OutputBundle): readonly GeneratedSubpackage[] {
+            const outputChunks = Object.values(bundle).filter(
+                (output): output is Rolldown.OutputChunk => output.type === 'chunk'
+            )
+            // This local mutable set deduplicates typed package owners that retain at least one final output chunk.
+            const roots = new Set<string>()
+            for (const chunk of outputChunks) {
+                // OutputChunk.fileName contains the resolved content hash. preliminaryFileName preserves the exact physical
+                // candidate with placeholders that identified this chunk when placement was created during renderChunk.
+                const location = getLocation(chunk.preliminaryFileName)
+                if (location.kind !== 'subpackage') {
+                    continue
+                }
+                // OutputChunk is mutable in generateBundle. Assigning fileName makes Rolldown retain all chunk metadata and
+                // write that same chunk at its physical package path; deleting bundle keys or re-emitting would lose identity.
+                chunk.fileName = `${location.root}/${chunk.fileName}`
+                roots.add(location.root)
+            }
+
+            return [...roots].sort().map((root) => ({
+                name: root.slice(root.lastIndexOf('/') + 1),
+                root: root,
+                pages: []
+            }))
+        }
+    }
+}
+
+/** Keeps every explicit output entry and its complete static chunk closure in main. */
+function findMainChunkIds(chunks: ReadonlyMap<string, Rolldown.RenderedChunk>): Set<string> {
+    const mainChunkIds = new Set<string>()
+    // The worklist avoids recursion and visits every eager static edge once.
+    const pending = [...chunks].filter(([, chunk]) => chunk.isEntry).map(([chunkId]) => chunkId)
+    while (pending.length > 0) {
+        const chunkId = pending.pop()
+        if (!chunkId || mainChunkIds.has(chunkId)) {
+            continue
+        }
+        const chunk = chunks.get(chunkId)
+        if (!chunk) {
+            continue
+        }
+        mainChunkIds.add(chunkId)
+        pending.push(...chunk.imports)
+    }
+    return mainChunkIds
+}
+
+/** Creates every load-transition hyperedge and indexes its static closure by chunk. */
+function collectTransitionsByChunk({
+    chunks,
+    mainChunkIds
+}: {
+    chunks: ReadonlyMap<string, Rolldown.RenderedChunk>
+    mainChunkIds: ReadonlySet<string>
+}): Map<string, ReadonlySet<number>> {
+    const transitionsByChunk = new Map<string, Set<number>>()
+    let transitionId = 0
+    for (const chunk of chunks.values()) {
+        for (const targetId of [...chunk.dynamicImports].sort()) {
+            if (!chunks.has(targetId) || mainChunkIds.has(targetId)) {
+                continue
+            }
+            for (const chunkId of collectStaticClosure({
+                rootId: targetId,
+                chunks: chunks,
+                mainChunkIds: mainChunkIds
+            })) {
+                const transitions = transitionsByChunk.get(chunkId) ?? new Set<number>()
+                transitions.add(transitionId)
+                transitionsByChunk.set(chunkId, transitions)
+            }
+            transitionId++
+        }
+    }
+    return transitionsByChunk
+}
+
+/** Collects one transition's static closure; nested dynamic imports remain independent transitions. */
+function collectStaticClosure({
+    rootId,
+    chunks,
+    mainChunkIds
+}: {
+    rootId: string
+    chunks: ReadonlyMap<string, Rolldown.RenderedChunk>
+    mainChunkIds: ReadonlySet<string>
+}): string[] {
+    const closure = new Set<string>()
+    // The worklist follows static edges only; the visited set terminates cycles.
+    const pending = [rootId]
+    while (pending.length > 0) {
+        const chunkId = pending.pop()
+        if (!chunkId || closure.has(chunkId) || mainChunkIds.has(chunkId)) {
+            continue
+        }
+        const chunk = chunks.get(chunkId)
+        if (!chunk) {
+            continue
+        }
+        closure.add(chunkId)
+        pending.push(...chunk.imports)
+    }
+    return [...closure].sort()
+}
+
+/** Partitions final chunks by transition overlap before best-fit capacity. */
+function packChunks({
+    chunks,
+    planningBudgetBytes
+}: {
+    chunks: readonly PlaceableChunk[]
+    planningBudgetBytes: number
+}): ChunkBin[] {
+    const bins: ChunkBin[] = []
+    const orderedChunks = [...chunks].sort(compareChunks)
+    for (const chunk of orderedChunks) {
+        const bin =
+            chunk.estimatedBytes <= planningBudgetBytes
+                ? (findBestBin({ bins: bins, chunk: chunk, planningBudgetBytes: planningBudgetBytes }) ??
+                  createBin(bins))
+                : createBin(bins)
+        placeChunk(bin, chunk)
+    }
+    return bins
+}
+
+/** Gives globally shared transition demand priority, then size and stable preliminary filename. */
+function compareChunks(left: PlaceableChunk, right: PlaceableChunk): number {
+    return (
+        right.transitions.size - left.transitions.size ||
+        right.estimatedBytes - left.estimatedBytes ||
+        left.chunkId.localeCompare(right.chunkId)
+    )
+}
+
+/** Chooses maximum transition overlap, then the fullest fitting package and stable creation order. */
+function findBestBin({
+    bins,
+    chunk,
+    planningBudgetBytes
+}: {
+    bins: readonly ChunkBin[]
+    chunk: PlaceableChunk
+    planningBudgetBytes: number
+}): ChunkBin | undefined {
+    let best: BinCandidate | undefined
+    for (const bin of bins) {
+        if (bin.estimatedBytes + chunk.estimatedBytes > planningBudgetBytes) {
+            continue
+        }
+        const candidate = {
+            bin: bin,
+            overlap: countOverlap(bin.transitions, chunk.transitions),
+            remainingBytes: planningBudgetBytes - bin.estimatedBytes - chunk.estimatedBytes
+        }
+        if (
+            !best ||
+            candidate.overlap > best.overlap ||
+            (candidate.overlap === best.overlap && candidate.remainingBytes < best.remainingBytes)
+        ) {
+            best = candidate
+        }
+    }
+    return best?.bin
+}
+
+/** Counts transition-package incidences removed by one candidate placement. */
+function countOverlap(left: ReadonlySet<number>, right: ReadonlySet<number>): number {
+    const [smaller, larger] = left.size <= right.size ? [left, right] : [right, left]
+    let overlap = 0
+    for (const transition of smaller) {
+        if (larger.has(transition)) {
+            overlap++
+        }
+    }
+    return overlap
+}
+
+/** Creates one planner-local mutable package. */
+function createBin(bins: ChunkBin[]): ChunkBin {
+    const bin: ChunkBin = {
+        chunkIds: [],
+        estimatedBytes: 0,
+        transitions: new Set<number>()
+    }
+    bins.push(bin)
+    return bin
+}
+
+/** Applies one irreversible, non-duplicating final chunk assignment. */
+function placeChunk(bin: ChunkBin, chunk: PlaceableChunk): void {
+    bin.chunkIds.push(chunk.chunkId)
+    bin.estimatedBytes += chunk.estimatedBytes
+    for (const transition of chunk.transitions) {
+        bin.transitions.add(transition)
+    }
+}
+
+/** Estimates final output bytes from tree-shaken modules plus a bounded generated-chunk allowance. */
+function estimateChunkBytes(chunk: Rolldown.RenderedChunk): number {
+    const renderedModuleBytes = Object.values(chunk.modules).reduce(
+        (bytes, module) => bytes + (module.code ? Buffer.byteLength(module.code, 'utf8') : 0),
+        0
+    )
+    const moduleWrapperBytes = chunk.moduleIds.length * 64
+    const referenceBytes = (chunk.imports.length + chunk.dynamicImports.length) * 32
+    return renderedModuleBytes + moduleWrapperBytes + referenceBytes + 64
+}
+
+/** Freezes membership and derives a stable root from sorted preliminary filenames. */
+function createPackedSubpackage(bin: ChunkBin): PackedSubpackage {
+    const chunkIds = [...bin.chunkIds].sort()
+    const hash = createHash('sha256').update(chunkIds.join('\0')).digest('hex').slice(0, 8)
+    return {
+        kind: 'subpackage',
+        root: `${generatedSubpackageRootPrefix}${hash}`,
+        chunkIds: chunkIds
+    }
+}
+
+/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
+export function isGeneratedSubpackageFile(fileName: string): boolean {
+    return fileName.startsWith(generatedSubpackageRootPrefix)
+}

package/src/node/plugins/wx/placer/placer.ts

@@ -0,0 +1,179 @@
+import { normalizePath, type Plugin, type Rolldown } from 'vite'
+import { getWxExecutionKind, isTransportModule } from '../module/module.ts'
+import { getNativeComponentAssetBytes } from '../native/native-component-assets.ts'
+import { createPlacement, type GeneratedSubpackage, type PackageLocation, type Placement } from './placement.ts'
+
+export type { GeneratedSubpackage, Placement } from './placement.ts'
+
+const pnpmFrameworkPackagePattern = /\/node_modules\/\.pnpm\/(?:@tarojs\+|react(?:-dom|-reconciler)?@|scheduler@)/
+const workspaceFrameworkPackagePattern = /\/packages\/(?:taro-react|taro-plugin-framework-react)\//
+
+/** Selects the explicit React/Taro roots whose complete dependency closure forms the framework vendor chunk. */
+export function isWxFrameworkVendorModule(moduleId: string): boolean {
+    const normalizedId = normalizePath(moduleId)
+    return pnpmFrameworkPackagePattern.test(normalizedId) || workspaceFrameworkPackagePattern.test(normalizedId)
+}
+
+type PlacementState =
+    | { phase: 'idle' }
+    | { phase: 'awaiting-chunks' }
+    | { phase: 'planned'; placement: Placement }
+    | { phase: 'finalized'; placement: Placement; subpackages: readonly GeneratedSubpackage[] }
+
+/** Placement services consumed by the later `vpt:wx` rendering and output hooks. */
+export type WxPlacementPlugin = Plugin &
+    Readonly<{
+        getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation
+        getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string
+        getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async'
+        getSubpackages(): readonly GeneratedSubpackage[]
+    }>
+
+/**
+ * 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: {
+        /**
+         * React and Taro form one stable framework boundary shared by the App and every Page capsule. Keeping their complete
+         * dependency closure together prevents application edits from invalidating framework chunk identity and makes later
+         * development generations eligible to reuse the unchanged vendor. All remaining modules use Rolldown's automatic
+         * chunking; physical WX package placement operates on those final chunks without imposing another split strategy.
+         */
+        codeSplitting: {
+            groups: [
+                {
+                    name: 'vendor',
+                    test: isWxFrameworkVendorModule,
+                    priority: 100,
+                    includeDependenciesRecursively: true
+                }
+            ]
+        },
+        /**
+         * 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: Rolldown.PreRenderedChunk): string {
+            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' as const
+}
+
+/**
+ * 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(): WxPlacementPlugin {
+    // This one mutable cell is the output-generation state machine described above; hooks replace it atomically by phase.
+    let state: PlacementState = { phase: 'idle' }
+
+    function requirePlacement(): Placement {
+        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: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation {
+            return requirePlacement().getPackageLocation(chunk)
+        },
+
+        getPhysicalChunkId(chunk: Rolldown.RenderedChunk): string {
+            return requirePlacement().getPhysicalChunkId(chunk)
+        },
+
+        getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async' {
+            return requirePlacement().getLoadMode(chunk)
+        },
+
+        getSubpackages(): readonly GeneratedSubpackage[] {
+            if (state.phase !== 'finalized') {
+                throw new Error('wx subpackages are unavailable before output finalization')
+            }
+            return state.subpackages
+        }
+    }
+}

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

@@ -4,11 +4,10 @@ import { esTarget } from '../../utils/constant.ts'
 import { packageRequire } from '../../utils/packages.ts'
 import { clientTaroNativeId } from '../client/constant.ts'
 import { createWxDevelopmentPlugin } from './dev/plugins.ts'
-import { getWxExecutionKind, isTransportModule } from './module.ts'
+import { getWxExecutionKind, isTransportModule } from './module/module.ts'
 import { compileNativeComponentInterface } from './native/compile-native-component-interface.ts'
-import { getNativeComponentAssetBytes } from './native/native-component-assets.ts'
 import { createOutputFiles } from './output/files.ts'
-import { createPlacer } from './placement/placer.ts'
+import { createWxPlacementPlugin, type WxPlacementPlugin } from './placer/placer.ts'
 import { renderCapsule } from './render/capsule.ts'
 import { renderNative } from './render/native.ts'
 import { materializeTransport } from './render/transport.ts'
@@ -23,17 +22,18 @@ export function createWxTargetPlugins(options: VptOptions): PluginOption[] {
 
     // 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: VptOptions, resolver: WxResolver): Plugin {
-    const placer = createPlacer()
-
+function createWxPlugin(options: VptOptions, resolver: WxResolver, placement: WxPlacementPlugin): Plugin {
     return {
         name: 'vpt:wx',
 
@@ -70,7 +70,8 @@ function createWxPlugin(options: VptOptions, resolver: WxResolver): Plugin {
                     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
                     }
                 }
@@ -99,17 +100,11 @@ function createWxPlugin(options: VptOptions, resolver: WxResolver): Plugin {
             }
         },
 
-        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)
 
@@ -126,7 +121,8 @@ function createWxPlugin(options: VptOptions, resolver: WxResolver): Plugin {
                         code: native.code,
                         transportChunk: chunk,
                         chunks: meta.chunks,
-                        getLoadMode: placer.getLoadMode,
+                        getLoadMode: placement.getLoadMode,
+                        getPhysicalChunkId: placement.getPhysicalChunkId,
                         sourcemap
                     })
                 }
@@ -144,13 +140,17 @@ function createWxPlugin(options: VptOptions, resolver: WxResolver): Plugin {
              */
             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) => {