vite-plugin-taro 0.6.18 → 0.6.19

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

@@ -1,358 +0,0 @@
-import { recursiveMerge } from '@tarojs/helper';
-import { Weapp as WxPlatform } from '@tarojs/plugin-platform-weapp';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { packageRequire } from '../../../utils/packages.js';
-import { createAppConfig } from '../../../utils/project-config.js';
-import { isGeneratedSubpackageFile } from '../placer/placement.js';
-import { toRootRelativePath } from './relative-root.js';
-const customWrapperName = 'custom-wrapper';
-const taroComponentsModulePath = packageRequire.resolve('@tarojs/plugin-platform-weapp/dist/components-react');
-/** Creates every JSON, WXML, WXS, and Page WXSS asset owned by Taro's native rendering boundary. */
-export function createTemplateAssets({ bundle, options, subpackages, nativeComponents, isProduction }) {
-    const templateBuilder = createTemplateBuilder();
-    const componentConfig = collectTemplateComponentConfig(bundle, nativeComponents);
-    const nativeComponentConfig = createNativeComponentConfig(nativeComponents);
-    const recursiveComponentJson = createRecursiveComponentJson(nativeComponentConfig);
-    const jsonAsset = (fileName, value) => createJsonAsset(fileName, value, isProduction);
-    return [
-        jsonAsset('app.json', createAppJson({ options, subpackages })),
-        createAsset('base.wxml', templateBuilder.buildBaseTemplate(componentConfig)),
-        createAsset('utils.wxs', templateBuilder.buildXScript()),
-        createAsset('comp.wxml', templateBuilder.buildBaseComponentTemplate('.wxml')),
-        jsonAsset('comp.json', recursiveComponentJson),
-        createAsset('custom-wrapper.wxml', templateBuilder.buildCustomComponentTemplate('.wxml')),
-        jsonAsset('custom-wrapper.json', recursiveComponentJson),
-        ...options.pages.flatMap((page) => [
-            jsonAsset(`${page.path}.json`, createPageJson(page, nativeComponentConfig)),
-            createAsset(`${page.path}.wxml`, templateBuilder.buildPageTemplate(toRootRelativePath(page.path, 'base.wxml'), {
-                content: page.config,
-                path: page.path
-            })),
-            createAsset(`${page.path}.wxss`, '')
-        ]),
-        jsonAsset('project.config.json', options.projectConfigJson),
-        ...(options.projectPrivateConfigJson
-            ? [jsonAsset('project.private.config.json', options.projectPrivateConfigJson)]
-            : []),
-        ...(options.sitemapJson ? [jsonAsset('sitemap.json', options.sitemapJson)] : [])
-    ];
-}
-/**
- * Adapts Taro's stock template builder to the WXML half of WX App wrapping without changing its recursive renderer.
- *
- * End-to-end contract
- * -------------------
- * React and Taro retain one in-memory ownership tree:
- *
- * App React root
- *   -> App host records
- *      -> vpt_page_outlet host at App {children}
- *         -> independently scheduled Taro Page roots
- *
- * The patched WX document makes the singleton App host a TaroRootElement. App host mutations therefore batch under app.*
- * and fan out to every mounted native Page. Each Page root remains its own TaroRootElement and emits only page.*. The React
- * host renderer marks the outlet and its App ancestors with an ordinary compact `vo` prop after each commit, while patched
- * hydrate() stops at vpt_page_outlet. Page roots remain attached for React Context, lifecycle, events, removal, refs, effects,
- * and HMR without entering app data.
- *
- * Build-time output
- * -----------------
- * createTemplateAssets asks one builder for shared base.wxml, utils.wxs, comp.wxml, custom-wrapper.wxml, and each Page WXML.
- * This adapter specializes the products that own the native join:
- *
- * - shared base.wxml receives branch-local slot forwarding at comp boundaries plus vpt_fragment and vpt_page_outlet
- *   template definitions;
- * - each Page WXML replaces Taro's root:root entry with one generic comp bound to app and one caller-owned taro_tmpl bound
- *   to page as that component's default slot.
- *
- * utils.wxs remains Taro's normal compact-node dispatcher. comp.wxml and custom-wrapper.wxml retain Taro's generic compact
- * rendering contracts; their JSON companions register recursive boundaries and native components, while runtime configs
- * retain standard event dispatch. CustomWrapper keeps Taro's Page-local ownership model and is not made slot-transparent
- * for App wrapping.
- * There is one shared template namespace, no Page-specific base file, no App/Page mode property, and no Page object threaded
- * through App template data.
- *
- * First native Page
- * -----------------
- * createPageConfig starts the native Page with:
- *
- *     app  = { nn: 'vpt_fragment', cn: [] }
- *     page = { cn: [] }
- *
- * nn lets unchanged comp dispatch one input object even though App JSX may produce one or many root hosts. The record
- * is WXML-only rather than a Taro host, so it needs no sid. After React commits the Page root below the outlet, the framework
- * queues a lazy hydrate(AppRoot).cn value beside the Page root's already-pending page.* payloads. Taro drains both through the
- * native Page's existing first setData, making App wrapping and Page content appear atomically.
- *
- * Native WXML execution
- * ---------------------
- * Data/slot ownership and named-template ownership intentionally travel through different scopes:
- *
- * Page WXML (owns app, page, Page eh, and Page-content light DOM)
- *   -> <comp i="{{app}}"> (crosses into a virtual custom-component scope)
- *      -> comp.wxml (owns App eh, imports unchanged utils.wxs and shared base.wxml)
- *         -> tmpl_0_vpt_fragment (iterates the real App compact roots in app.cn)
- *            -> stock Taro templates (render App hosts and recurse through their cn arrays)
- *               -> native recursion boundary <comp ...>
- *                    -> forwards <slot /> only when this compact subtree root has i.vo
- *               -> tmpl_0_vpt_page_outlet at React's exact {children} position
- *                  -> <slot />
- *                     -> caller-owned <template is="taro_tmpl" data="{{root:page}}" />
- *                        -> stock Taro templates render this native Page's page.cn records
- *
- * The virtual comp and both private templates add no native layout node. `vo` is part of the existing compact node i, not a
- * component property or template context. App events execute through comp.eh; slotted Page events retain the native Page's
- * eh. Both resolve the original Taro sid through the same event source.
- *
- * Named-template scope
- * --------------------
- * Slots transfer caller-owned light DOM only. They do not transfer the caller's named-template table or WXS modules. App
- * dispatch runs inside comp.wxml, so vpt_fragment and vpt_page_outlet must live in base.wxml imported by that component.
- * Putting those definitions in buildPageTemplate produces Page WXML that compiles, but component runtime dispatch fails with
- * `Template tmpl_0_vpt_fragment not found`. Shared base.wxml makes the names visible in the root and every recursive
- * component scope and emits them once rather than once per Page.
- *
- * Projection-spine ownership
- * --------------------------
- * React's host renderer runs after the final commit tree exists and caches the outlet-to-root Taro host ancestor array. It
- * skips the unchanged root-side suffix, gives old leaf-side nodes the ordinary host prop vo=false, and gives new ones vo=true.
- * Taro's existing lazy structural hydration runs later and therefore serializes those props without projection-specific
- * scheduler or hydrate behavior. If React replaces the outlet host while moving it, the renderer finds the unique new marker
- * once and caches its new ancestor array. At each depth-reset comp boundary, i.vo makes forwarding an O(1) local decision;
- * WXML never searches descendants, and Page trees instantiate no unnamed slot.
- *
- * Steady-state updates and navigation
- * -----------------------------------
- * A page.* setData updates only the caller-owned Page template inside the slot. app is not passed through that template and
- * comp.i does not change, so Page updates cannot invalidate App recursion. Ordinary app.* payloads and outlet-spine marker
- * changes remain in Taro's granular batch before it fans out to every retained native Page. Adding or removing a React Page
- * root mutates the outlet only in memory, and the runtime suppresses that marker's native child update. A newly pushed Page
- * receives the latest complete App snapshot in its initial batch, while existing and hidden Pages require no navigation
- * synchronization.
- *
- * Method responsibilities
- * -----------------------
- * 1. buildBaseTemplate preserves stock host templates, makes each depth-reset comp boundary slot-transparent through i.vo,
- *    and adds the two private definitions to the shared namespace.
- * 2. buildPageTemplate owns only the Page boundary: app binding, page binding, and the single Page-content slot.
- * 3. buildXScript delegates unchanged because routing metadata already travels inside compact node i.
- * 4. buildBaseComponentTemplate delegates unchanged so recursive comp remains generic and feature-independent.
- * 5. buildCustomComponentTemplate delegates unchanged so CustomWrapper renders compact children in its own native scope.
- *
- * H5 never calls this WX output builder. Its App continues to receive ordinary Fragment children and none of these native
- * data roots, templates, custom-component boundaries, or slot rules enter the browser build.
- */
-/** Replaces one pinned Taro fragment and rejects absent or duplicated upstream contracts. */
-export function replaceExactlyOnce(source, current, replacement, description) {
-    const firstIndex = source.indexOf(current);
-    const duplicateIndex = firstIndex === -1 ? -1 : source.indexOf(current, firstIndex + current.length);
-    if (firstIndex === -1 || duplicateIndex !== -1) {
-        throw new Error(`Expected one ${description}, found ${firstIndex === -1 ? 0 : 'multiple'}`);
-    }
-    return `${source.slice(0, firstIndex)}${replacement}${source.slice(firstIndex + current.length)}`;
-}
-function createTemplateBuilder() {
-    const platform = new WxPlatform({
-        helper: {
-            recursiveMerge
-        },
-        // c8 cannot observe callbacks Taro accepts but intentionally never invokes.
-        /* c8 ignore next */
-        modifyWebpackChain() { },
-        /* c8 ignore next */
-        registerPlatform() { }
-    }, {}, {});
-    platform.modifyTemplate({});
-    const taroTemplateBuilder = platform.template;
-    return {
-        buildBaseTemplate: (componentConfig) => {
-            const source = taroTemplateBuilder.buildTemplate(componentConfig);
-            /*
-             * Taro inserts recursive comp only when template depth resets. App {children} may be below any number of those
-             * boundaries, so each boundary reads the renderer-maintained vo marker on its compact subtree root before forwarding
-             * the caller's default slot. No App/Page mode or Page data is threaded through template scopes: Page recursion
-             * and unrelated App branches have no marker, while the outlet spine carries the one Page-owned slot.
-             */
-            const slotTransparentRecursion = replaceExactlyOnce(source, '<comp i="{{i}}" l="{{l}}" />', `<comp i="{{i}}" l="{{l}}"><slot wx:if="{{i.vo}}" /></comp>`, 'recursive comp call');
-            /*
-             * These definitions belong in shared base.wxml rather than buildPageTemplate. Although native data is Page-owned,
-             * the dynamic calls that render App records execute after crossing into comp.wxml's component scope. WXML slots
-             * transfer caller-owned light DOM, not the caller's named-template table or WXS modules. comp.wxml can therefore
-             * resolve only its own definitions and those imported from base.wxml.
-             *
-             * Defining the two names in Page WXML is not merely redundant: WeChat accepts that Page file at compile time, then
-             * comp.wxml's runtime dispatch fails with `Template tmpl_0_vpt_fragment not found` because component template
-             * resolution never searches the caller Page. Shared base.wxml is already imported by comp.wxml, makes both names
-             * visible at every depth-reset component scope, and emits them once instead of once per generated Page.
-             *
-             * Page WXML can give generic comp one i object, whereas App output is a root collection. vpt_fragment bridges
-             * those contracts without becoming a native or Taro host: its nn is only a template discriminator and its
-             * template emits each real cn record directly. Keeping the collection behind one comp is important because that
-             * component owns exactly one Page slot regardless of whether App rendered zero, one, or many top-level hosts.
-             * The synthetic record itself is not keyed or event-addressable, so it deliberately has no sid. Its cn items are
-             * different: they are real hydrated Taro elements, text nodes, or the outlet, and every one has Taro's stable sid.
-             * wx:key="sid" matches Taro's stock root.cn loop so insertion/reordering preserves native-component instances,
-             * sibling identity, and event-source routing instead of reusing children only by array position.
-             *
-             * vpt_page_outlet is the matching terminal. The patched runtime retains Page roots below that marker in memory
-             * and serializes no children into app data, while React's host renderer marks its compact ancestor spine with vo.
-             * The slot inserts the parent Page's separate page data at the same visual position and adds no native layout
-             * wrapper.
-             */
-            return `${slotTransparentRecursion}
-<template name="tmpl_0_vpt_fragment">
-  <template
-    is="{{xs.a(0, item.nn, '')}}"
-    data="{{i:item,c:1,l:xs.f('',item.nn)}}"
-    wx:for="{{i.cn}}"
-    wx:key="sid"
-  />
-</template>
-<template name="tmpl_0_vpt_page_outlet"><slot /></template>
-`;
-        },
-        buildXScript: () => {
-            // Alias selection and compact paths are unchanged; both App and Page records use Taro's normal node vocabulary,
-            // and projection ownership already travels on the current i object as vo.
-            return taroTemplateBuilder.buildXScript();
-        },
-        buildBaseComponentTemplate: (ext) => {
-            /*
-             * Keep comp generic. i is the current compact node dispatched through i.nn. l is Taro's lineage of selected
-             * special/native aliases: xs.f records bounded/nestable ancestors and xs.a uses that history when choosing a
-             * generated template level on non-recursive WXML platforms. The current comp.wxml restarts its local lineage from
-             * i.nn, but l remains part of Taro's intentional depth-reset component contract and platform variants may consume
-             * it. Preserve that upstream binding; only the new Page-root comp starts with the property's empty default. Slot
-             * forwarding lives at this base.wxml call site, and vo already belongs to i, so comp still needs no App/Page mode,
-             * projection property, or Page data.
-             */
-            return taroTemplateBuilder.buildBaseComponentTemplate(ext);
-        },
-        buildCustomComponentTemplate: (ext) => {
-            // CustomWrapper renders its compact children in its own native scope; imported base templates perform dispatch.
-            return taroTemplateBuilder.buildCustomComponentTemplate(ext);
-        },
-        buildPageTemplate: (baseTempPath, page) => {
-            const source = taroTemplateBuilder.buildPageTemplate(baseTempPath, page);
-            /*
-             * The native Page owns both data bindings. app is the transparent single-node adapter rendered by unchanged
-             * comp; the caller-owned taro_tmpl still reads only page and becomes comp's one default slot. A page.* update
-             * therefore cannot enter App template scopes or a component property, while App recursion can place the Page
-             * exactly at {children} by consuming the slot at vpt_page_outlet. The root call omits l because this native comp
-             * starts a fresh lineage scope and its generic property already defaults to the empty string. It also emits no id:
-             * no runtime lookup, event dispatch, ref, or selector addresses this virtual boundary.
-             */
-            return replaceExactlyOnce(source, '<template is="taro_tmpl" data="{{root:root}}" />', `<comp i="{{app}}"><template is="taro_tmpl" data="{{root:page}}" /></comp>`, 'Page template entry');
-        }
-    };
-}
-/** Creates template metadata from reachable Taro hosts, the standard CustomWrapper boundary, and native JSX fields. */
-function collectTemplateComponentConfig(bundle, nativeComponents) {
-    const components = findBundleModule(bundle, taroComponentsModulePath);
-    const renderedComponentNames = (components?.renderedExports ?? []).map(toDashed);
-    return {
-        includes: new Set([
-            'view',
-            'catch-view',
-            'static-view',
-            'pure-view',
-            'click-view',
-            'scroll-view',
-            'image',
-            'static-image',
-            'text',
-            'static-text',
-            ...renderedComponentNames.filter((name) => name !== customWrapperName)
-        ]),
-        exclude: new Set(),
-        thirdPartyComponents: new Map([
-            [customWrapperName, new Set()],
-            ...nativeComponents.map((component) => [component.name, new Set(component.fields)])
-        ]),
-        includeAll: false
-    };
-}
-/** Finds one module in the final chunk metadata. */
-function findBundleModule(bundle, resolvedId) {
-    const normalizedResolvedId = normalizeModuleId(resolvedId);
-    for (const output of Object.values(bundle)) {
-        if (output.type !== 'chunk') {
-            continue;
-        }
-        const found = Object.entries(output.modules).find(([id]) => normalizeModuleId(id) === normalizedResolvedId);
-        if (found) {
-            return found[1];
-        }
-    }
-}
-/** Converts a React component export to Taro's dashed host-component name. */
-function toDashed(value) {
-    return value.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-}
-/** Creates App JSON with generated subpackages. */
-function createAppJson({ options, subpackages }) {
-    return {
-        ...createAppConfig(options),
-        ...(subpackages.length > 0 ? { subPackages: subpackages } : {})
-    };
-}
-/** Creates native registrations for every WXML rendering scope that can instantiate their templates. */
-function createNativeComponentConfig(nativeComponents) {
-    // Cross-package components require a placeholder while WeChat downloads their generated subpackage. Paths are
-    // root-absolute, so remove the leading slash before testing the output-relative subpackage prefix.
-    // https://developers.weixin.qq.com/miniprogram/dev/framework/subpackages/async.html
-    // https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/placeholder.html
-    return {
-        usingComponents: Object.fromEntries(nativeComponents.map(({ name, componentPath }) => [name, componentPath])),
-        componentPlaceholder: Object.fromEntries(nativeComponents.flatMap(({ name, componentPath }) => isGeneratedSubpackageFile(componentPath.slice(1)) ? [[name, 'view']] : []))
-    };
-}
-/** Preserves configured Page JSON and registers its recursive and native component entries. */
-function createPageJson(page, nativeComponentConfig) {
-    const usingComponents = isJsonObject(page.config.usingComponents) ? page.config.usingComponents : {};
-    const componentPlaceholder = isJsonObject(page.config.componentPlaceholder) ? page.config.componentPlaceholder : {};
-    const hasNativeComponentPlaceholder = Object.keys(nativeComponentConfig.componentPlaceholder).length > 0;
-    return {
-        ...page.config,
-        usingComponents: {
-            ...usingComponents,
-            ...nativeComponentConfig.usingComponents,
-            comp: toRootRelativePath(page.path, 'comp'),
-            [customWrapperName]: toRootRelativePath(page.path, customWrapperName)
-        },
-        ...(hasNativeComponentPlaceholder
-            ? {
-                componentPlaceholder: {
-                    ...componentPlaceholder,
-                    ...nativeComponentConfig.componentPlaceholder
-                }
-            }
-            : {})
-    };
-}
-/** Creates the shared recursive component configuration used by comp and CustomWrapper. */
-function createRecursiveComponentJson(nativeComponentConfig) {
-    const hasNativeComponentPlaceholder = Object.keys(nativeComponentConfig.componentPlaceholder).length > 0;
-    return {
-        component: true,
-        styleIsolation: 'apply-shared',
-        usingComponents: {
-            ...nativeComponentConfig.usingComponents,
-            comp: './comp',
-            [customWrapperName]: `./${customWrapperName}`
-        },
-        ...(hasNativeComponentPlaceholder ? { componentPlaceholder: nativeComponentConfig.componentPlaceholder } : {})
-    };
-}
-/** Tests whether a configured JSON value can be merged as an object. */
-function isJsonObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/** Creates compact production JSON and readable development JSON. */
-function createJsonAsset(fileName, value, isProduction) {
-    return createAsset(fileName, isProduction ? JSON.stringify(value) : `${JSON.stringify(value, null, 4)}\n`);
-}
-/** Creates one emitted text asset. */
-function createAsset(fileName, source) {
-    return { type: 'asset', fileName: fileName, source: source };
-}

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

