@wyw-in-js/transform 2.0.0-alpha.0 → 2.0.0

package/types/transform/generators/resolveStaticOxcValues/programAnalysis.js

@@ -0,0 +1,133 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { collectImportBindings, isSafeLiteral, unwrapExpression, } from './staticExpression';
+export const collectLocalConstExpressions = (program) => {
+    const result = new Map();
+    const collect = (declaration) => {
+        if (declaration.kind !== 'const') {
+            return;
+        }
+        declaration.declarations.forEach((declarator) => {
+            if (declarator.id.type === 'Identifier' && declarator.init) {
+                result.set(declarator.id.name, declarator.init);
+            }
+        });
+    };
+    program.body.forEach((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            collect(statement);
+            return;
+        }
+        if (statement.type === 'ExportNamedDeclaration' &&
+            statement.declaration?.type === 'VariableDeclaration') {
+            collect(statement.declaration);
+        }
+    });
+    return result;
+};
+export const objectPropertyKeyName = (node) => {
+    const unwrapped = unwrapExpression(node);
+    if (unwrapped.type === 'Identifier') {
+        return unwrapped.name;
+    }
+    if (isSafeLiteral(unwrapped) && typeof unwrapped.value === 'string') {
+        return unwrapped.value;
+    }
+    return null;
+};
+export const findObjectPropertyValue = (expr, name) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'ObjectExpression') {
+        return null;
+    }
+    for (const property of unwrapped.properties) {
+        if (property.type === 'SpreadElement') {
+            continue;
+        }
+        const propertyNode = property;
+        if (propertyNode.computed) {
+            continue;
+        }
+        const key = propertyNode.key;
+        const value = propertyNode.value;
+        if (key && value && objectPropertyKeyName(key) === name) {
+            return value;
+        }
+    }
+    return null;
+};
+export const topLevelStatements = (program) => {
+    const result = [];
+    program.body.forEach((statement) => {
+        if (statement.type === 'ExportNamedDeclaration' ||
+            statement.type === 'ExportDefaultDeclaration') {
+            result.push(statement.declaration ?? statement);
+            return;
+        }
+        result.push(statement);
+    });
+    return result;
+};
+export const findTopLevelConstExpression = (program, name) => {
+    for (const statement of topLevelStatements(program)) {
+        if (statement.type !== 'VariableDeclaration' ||
+            statement.kind !== 'const') {
+            continue;
+        }
+        for (const declarator of statement.declarations) {
+            if (declarator.id.type === 'Identifier' &&
+                declarator.id.name === name &&
+                declarator.init) {
+                return declarator.init;
+            }
+        }
+    }
+    return null;
+};
+export const hasTopLevelBinding = (program, name) => {
+    if (collectImportBindings(program).has(name)) {
+        return true;
+    }
+    return topLevelStatements(program).some((statement) => {
+        if (statement.type === 'VariableDeclaration') {
+            return statement.declarations.some((declarator) => declarator.id.type === 'Identifier' && declarator.id.name === name);
+        }
+        if (statement.type === 'FunctionDeclaration') {
+            return statement.id?.name === name;
+        }
+        if (statement.type === 'ClassDeclaration') {
+            return statement.id?.name === name;
+        }
+        return false;
+    });
+};
+export const isTopLevelFunctionOrClass = (program, name) => topLevelStatements(program).some((statement) => {
+    if (statement.type === 'FunctionDeclaration') {
+        return statement.id?.name === name;
+    }
+    if (statement.type === 'ClassDeclaration') {
+        return statement.id?.name === name;
+    }
+    return false;
+});
+export const functionReturnExpression = (expr, options = {}) => {
+    const unwrapped = unwrapExpression(expr);
+    if (unwrapped.type !== 'ArrowFunctionExpression' &&
+        unwrapped.type !== 'FunctionExpression') {
+        return null;
+    }
+    if (unwrapped.async ||
+        (!options.allowParams && unwrapped.params.length > 0) ||
+        !unwrapped.body) {
+        return null;
+    }
+    if (unwrapped.body.type !== 'BlockStatement') {
+        return unwrapped.body;
+    }
+    if (unwrapped.body.body.length !== 1) {
+        return null;
+    }
+    const [statement] = unwrapped.body.body;
+    return statement.type === 'ReturnStatement' && statement.argument
+        ? statement.argument
+        : null;
+};

