vite-plugin-taro 0.6.0 → 0.6.2

package/dist/node/plugins/wx/render/system-js/system-js.js

@@ -0,0 +1,602 @@
+import { ScopeTracker, walk } from 'oxc-walker';
+import { RolldownMagicString } from 'rolldown';
+import { parseSync } from 'rolldown/utils';
+import { StringEditor } from './string-editor.js';
+/**
+ * Converts one final Rolldown ES chunk into System.register data without rebuilding its complete AST through Babel.
+ *
+ * The compiler intentionally accepts Rolldown's normalized final-chunk grammar rather than arbitrary source modules. Every
+ * unsupported module declaration fails before source edits begin, so a future Rolldown output change cannot be miscompiled.
+ */
+export function transformSystemJs(options) {
+    const parseResult = parseSync(options.filename, options.code);
+    if (parseResult.errors.length > 0) {
+        const diagnostics = parseResult.errors.map((error) => error.message).join('; ');
+        throw new Error(`Failed to parse ${options.filename} with Oxc: ${diagnostics}`);
+    }
+    // Analysis and validation complete before an editor can publish output. A thrown unsupported-form error therefore fails
+    // the build transaction instead of returning a partially transformed capsule.
+    const model = analyzeModule(parseResult.program, options.filename);
+    if (!options.sourcemap) {
+        const editor = new StringEditor(options.code);
+        applyProgramEdits(editor, model);
+        applyExpressionEdits(editor, model, options);
+        return { code: assembleUnmappedRegistration(editor, model, options), map: null };
+    }
+    const editor = new RolldownMagicString(options.code, { filename: options.filename });
+    applyProgramEdits(editor, model);
+    applyExpressionEdits(editor, model, options);
+    assembleMappedRegistration(editor, model, options);
+    return {
+        code: editor.toString(),
+        map: createSourceMap(editor, options.filename)
+    };
+}
+/** Collects immutable compilation facts before any source range is changed. */
+function analyzeModule(program, filename) {
+    // These journals are mutable only during this one linear analysis pass; all are exposed as readonly compilation facts.
+    const identifierNames = new Set();
+    const exportNamesByLocal = new Map();
+    const dependencyBySource = new Map();
+    const functions = [];
+    const hoistedVariables = [];
+    const importBindings = new Set();
+    const outerBindings = new Set();
+    // Boundary depth excludes declarations and await expressions owned by nested functions or classes from module analysis.
+    let moduleBoundaryDepth = 0;
+    let hasDirectEval = false;
+    let hasTopLevelAwait = false;
+    walk(program, {
+        enter(node, parent) {
+            if (node.type === 'Identifier')
+                identifierNames.add(node.name);
+            if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'eval') {
+                hasDirectEval = true;
+            }
+            if (isModuleBoundary(node))
+                moduleBoundaryDepth += 1;
+            if (node.type === 'AwaitExpression' && moduleBoundaryDepth === 0)
+                hasTopLevelAwait = true;
+            if (node.type === 'VariableDeclaration' && node.kind === 'var' && moduleBoundaryDepth === 0) {
+                const isForIterationBinding = (parent?.type === 'ForInStatement' || parent?.type === 'ForOfStatement') && parent.left === node;
+                hoistedVariables.push({ declaration: node, isForIterationBinding });
+                bindingNamesFromDeclaration(node).forEach((name) => {
+                    outerBindings.add(name);
+                });
+            }
+        },
+        leave(node) {
+            if (isModuleBoundary(node))
+                moduleBoundaryDepth -= 1;
+        }
+    });
+    // Final Rolldown chunks normally expose imports and exports as direct Program children. Declaration exports and
+    // re-exports are intentionally not normalized here because accepting them would expand the semantic surface needlessly.
+    for (const node of program.body) {
+        switch (node.type) {
+            case 'ImportDeclaration':
+                collectImport(node, dependencyBySource, importBindings, outerBindings, filename);
+                break;
+            case 'ExportNamedDeclaration':
+                collectExports(node, exportNamesByLocal, filename);
+                break;
+            case 'ExportDefaultDeclaration':
+            case 'ExportAllDeclaration':
+                throw unsupported(filename, `source-level ${node.type}`);
+            case 'VariableDeclaration':
+                requireSupportedVariableKind(node, filename);
+                node.declarations
+                    .flatMap((declaration) => bindingNames(declaration.id))
+                    .forEach((name) => {
+                    outerBindings.add(name);
+                });
+                break;
+            case 'FunctionDeclaration':
+                if (!node.id || !node.body || node.declare) {
+                    throw unsupported(filename, 'anonymous or ambient function declaration');
+                }
+                functions.push(node);
+                outerBindings.add(node.id.name);
+                break;
+            case 'ClassDeclaration':
+                if (!node.id || node.declare)
+                    throw unsupported(filename, 'anonymous or ambient class declaration');
+                outerBindings.add(node.id.name);
+                break;
+        }
+    }
+    requireNoDirectEval(hasDirectEval, filename);
+    const generatedNames = createGeneratedNames(identifierNames, dependencyBySource.size);
+    validateExportBindings(exportNamesByLocal, outerBindings, filename);
+    const scopes = createFrozenScopes(program);
+    return {
+        dependencies: [...dependencyBySource.values()],
+        exportNamesByLocal,
+        functions,
+        generatedNames,
+        hasTopLevelAwait,
+        hoistedVariables,
+        importBindings,
+        outerBindings,
+        program,
+        scopes
+    };
+}
+/** Merges same-source imports because one SystemJS dependency has exactly one setter. */
+function collectImport(declaration, dependencyBySource, importBindings, outerBindings, filename) {
+    if (declaration.phase || declaration.attributes.length > 0 || declaration.importKind === 'type') {
+        throw unsupported(filename, 'import phases, attributes, or type-only imports');
+    }
+    const source = declaration.source.value;
+    // This map owns one mutable import list per source while declarations are folded; duplicate imports retain source order.
+    const dependency = dependencyBySource.get(source) ?? { source, imports: [] };
+    if (!dependencyBySource.has(source))
+        dependencyBySource.set(source, dependency);
+    for (const specifier of declaration.specifiers) {
+        importBindings.add(specifier.local.name);
+        outerBindings.add(specifier.local.name);
+        switch (specifier.type) {
+            case 'ImportDefaultSpecifier':
+                dependency.imports.push({ imported: 'default', local: specifier.local.name });
+                break;
+            case 'ImportNamespaceSpecifier':
+                dependency.imports.push({ imported: null, local: specifier.local.name });
+                break;
+            case 'ImportSpecifier':
+                if (specifier.importKind === 'type')
+                    throw unsupported(filename, 'type-only import specifier');
+                dependency.imports.push({ imported: moduleExportName(specifier.imported), local: specifier.local.name });
+                break;
+        }
+    }
+}
+/** Records every public alias attached to one local binding. */
+function collectExports(declaration, exportNamesByLocal, filename) {
+    if (declaration.declaration ||
+        declaration.source ||
+        declaration.attributes.length > 0 ||
+        declaration.exportKind === 'type') {
+        throw unsupported(filename, 'declaration exports, re-exports, export attributes, or type-only exports');
+    }
+    for (const specifier of declaration.specifiers) {
+        if (specifier.exportKind === 'type')
+            throw unsupported(filename, 'type-only export specifier');
+        const local = moduleExportName(specifier.local);
+        const exported = moduleExportName(specifier.exported);
+        // Aliases are accumulated in declaration order because nested live-binding calls must publish in the same order as Babel.
+        const names = exportNamesByLocal.get(local) ?? [];
+        names.push(exported);
+        if (!exportNamesByLocal.has(local))
+            exportNamesByLocal.set(local, names);
+    }
+}
+/** Rejects exports outside the direct normalized module cells supported by final Rolldown chunks. */
+function validateExportBindings(exportNamesByLocal, outerBindings, filename) {
+    for (const local of exportNamesByLocal.keys()) {
+        if (!outerBindings.has(local)) {
+            throw unsupported(filename, `export of non-module binding ${JSON.stringify(local)}`);
+        }
+    }
+}
+/** Applies declaration-level edits whose semantics are known from direct Program children. */
+function applyProgramEdits(editor, model) {
+    for (const node of model.program.body) {
+        switch (node.type) {
+            case 'ImportDeclaration':
+                editor.remove(node.start, node.end);
+                break;
+            case 'ExportNamedDeclaration':
+                editor.overwrite(node.start, node.end, renderImportedExports(node.specifiers, model));
+                break;
+            case 'VariableDeclaration':
+                transformTopLevelVariables(editor, node, model.generatedNames.exportBinding, model.exportNamesByLocal);
+                break;
+            case 'ClassDeclaration':
+                transformTopLevelClass(editor, node, model.generatedNames.exportBinding, model.exportNamesByLocal);
+                break;
+        }
+    }
+    const directDeclarations = new Set(model.program.body.flatMap((node) => (node.type === 'VariableDeclaration' ? [node] : [])));
+    model.hoistedVariables
+        .filter(({ declaration }) => !directDeclarations.has(declaration))
+        .forEach(({ declaration, isForIterationBinding }) => {
+        transformNestedHoistedVariables(editor, declaration, isForIterationBinding, model.generatedNames.exportBinding, model.exportNamesByLocal);
+    });
+}
+/** Changes module variables into assignments to declaration-scope cells shared with setters and hoisted functions. */
+function transformTopLevelVariables(editor, declaration, exportBinding, exportNamesByLocal) {
+    const [first] = declaration.declarations;
+    if (!first) {
+        editor.remove(declaration.start, declaration.end);
+        return;
+    }
+    // `const value = init` becomes `(value = init)`: the declaration cell itself is emitted once in the registration scope.
+    editor.overwrite(declaration.start, first.start, '(');
+    editor.appendLeft(statementTerminatorStart(editor.original, declaration.end), ')');
+    transformVariableInitializers(editor, declaration, exportBinding, exportNamesByLocal);
+}
+/** Hoists module-scoped var declarations nested in statements without changing their control-flow position. */
+function transformNestedHoistedVariables(editor, declaration, isForIterationBinding, exportBinding, exportNamesByLocal) {
+    const [first] = declaration.declarations;
+    if (!first) {
+        editor.remove(declaration.start, declaration.end);
+        return;
+    }
+    editor.overwrite(declaration.start, first.start, isForIterationBinding ? '' : '(');
+    if (!isForIterationBinding)
+        editor.appendLeft(statementTerminatorStart(editor.original, declaration.end), ')');
+    transformVariableInitializers(editor, declaration, exportBinding, exportNamesByLocal);
+}
+/** Publishes initialized exported cells at the exact initializer evaluation point. */
+function transformVariableInitializers(editor, declaration, exportBinding, exportNamesByLocal) {
+    for (const declarator of declaration.declarations) {
+        if (!declarator.init)
+            continue;
+        const exportedBindings = bindingNames(declarator.id).flatMap((name) => (exportNamesByLocal.get(name) ?? []).map((exported) => ({ exported, local: name })));
+        if (exportedBindings.length === 0)
+            continue;
+        if (declarator.id.type === 'Identifier') {
+            // Nested calls publish every alias while preserving the initializer's completion value.
+            const names = exportNamesByLocal.get(declarator.id.name) ?? [];
+            editor.prependLeft(declarator.start, exportExpressionPrefix(exportBinding, names, ''));
+            editor.appendRight(declarator.end, exportExpressionSuffix(names));
+            continue;
+        }
+        editor.prependLeft(declarator.start, '(');
+        editor.appendRight(declarator.end, `,${exportedBindings.map(({ exported, local }) => exportCall(exportBinding, exported, local)).join(',')})`);
+    }
+}
+/** Turns a class declaration into the execute-time assignment required by cyclic SystemJS linking. */
+function transformTopLevelClass(editor, declaration, exportBinding, exportNamesByLocal) {
+    if (!declaration.id)
+        return;
+    const names = exportNamesByLocal.get(declaration.id.name) ?? [];
+    editor.prependLeft(declaration.start, exportExpressionPrefix(exportBinding, names, `${declaration.id.name}=`));
+    editor.appendRight(declaration.end, exportExpressionSuffix(names));
+}
+/** Rewrites expression-level module semantics in one scope-aware O(n) traversal. */
+function applyExpressionEdits(editor, model, options) {
+    const scopes = model.scopes;
+    // Function and class depth are mutable traversal cursors used only to identify lexical module `this` and top-level await.
+    let thisBoundaryDepth = 0;
+    walk(model.program, {
+        scopeTracker: scopes,
+        enter(node) {
+            if (isThisBoundary(node))
+                thisBoundaryDepth += 1;
+            switch (node.type) {
+                case 'ImportExpression':
+                    // SystemJS owns dynamic loading; only string literals are canonicalized at build time.
+                    if (node.options || node.phase)
+                        throw unsupported(options.filename, 'dynamic import options or phases');
+                    editor.overwrite(node.start, node.source.start, `${model.generatedNames.context}.import(`);
+                    if (node.source.type === 'Literal' && typeof node.source.value === 'string') {
+                        editor.overwrite(node.source.start, node.source.end, JSON.stringify(options.resolveReference(node.source.value, 'dynamic')));
+                    }
+                    break;
+                case 'MetaProperty':
+                    if (node.meta.name === 'import' && node.property.name === 'meta') {
+                        editor.overwrite(node.start, node.end, `${model.generatedNames.context}.meta`);
+                    }
+                    break;
+                case 'ThisExpression':
+                    // ESM top-level `this` is undefined. Arrow functions inherit it, while normal functions/classes do not.
+                    if (thisBoundaryDepth === 0)
+                        editor.overwrite(node.start, node.end, 'void 0');
+                    break;
+                case 'AssignmentExpression':
+                    transformAssignment(editor, node.left, node.start, node.end, scopes, model, options.filename);
+                    break;
+                case 'UpdateExpression':
+                    transformUpdate(editor, node, scopes, model);
+                    break;
+                case 'ForInStatement':
+                case 'ForOfStatement':
+                    if (node.left.type !== 'VariableDeclaration') {
+                        requireNoExportedPattern(node.left, scopes, model.exportNamesByLocal, options.filename);
+                    }
+                    break;
+            }
+        },
+        leave(node) {
+            if (isThisBoundary(node))
+                thisBoundaryDepth -= 1;
+        }
+    });
+}
+/** Wraps one assignment when its target is an exported root binding. */
+function transformAssignment(editor, target, start, end, scopes, model, filename) {
+    if (target.type === 'Identifier') {
+        const names = exportedRootNames(target.name, scopes, model.exportNamesByLocal);
+        if (names.length === 0)
+            return;
+        editor.prependLeft(start, exportExpressionPrefix(model.generatedNames.exportBinding, names, ''));
+        editor.appendRight(end, exportExpressionSuffix(names));
+        return;
+    }
+    requireNoExportedPattern(target, scopes, model.exportNamesByLocal, filename);
+}
+/** Preserves prefix and postfix update values while publishing the next live binding. */
+function transformUpdate(editor, update, scopes, model) {
+    if (update.argument.type !== 'Identifier')
+        return;
+    const names = exportedRootNames(update.argument.name, scopes, model.exportNamesByLocal);
+    if (names.length === 0)
+        return;
+    if (update.prefix) {
+        editor.prependLeft(update.start, exportExpressionPrefix(model.generatedNames.exportBinding, names, ''));
+        editor.appendRight(update.end, exportExpressionSuffix(names));
+        return;
+    }
+    // A postfix expression must return the old value, so publish the computed next cell before evaluating the original update.
+    const nextValue = `+${update.argument.name}${update.operator[0]}1`;
+    editor.prependLeft(update.start, `(${nestedExportExpression(model.generatedNames.exportBinding, names, nextValue)},`);
+    editor.appendRight(update.end, ')');
+}
+/** Fails rather than silently changing the completion value of an exported destructuring assignment. */
+function requireNoExportedPattern(target, scopes, exportNamesByLocal, filename) {
+    const exported = assignmentNames(target).filter((name) => exportedRootNames(name, scopes, exportNamesByLocal).length > 0);
+    if (exported.length > 0) {
+        throw unsupported(filename, `destructuring write to exported binding ${JSON.stringify(exported[0])}`);
+    }
+}
+/** Renders the no-map fast path through one source-order edit journal. */
+function assembleUnmappedRegistration(editor, model, options) {
+    const shell = createRegistrationShell(model, options);
+    const hoistedFunctions = model.functions
+        .map((declaration) => editor.render(declaration.start, declaration.end))
+        .join('');
+    model.functions.forEach((declaration) => {
+        editor.remove(declaration.start, declaration.end);
+    });
+    return `${shell.prefix}${editor.render(0, editor.original.length)}}};${hoistedFunctions}${shell.suffix}`;
+}
+/** Places mapped hoisted functions after the declaration return while retaining every original source segment. */
+function assembleMappedRegistration(editor, model, options) {
+    const shell = createRegistrationShell(model, options);
+    // Relocation preserves source-map ownership for large hoisted function bodies when callers explicitly request maps.
+    for (const declaration of model.functions)
+        editor.move(declaration.start, declaration.end, editor.original.length);
+    editor.prepend(shell.prefix);
+    editor.prependLeft(editor.original.length, '}};');
+    editor.append(shell.suffix);
+}
+/** Creates the generated registration boundary shared by mapped and unmapped rendering. */
+function createRegistrationShell(model, options) {
+    const dependencies = model.dependencies.map((dependency) => options.resolveReference(dependency.source, 'static'));
+    const setters = model.dependencies.map((dependency, index) => renderSetter(dependency, index, model.generatedNames));
+    const earlyExports = renderEarlyExports(model);
+    const declarations = model.outerBindings.size > 0 ? `var ${[...model.outerBindings].join(',')};` : '';
+    const execute = model.hasTopLevelAwait ? 'async function' : 'function';
+    // Imports, hoisted cells, and cyclically visible exports belong to declaration/link time. Original executable statements
+    // remain inside execute(), which becomes async only when the module itself owns a top-level await.
+    const declarationStart = `function(${model.generatedNames.exportBinding},${model.generatedNames.context}){"use strict";${declarations}${earlyExports}return {setters:[${setters.join(',')}],execute:${execute}(){`;
+    return options.format === 'system-register'
+        ? {
+            prefix: `System.register(${JSON.stringify(dependencies)},${declarationStart}`,
+            suffix: '})'
+        }
+        : {
+            prefix: `module.exports=[${JSON.stringify(dependencies)},${declarationStart}`,
+            suffix: '}]'
+        };
+}
+/** Produces declaration-time exports for functions and uninitialized variables, matching cyclic ESM availability. */
+function renderEarlyExports(model) {
+    const functionNames = new Set(model.functions.flatMap((declaration) => (declaration.id ? [declaration.id.name] : [])));
+    const directVariables = model.program.body.flatMap((node) => (node.type === 'VariableDeclaration' ? [node] : []));
+    const nestedHoistedVariables = model.hoistedVariables
+        .map(({ declaration }) => declaration)
+        .filter((declaration) => !directVariables.includes(declaration));
+    const variablesInSourceOrder = [...directVariables, ...nestedHoistedVariables].sort((left, right) => left.start - right.start);
+    const entries = [];
+    for (const [local, exportedNames] of model.exportNamesByLocal) {
+        if (!functionNames.has(local))
+            continue;
+        for (const exported of exportedNames)
+            entries.push({ exported, value: local });
+    }
+    for (const declaration of variablesInSourceOrder) {
+        for (const declarator of declaration.declarations) {
+            if (declarator.init)
+                continue;
+            for (const local of bindingNames(declarator.id)) {
+                for (const exported of model.exportNamesByLocal.get(local) ?? []) {
+                    entries.push({ exported, value: 'void 0' });
+                }
+            }
+        }
+    }
+    if (entries.length === 0)
+        return '';
+    if (entries.length === 1) {
+        const [entry] = entries;
+        return exportCallWith(model.generatedNames.exportBinding, entry.exported, entry.value);
+    }
+    const properties = entries.map(({ exported, value }) => `[${JSON.stringify(exported)}]:${value}`).join(',');
+    return `${model.generatedNames.exportBinding}({${properties}});`;
+}
+/** Keeps Babel's execute-time publication point for imported locals named by a final export list. */
+function renderImportedExports(specifiers, model) {
+    return specifiers
+        .filter((specifier) => model.importBindings.has(moduleExportName(specifier.local)))
+        .map((specifier) => {
+        const local = moduleExportName(specifier.local);
+        return exportCallWith(model.generatedNames.exportBinding, moduleExportName(specifier.exported), local);
+    })
+        .join('');
+}
+/** Creates one dependency setter with the import cells consumed by execute-time code. */
+function renderSetter(dependency, index, names) {
+    const moduleName = `${names.dependencyPrefix}${index}`;
+    const statements = dependency.imports.flatMap((binding) => {
+        const importedValue = binding.imported === null ? moduleName : memberExpression(moduleName, binding.imported);
+        return [`${binding.local}=${importedValue};`];
+    });
+    return `function(${moduleName}){${statements.join('')}}`;
+}
+/** Selects aliases only when the current traversal reference resolves to the root module declaration. */
+function exportedRootNames(local, scopes, exportNamesByLocal) {
+    const names = exportNamesByLocal.get(local) ?? [];
+    if (names.length === 0)
+        return names;
+    const declaration = scopes.getDeclaration(local);
+    return declaration?.scope === '' ? names : [];
+}
+/** Builds the opening calls around an expression that follows directly in the original source. */
+function exportExpressionPrefix(exportBinding, names, expressionPrefix) {
+    if (names.length === 0)
+        return expressionPrefix;
+    return names.reduce((prefix, exported) => `${exportCallPrefix(exportBinding, exported)}${prefix}`, expressionPrefix);
+}
+/** Closes nested export calls opened by exportExpressionPrefix. */
+function exportExpressionSuffix(names) {
+    return ')'.repeat(names.length);
+}
+/** Renders nested export calls around a generated expression. */
+function nestedExportExpression(exportBinding, names, expression) {
+    return names.reduce((value, exported) => `${exportCallPrefix(exportBinding, exported)}${value})`, expression);
+}
+/** Opens an export notification around an original expression whose source text follows. */
+function exportCallPrefix(exportBinding, exported) {
+    return `${exportBinding}(${JSON.stringify(exported)},`;
+}
+/** Emits an export notification expression without imposing statement boundaries. */
+function exportCall(exportBinding, exported, value) {
+    return `${exportBinding}(${JSON.stringify(exported)},${value})`;
+}
+/** Emits a complete export notification statement. */
+function exportCallWith(exportBinding, exported, value) {
+    return `${exportBinding}(${JSON.stringify(exported)},${value});`;
+}
+/** Creates collision-free identifiers without requiring Babel's scope allocator. */
+function createGeneratedNames(identifierNames, dependencyCount) {
+    // The used-name set is locally mutable because each selected helper reserves its name for the next helper.
+    const used = new Set(identifierNames);
+    const take = (base) => {
+        // The suffix cursor advances only on an actual source collision and never escapes this allocation call.
+        let suffix = 0;
+        let candidate = base;
+        while (used.has(candidate)) {
+            suffix += 1;
+            candidate = `${base}${suffix}`;
+        }
+        used.add(candidate);
+        return candidate;
+    };
+    const takeDependencyPrefix = (base) => {
+        // Prefix selection tests every concrete setter argument because the unsuffixed base may itself be collision-free.
+        let suffix = 0;
+        let candidate = base;
+        while (Array.from({ length: dependencyCount }, (_, index) => `${candidate}${index}`).some((name) => used.has(name))) {
+            suffix += 1;
+            candidate = `${base}${suffix}`;
+        }
+        Array.from({ length: dependencyCount }, (_, index) => `${candidate}${index}`).forEach((name) => {
+            used.add(name);
+        });
+        return candidate;
+    };
+    return {
+        context: take('__systemContext'),
+        exportBinding: take('__systemExport'),
+        dependencyPrefix: takeDependencyPrefix('__systemDependency')
+    };
+}
+/** Builds and freezes complete lexical declarations for scope-correct write detection. */
+function createFrozenScopes(program) {
+    // ScopeTracker is intentionally mutable during its declaration pass, then frozen before every query traversal.
+    const scopes = new ScopeTracker({ preserveExitedScopes: true });
+    walk(program, { scopeTracker: scopes });
+    scopes.freeze();
+    return scopes;
+}
+/** Normalizes identifier and quoted module names to the runtime property string. */
+function moduleExportName(name) {
+    return name.type === 'Literal' ? String(name.value) : name.name;
+}
+/** Uses dot access only when the imported name is a valid identifier. */
+function memberExpression(object, property) {
+    return /^[$A-Z_a-z][$\w]*$/.test(property) ? `${object}.${property}` : `${object}[${JSON.stringify(property)}]`;
+}
+function bindingNamesFromDeclaration(declaration) {
+    return declaration.declarations.flatMap((declarator) => bindingNames(declarator.id));
+}
+function bindingNames(pattern) {
+    return patternNames(pattern);
+}
+function assignmentNames(pattern) {
+    return patternNames(pattern);
+}
+/** Extracts identifiers from binding and assignment patterns without treating computed keys as targets. */
+function patternNames(pattern) {
+    switch (pattern.type) {
+        case 'Identifier':
+            return [pattern.name];
+        case 'AssignmentPattern':
+            return patternNames(pattern.left);
+        case 'ArrayPattern':
+            return pattern.elements.flatMap((element) => (element ? patternNames(element) : []));
+        case 'ObjectPattern':
+            return pattern.properties.flatMap((property) => property.type === 'Property' ? patternNames(property.value) : patternNames(property.argument));
+        case 'RestElement':
+            return patternNames(pattern.argument);
+        case 'TSAsExpression':
+        case 'TSSatisfiesExpression':
+        case 'TSNonNullExpression':
+        case 'TSTypeAssertion':
+            return patternNames(pattern.expression);
+        default:
+            return [];
+    }
+}
+function isFunction(node) {
+    return (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression' ||
+        node.type === 'TSEmptyBodyFunctionExpression');
+}
+function isModuleBoundary(node) {
+    return isFunction(node) || node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
+}
+function isThisBoundary(node) {
+    return ((isFunction(node) && node.type !== 'ArrowFunctionExpression') ||
+        node.type === 'ClassDeclaration' ||
+        node.type === 'ClassExpression');
+}
+/** Babel rejects direct eval for SystemJS because renaming declaration cells cannot update evaluated source. */
+function requireNoDirectEval(hasDirectEval, filename) {
+    if (hasDirectEval)
+        throw unsupported(filename, 'direct eval');
+}
+function requireSupportedVariableKind(declaration, filename) {
+    if (declaration.kind === 'using' || declaration.kind === 'await using' || declaration.declare) {
+        throw unsupported(filename, 'using or ambient variable declaration');
+    }
+}
+/** Places a closing edit before an optional semicolon owned by the declaration node. */
+function statementTerminatorStart(code, end) {
+    return code[end - 1] === ';' ? end - 1 : end;
+}
+/** Makes a future Rolldown grammar change fail closed with the affected chunk named. */
+function unsupported(filename, construct) {
+    return new Error(`Unsupported final Rolldown chunk ${filename}: ${construct}`);
+}
+/** Produces a Vite-compatible raw map that retains the complete pre-transform chunk as source content. */
+function createSourceMap(editor, filename) {
+    const generated = editor.generateMap({
+        file: filename,
+        hires: 'boundary',
+        includeContent: true,
+        source: filename
+    });
+    return {
+        version: generated.version,
+        file: generated.file,
+        sources: generated.sources,
+        sourcesContent: generated.sourcesContent,
+        names: generated.names,
+        mappings: generated.mappings,
+        ...(generated.x_google_ignoreList ? { x_google_ignoreList: generated.x_google_ignoreList } : {})
+    };
+}

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>;