@@ -1,245 +0,0 @@
-import { createHash } from 'node:crypto';
-// Leave headroom below WeChat's 2M subpackage limit for rendered wrappers and native assets.
-export const subpackagePlanningBudget = 1_900_000;
-const generatedSubpackageRootPrefix = 'sub/p_';
-/** Shared main-package value used for every synchronously reachable chunk. */
-const mainPackage = { kind: 'main' };
-/**
- * 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 }) {
-    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()
-    }));
-    const subpackages = packChunks({
-        chunks: placeableChunks,
-        planningBudgetBytes: subpackagePlanningBudget
-    }).map(createPackedSubpackage);
-    // This local map accumulates the immutable plan returned to output materialization.
-    const locationByChunk = new Map();
-    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) {
-        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) {
-        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) {
-            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) {
-            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) {
-            const outputChunks = Object.values(bundle).filter((output) => output.type === 'chunk');
-            // This local mutable set deduplicates typed package owners that retain at least one final output chunk.
-            const roots = new Set();
-            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) {
-    const mainChunkIds = new Set();
-    // 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 }) {
-    const transitionsByChunk = new Map();
-    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();
-                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 }) {
-    const closure = new Set();
-    // 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 }) {
-    const bins = [];
-    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, right) {
-    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 }) {
-    let best;
-    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, right) {
-    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) {
-    const bin = {
-        chunkIds: [],
-        estimatedBytes: 0,
-        transitions: new Set()
-    };
-    bins.push(bin);
-    return bin;
-}
-/** Applies one irreversible, non-duplicating final chunk assignment. */
-function placeChunk(bin, chunk) {
-    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) {
-    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) {
-    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) {
-    return fileName.startsWith(generatedSubpackageRootPrefix);
-}