package/types/transform/generators/resolveStaticOxcValues/prune.d.ts

@@ -0,0 +1,15 @@
+import type { ImportDeclaration, Node, Program } from 'oxc-parser';
+export declare const isIdentifierBindingPosition: (node: Node, parent: Node | null) => boolean;
+export declare const isPropertyKeyOnlyIdentifier: (node: Node, parent: Node | null) => boolean;
+export declare const collectUsedIdentifierNames: (program: Program) => Set<string>;
+export declare const removableStaticHelperNames: (program: Program, staticValueNames: Set<string>) => Set<string>;
+export declare const collectImportLocalReferences: (node: Node, importLocals: Set<string>, result: Set<string>) => void;
+export declare const removeStaticHelperDeclarations: (code: string, filename: string, staticValueNames: Set<string>) => {
+    code: string;
+    removed: Set<string>;
+    removedImportLocals: Set<string>;
+};
+export declare const importSpecifierLocalName: (specifier: ImportDeclaration["specifiers"][number]) => string | null;
+export declare const removeUnusedStaticImports: (code: string, filename: string, staticImportLocals: Set<string>, sideEffectImportLocals: Set<string>, sideEffectImportOrderLocals?: Set<string>) => string;
+export declare const replaceStaticWYWMetaExtendsHelpers: (code: string, filename: string, helperValues: Map<string, unknown>) => string;
+export declare const pruneStaticPreevalCode: (code: string, filename: string, staticValueNames: Set<string>, staticImportLocals: Set<string>, staticExtendsHelperValues: Map<string, unknown>, sideEffectImportLocals: Set<string>) => string;

package/types/transform/generators/resolveStaticOxcValues/prune.js

@@ -0,0 +1,312 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { getOxcNodeChildren } from '../../../utils/oxc/ast';
+import { applyOxcReplacements } from '../../../utils/oxc/replacements';
+import { parseProgram } from './environment';
+import { collectImportBindings, unwrapExpression } from './staticExpression';
+import { findWYWMetaExtendsExpression, staticWYWMetaExtendsReplacementCode, } from './processorStaticModel';
+export const isIdentifierBindingPosition = (node, parent) => {
+    if (node.type !== 'Identifier' || !parent) {
+        return false;
+    }
+    if ((parent.type === 'VariableDeclarator' && parent.id === node) ||
+        (parent.type === 'FunctionDeclaration' && parent.id === node) ||
+        (parent.type === 'FunctionExpression' && parent.id === node) ||
+        (parent.type === 'ClassDeclaration' && parent.id === node) ||
+        (parent.type === 'ClassExpression' && parent.id === node)) {
+        return true;
+    }
+    if ((parent.type === 'ArrowFunctionExpression' ||
+        parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression') &&
+        parent.params.some((param) => param === node)) {
+        return true;
+    }
+    return ((parent.type === 'ImportSpecifier' && parent.local === node) ||
+        (parent.type === 'ImportDefaultSpecifier' && parent.local === node) ||
+        (parent.type === 'ImportNamespaceSpecifier' && parent.local === node));
+};
+export const isPropertyKeyOnlyIdentifier = (node, parent) => node.type === 'Identifier' &&
+    !!parent &&
+    ((parent.type === 'MemberExpression' &&
+        parent.property === node &&
+        !parent.computed) ||
+        (parent.type === 'Property' &&
+            parent.key === node &&
+            !parent.computed &&
+            !parent.shorthand));
+export const collectUsedIdentifierNames = (program) => {
+    const used = new Set();
+    const walk = (node, parent) => {
+        if (node.type === 'ImportDeclaration') {
+            return;
+        }
+        if (node.type === 'Identifier' &&
+            !isIdentifierBindingPosition(node, parent) &&
+            !isPropertyKeyOnlyIdentifier(node, parent)) {
+            used.add(node.name);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(program, null);
+    return used;
+};
+export const removableStaticHelperNames = (program, staticValueNames) => {
+    const used = collectUsedIdentifierNames(program);
+    const result = new Set();
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration') {
+            return;
+        }
+        statement.declarations.forEach((declarator) => {
+            if (declarator.id.type === 'Identifier' &&
+                staticValueNames.has(declarator.id.name) &&
+                !used.has(declarator.id.name)) {
+                result.add(declarator.id.name);
+            }
+        });
+    });
+    return result;
+};
+export const collectImportLocalReferences = (node, importLocals, result) => {
+    const walk = (item, parent) => {
+        if (item.type === 'Identifier' &&
+            importLocals.has(item.name) &&
+            !isIdentifierBindingPosition(item, parent) &&
+            !isPropertyKeyOnlyIdentifier(item, parent)) {
+            result.add(item.name);
+        }
+        getOxcNodeChildren(item).forEach((child) => walk(child, item));
+    };
+    walk(node, null);
+};
+export const removeStaticHelperDeclarations = (code, filename, staticValueNames) => {
+    if (staticValueNames.size === 0) {
+        return { code, removed: new Set(), removedImportLocals: new Set() };
+    }
+    const program = parseProgram(code, filename);
+    const removableNames = removableStaticHelperNames(program, staticValueNames);
+    const importLocals = new Set();
+    collectImportBindings(program).forEach((_, local) => importLocals.add(local));
+    const removedImportLocals = new Set();
+    const ranges = [];
+    const replacements = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration' ||
+            statement.declarations.length === 0) {
+            return;
+        }
+        const removableIndexes = statement.declarations.flatMap((declarator, index) => declarator.id.type === 'Identifier' &&
+            removableNames.has(declarator.id.name)
+            ? [index]
+            : []);
+        if (removableIndexes.length === 0) {
+            return;
+        }
+        removableIndexes.forEach((index) => {
+            collectImportLocalReferences(statement.declarations[index], importLocals, removedImportLocals);
+        });
+        if (removableIndexes.length === statement.declarations.length) {
+            ranges.push({
+                end: statement.end,
+                start: statement.start,
+            });
+            return;
+        }
+        const keptDeclarations = statement.declarations
+            .filter((_, index) => !removableIndexes.includes(index))
+            .map((declarator) => code.slice(declarator.start, declarator.end));
+        replacements.push({
+            end: statement.end,
+            start: statement.start,
+            text: `${statement.kind} ${keptDeclarations.join(', ')};`,
+        });
+    });
+    return {
+        code: applyOxcReplacements(code, [
+            ...ranges.map((range) => ({ ...range, text: '' })),
+            ...replacements,
+        ]),
+        removed: removableNames,
+        removedImportLocals,
+    };
+};
+export const importSpecifierLocalName = (specifier) => specifier.local?.name ?? null;
+export const removeUnusedStaticImports = (code, filename, staticImportLocals, sideEffectImportLocals, sideEffectImportOrderLocals = sideEffectImportLocals) => {
+    if (staticImportLocals.size === 0) {
+        return code;
+    }
+    const program = parseProgram(code, filename);
+    const used = collectUsedIdentifierNames(program);
+    const ranges = [];
+    const replacements = [];
+    const importSourceByLocal = new Map();
+    const removedSideEffectImportRanges = [];
+    const keptImportRangesBySource = new Map();
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration' ||
+            statement.specifiers.length === 0) {
+            return;
+        }
+        const source = code.slice(statement.source.start, statement.source.end);
+        const orderedLocalNames = statement.specifiers.flatMap((specifier) => {
+            const localName = importSpecifierLocalName(specifier);
+            return localName && sideEffectImportOrderLocals.has(localName)
+                ? [localName]
+                : [];
+        });
+        const sideEffectLocalNames = statement.specifiers.flatMap((specifier) => {
+            const localName = importSpecifierLocalName(specifier);
+            return localName && sideEffectImportLocals.has(localName)
+                ? [localName]
+                : [];
+        });
+        [...orderedLocalNames, ...sideEffectLocalNames].forEach((localName) => {
+            importSourceByLocal.set(localName, source);
+        });
+        const removable = statement.specifiers.flatMap((specifier, index) => {
+            const localName = importSpecifierLocalName(specifier);
+            return localName &&
+                staticImportLocals.has(localName) &&
+                !used.has(localName)
+                ? [{ index, localName }]
+                : [];
+        });
+        if (removable.length === 0) {
+            if (orderedLocalNames.length > 0 &&
+                !keptImportRangesBySource.has(source)) {
+                keptImportRangesBySource.set(source, {
+                    end: statement.end,
+                    start: statement.start,
+                });
+            }
+            return;
+        }
+        if (removable.length === statement.specifiers.length) {
+            if (removable.some((item) => sideEffectImportLocals.has(item.localName))) {
+                removedSideEffectImportRanges.push({
+                    end: statement.end,
+                    start: statement.start,
+                });
+                return;
+            }
+            ranges.push({
+                end: statement.end,
+                start: statement.start,
+            });
+            return;
+        }
+        if (orderedLocalNames.length > 0 && !keptImportRangesBySource.has(source)) {
+            keptImportRangesBySource.set(source, {
+                end: statement.end,
+                start: statement.start,
+            });
+        }
+    });
+    if (removedSideEffectImportRanges.length > 0) {
+        const seenSources = new Set();
+        const removedRanges = removedSideEffectImportRanges.sort((a, b) => a.start - b.start);
+        const [firstRemoved, ...restRemoved] = removedRanges;
+        const pendingImports = [];
+        let insertionAfterLastKept = null;
+        let usedFirstRemovedRange = false;
+        const flushBefore = (position) => {
+            if (pendingImports.length === 0) {
+                return;
+            }
+            replacements.push({
+                end: position,
+                start: position,
+                text: `${pendingImports.join('\n')}\n`,
+            });
+            pendingImports.length = 0;
+        };
+        [...sideEffectImportOrderLocals].forEach((local) => {
+            const source = importSourceByLocal.get(local);
+            if (!source) {
+                return;
+            }
+            const keptRange = keptImportRangesBySource.get(source);
+            if (keptRange) {
+                flushBefore(keptRange.start);
+                insertionAfterLastKept = keptRange.end;
+                if (sideEffectImportLocals.has(local)) {
+                    seenSources.add(source);
+                }
+                return;
+            }
+            if (!sideEffectImportLocals.has(local) || seenSources.has(source)) {
+                return;
+            }
+            seenSources.add(source);
+            pendingImports.push(`import ${source};`);
+        });
+        if (pendingImports.length > 0) {
+            if (insertionAfterLastKept !== null) {
+                replacements.push({
+                    end: insertionAfterLastKept,
+                    start: insertionAfterLastKept,
+                    text: `\n${pendingImports.join('\n')}`,
+                });
+            }
+            else if (firstRemoved) {
+                usedFirstRemovedRange = true;
+                replacements.push({
+                    end: firstRemoved.end,
+                    start: firstRemoved.start,
+                    text: pendingImports.join('\n'),
+                });
+            }
+        }
+        ranges.push(...(usedFirstRemovedRange ? restRemoved : removedRanges));
+    }
+    if (ranges.length > 1) {
+        ranges.sort((a, b) => a.start - b.start);
+    }
+    return applyOxcReplacements(code, [
+        ...ranges.map((range) => ({ ...range, text: '' })),
+        ...replacements,
+    ]);
+};
+export const replaceStaticWYWMetaExtendsHelpers = (code, filename, helperValues) => {
+    if (helperValues.size === 0) {
+        return code;
+    }
+    const program = parseProgram(code, filename);
+    const replacements = [];
+    const visit = (node) => {
+        if (node.type === 'ObjectExpression') {
+            const extendsExpression = findWYWMetaExtendsExpression(node);
+            if (extendsExpression) {
+                const unwrapped = unwrapExpression(extendsExpression);
+                if (unwrapped.type === 'CallExpression' &&
+                    unwrapped.callee.type === 'Identifier' &&
+                    unwrapped.arguments.length === 0 &&
+                    helperValues.has(unwrapped.callee.name)) {
+                    const replacement = staticWYWMetaExtendsReplacementCode(helperValues.get(unwrapped.callee.name));
+                    if (replacement) {
+                        replacements.push({
+                            end: extendsExpression.end,
+                            start: extendsExpression.start,
+                            text: replacement,
+                        });
+                    }
+                }
+            }
+        }
+        getOxcNodeChildren(node).forEach(visit);
+    };
+    visit(program);
+    return applyOxcReplacements(code, replacements);
+};
+export const pruneStaticPreevalCode = (code, filename, staticValueNames, staticImportLocals, staticExtendsHelperValues, sideEffectImportLocals) => {
+    const codeWithMetadataPruned = replaceStaticWYWMetaExtendsHelpers(code, filename, staticExtendsHelperValues);
+    const helpersRemoved = removeStaticHelperDeclarations(codeWithMetadataPruned, filename, staticValueNames);
+    if (helpersRemoved.removed.size === 0) {
+        return codeWithMetadataPruned;
+    }
+    const importLocalsToPrune = new Set([
+        ...staticImportLocals,
+        ...helpersRemoved.removedImportLocals,
+    ]);
+    return removeUnusedStaticImports(helpersRemoved.code, filename, importLocalsToPrune, sideEffectImportLocals, new Set([...staticImportLocals, ...sideEffectImportLocals]));
+};

package/types/transform/generators/resolveStaticOxcValues/resolveStaticOxcPreevalValues.d.ts

@@ -0,0 +1,2 @@
+import type { ITransformAction, SyncScenarioFor } from '../../types';
+export declare function resolveStaticOxcPreevalValues(this: ITransformAction): SyncScenarioFor<boolean>;

package/types/transform/generators/resolveStaticOxcValues/resolveStaticOxcPreevalValues.js

@@ -0,0 +1,198 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { isAbsolute } from 'path';
+import { appendOxcWywPreval } from '../../../utils/oxcPreevalStage';
+import { stripQueryAndHash } from '../../../utils/parseRequest';
+import { resolveCandidateValue, resolveOpaqueRuntimeCandidateValue, } from './candidateResolver';
+import { debugStaticResolve, getEvalStrategy, getStaticStrategyFailure, parseProgram, } from './environment';
+import { collectWYWMetaExtendsHelperNames, createSameFileStaticWYWMetaHelperResolver, } from './processorStaticModel';
+import { pruneStaticPreevalCode } from './prune';
+import { runtimeCallbackPlaceholder } from './staticExpression';
+export function* resolveStaticOxcPreevalValues() {
+    const preevalResult = this.entrypoint.getPreevalResult();
+    if (!preevalResult) {
+        return false;
+    }
+    const candidates = preevalResult.staticValueCandidates ?? [];
+    const evalDependencyNames = new Set(preevalResult.dependencyNames ?? []);
+    if (candidates.length === 0 && evalDependencyNames.size === 0) {
+        return false;
+    }
+    const filename = this.entrypoint.loadedAndParsed.evaluator === 'ignored'
+        ? this.entrypoint.name
+        : this.entrypoint.loadedAndParsed.evalConfig.filename ??
+            this.entrypoint.name;
+    const evalStrategy = getEvalStrategy(this);
+    if (evalStrategy === 'execute') {
+        return false;
+    }
+    const staticOnly = evalStrategy === 'static';
+    const staticValueCache = preevalResult.staticValueCache ?? new Map();
+    const staticDependencies = new Set(preevalResult.staticDependencies ?? []);
+    const staticImportLocals = new Set(preevalResult.staticImportLocals ?? []);
+    const sideEffectImportLocals = new Set();
+    const staticNullWYWMetaExtendsHelpers = new Set(preevalResult.staticNullWYWMetaExtendsHelpers ?? []);
+    const memo = new Map();
+    const opaqueRuntimeBaseHelpers = collectWYWMetaExtendsHelperNames(parseProgram(preevalResult.baseCode ?? preevalResult.code, filename));
+    // Names of candidates resolved to runtime callbacks (function values).
+    // They keep the file out of evalFile but their helper declarations must
+    // not be pruned — the runtime call site relies on them.
+    const runtimeOnlyCandidateNames = new Set(preevalResult.runtimeOnlyStaticValueNames ?? []);
+    let changed = false;
+    let hasKnownStaticCandidate = false;
+    const resolveSameFileStaticWYWMetaHelpers = createSameFileStaticWYWMetaHelperResolver(preevalResult.baseCode ?? preevalResult.code, filename);
+    const applySameFileStaticWYWMetaHelpers = () => {
+        let appliedAny = false;
+        for (;;) {
+            let applied = false;
+            const values = resolveSameFileStaticWYWMetaHelpers(staticValueCache);
+            values.forEach((value, name) => {
+                if (staticValueCache.has(name) ||
+                    (!evalDependencyNames.has(name) &&
+                        !opaqueRuntimeBaseHelpers.has(name))) {
+                    return;
+                }
+                staticValueCache.set(name, value);
+                debugStaticResolve(this, {
+                    candidate: name,
+                    filename,
+                    phase: 'candidate',
+                    reason: 'same-file-static-metadata',
+                    status: 'resolved',
+                });
+                applied = true;
+            });
+            if (!applied) {
+                break;
+            }
+            appliedAny = true;
+        }
+        if (appliedAny) {
+            changed = true;
+            hasKnownStaticCandidate = true;
+        }
+        return appliedAny;
+    };
+    applySameFileStaticWYWMetaHelpers();
+    for (const candidate of candidates) {
+        applySameFileStaticWYWMetaHelpers();
+        const isOpaqueRuntimeBaseHelper = opaqueRuntimeBaseHelpers.has(candidate.name);
+        if (!evalDependencyNames.has(candidate.name) &&
+            !isOpaqueRuntimeBaseHelper &&
+            !staticValueCache.has(candidate.name)) {
+            debugStaticResolve(this, {
+                candidate: candidate.name,
+                filename,
+                phase: 'candidate',
+                reason: 'not-eval-dependency',
+                status: 'skipped',
+            });
+            continue;
+        }
+        if (staticValueCache.has(candidate.name)) {
+            hasKnownStaticCandidate = true;
+            candidate.imports.forEach((item) => staticImportLocals.add(item.importLocal ?? item.local));
+            if (isOpaqueRuntimeBaseHelper &&
+                staticValueCache.get(candidate.name) === null) {
+                staticNullWYWMetaExtendsHelpers.add(candidate.name);
+            }
+            debugStaticResolve(this, {
+                candidate: candidate.name,
+                filename,
+                phase: 'candidate',
+                reason: 'already-static',
+                status: 'skipped',
+            });
+            continue;
+        }
+        let resolved;
+        let resolvedOpaqueRuntimeBase = false;
+        if (isOpaqueRuntimeBaseHelper) {
+            resolved = yield* resolveOpaqueRuntimeCandidateValue(this, candidate, filename);
+            resolvedOpaqueRuntimeBase = !!resolved;
+            if (!resolved) {
+                resolved = yield* resolveCandidateValue(this, candidate, filename, memo);
+            }
+        }
+        else {
+            resolved = yield* resolveCandidateValue(this, candidate, filename, memo);
+        }
+        if (!resolved) {
+            continue;
+        }
+        if (resolvedOpaqueRuntimeBase) {
+            debugStaticResolve(this, {
+                candidate: candidate.name,
+                filename,
+                phase: 'candidate',
+                reason: 'opaque-runtime-component',
+                status: 'resolved',
+            });
+            staticNullWYWMetaExtendsHelpers.add(candidate.name);
+        }
+        if (resolved.runtimeOnly) {
+            // Runtime callback — seed a callable placeholder for collect() but
+            // track it separately so the `_exp = () => target` helper survives
+            // pruning. The runtime call site relies on that helper declaration.
+            runtimeOnlyCandidateNames.add(candidate.name);
+            staticValueCache.set(candidate.name, runtimeCallbackPlaceholder);
+        }
+        else {
+            staticValueCache.set(candidate.name, resolved.value);
+        }
+        hasKnownStaticCandidate = true;
+        candidate.imports.forEach((item) => staticImportLocals.add(item.importLocal ?? item.local));
+        resolved.dependencies.forEach((dependency) => staticDependencies.add(dependency));
+        resolved.sideEffectImportLocals?.forEach((local) => sideEffectImportLocals.add(local));
+        changed = true;
+        applySameFileStaticWYWMetaHelpers();
+    }
+    if (!changed &&
+        (!hasKnownStaticCandidate || preevalResult.staticValuesApplied)) {
+        if (staticOnly && evalDependencyNames.size > 0) {
+            throw getStaticStrategyFailure(filename, evalDependencyNames);
+        }
+        return false;
+    }
+    const dependencyNames = (preevalResult.dependencyNames ?? []).filter((name) => !staticValueCache.has(name) && !runtimeOnlyCandidateNames.has(name));
+    if (staticOnly && dependencyNames.length > 0) {
+        throw getStaticStrategyFailure(filename, dependencyNames);
+    }
+    preevalResult.dependencyNames = dependencyNames;
+    preevalResult.staticValueCache = staticValueCache;
+    preevalResult.staticDependencies = [...staticDependencies];
+    preevalResult.staticNullWYWMetaExtendsHelpers = [
+        ...staticNullWYWMetaExtendsHelpers,
+    ];
+    preevalResult.runtimeOnlyStaticValueNames = [...runtimeOnlyCandidateNames];
+    preevalResult.staticValuesApplied = true;
+    const originalBaseCode = preevalResult.baseCode ?? preevalResult.code;
+    const prunableStaticValueNames = new Set([...staticValueCache.keys()].filter((name) => !runtimeOnlyCandidateNames.has(name)));
+    const staticExtendsHelperValues = new Map([...staticValueCache].filter(([name]) => !runtimeOnlyCandidateNames.has(name)));
+    staticNullWYWMetaExtendsHelpers.forEach((name) => {
+        if (!staticExtendsHelperValues.has(name)) {
+            staticExtendsHelperValues.set(name, null);
+        }
+    });
+    const baseCode = pruneStaticPreevalCode(originalBaseCode, filename, prunableStaticValueNames, staticImportLocals, staticExtendsHelperValues, sideEffectImportLocals);
+    const evalBaseCode = sideEffectImportLocals.size > 0
+        ? pruneStaticPreevalCode(originalBaseCode, filename, prunableStaticValueNames, staticImportLocals, staticExtendsHelperValues, new Set())
+        : baseCode;
+    preevalResult.baseCode = baseCode;
+    preevalResult.code = appendOxcWywPreval(baseCode, filename, dependencyNames);
+    preevalResult.evalCode = appendOxcWywPreval(evalBaseCode, filename, dependencyNames);
+    preevalResult.staticImportLocals = [...staticImportLocals];
+    preevalResult.staticSideEffectImportLocals = [...sideEffectImportLocals];
+    for (const dependency of staticDependencies) {
+        const strippedDependency = stripQueryAndHash(dependency);
+        if (isAbsolute(strippedDependency)) {
+            this.services.cache.checkFreshness(dependency, strippedDependency);
+        }
+        this.entrypoint.addInvalidationDependency({
+            only: ['*'],
+            resolved: dependency,
+            source: dependency,
+        });
+        this.entrypoint.markInvalidateOnDependencyChange(dependency);
+    }
+    return true;
+}