@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

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

@@ -1,17 +1,13 @@
-import type { File } from '@babel/types';
 import type { WYWTransformMetadata } from '../../utils/TransformMetadata';
 import type { Entrypoint } from '../Entrypoint';
 import type { ITransformAction, Services, SyncScenarioForAction } from '../types';
-type PrepareCodeFn = (services: Services, item: Entrypoint, originalAst: File) => [
+type PrepareCodeFn = (services: Services, item: Entrypoint, originalAst: unknown | null) => [
     code: string,
     imports: Map<string, string[]> | null,
     metadata: WYWTransformMetadata | null
 ];
-export declare const prepareCode: (services: Services, item: Entrypoint, originalAst: File) => ReturnType<PrepareCodeFn>;
+export declare const prepareCode: (services: Services, item: Entrypoint, originalAst: unknown | null) => ReturnType<PrepareCodeFn>;
+export declare const prepareCodeForEvalRuntime: (services: Services, item: Entrypoint, originalAst: unknown | null) => ReturnType<PrepareCodeFn>;
 export declare function internalTransform(this: ITransformAction, prepareFn: PrepareCodeFn): SyncScenarioForAction<ITransformAction>;
-/**
- * Prepares the code for evaluation. This includes removing dead and potentially unsafe code.
- * Emits resolveImports and processImports events.
- */
 export declare function transform(this: ITransformAction): SyncScenarioForAction<ITransformAction>;
 export {};

package/types/transform/generators/transform.js

@@ -1,102 +1,196 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareCode = void 0;
-exports.internalTransform = internalTransform;
-exports.transform = transform;
-const buildOptions_1 = require("../../options/buildOptions");
-const dynamic_import_1 = __importDefault(require("../../plugins/dynamic-import"));
-const preeval_1 = __importDefault(require("../../plugins/preeval"));
-const shaker_1 = require("../../shaker");
-const TransformMetadata_1 = require("../../utils/TransformMetadata");
-const getPluginKey_1 = require("../../utils/getPluginKey");
-const rewriteBarrelImports_1 = require("./rewriteBarrelImports");
+import { oxcShaker } from '../../shaker';
+import { collectOxcExportsAndImports } from '../../utils/collectOxcExportsAndImports';
+import { emitOxcCommonJS, stripTypesAndJsxWithOxc } from '../../utils/oxcEmit';
+import { runOxcPreevalStage } from '../../utils/oxcPreevalStage';
+import { shakeOxcToESM } from '../../utils/oxcShaker';
+import { rewriteOptimizedOxcBarrelImports } from './rewriteOxcBarrelImports';
+import { resolveStaticOxcPreevalValues } from './resolveStaticOxcValues';
 const EMPTY_FILE = '=== empty file ===';
-const hasKeyInList = (plugin, list) => {
-    const pluginKey = (0, getPluginKey_1.getPluginKey)(plugin);
-    return pluginKey ? list.some((i) => pluginKey.includes(i)) : false;
-};
-function runPreevalStage(babel, evalConfig, pluginOptions, code, originalAst, eventEmitter) {
-    const preShakePlugins = evalConfig.plugins?.filter((i) => hasKeyInList(i, pluginOptions.highPriorityPlugins)) ?? [];
-    const plugins = [
-        ...preShakePlugins,
-        [
-            preeval_1.default,
-            {
-                ...pluginOptions,
-                eventEmitter,
-            },
-        ],
-        dynamic_import_1.default,
-        ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, pluginOptions.highPriorityPlugins)),
-    ];
-    const transformConfig = (0, buildOptions_1.buildOptions)({
-        ...evalConfig,
-        envName: 'wyw-in-js',
-        plugins,
+const collectImportsFromOxc = (code, filename) => {
+    const imports = new Map();
+    const addImport = (source, imported) => {
+        const bucket = imports.get(source) ?? [];
+        if (!bucket.includes(imported)) {
+            bucket.push(imported);
+        }
+        imports.set(source, bucket);
+    };
+    collectOxcExportsAndImports(code, filename).imports.forEach((item) => {
+        addImport(item.source, item.imported || 'side-effect');
     });
-    const result = babel.transformFromAstSync(originalAst, code, transformConfig);
-    if (!result || !result.ast?.program) {
-        throw new Error('Babel transform failed');
-    }
-    return result;
-}
+    return imports;
+};
 const isPrevalOnly = (only) => only.length === 1 && only[0] === '__wywPreval';
-const prepareEvaluatorInput = (services, item, originalAst) => {
-    const { only, loadedAndParsed, log } = item;
+const hasWywPrevalExport = (code, filename) => Object.hasOwn(collectOxcExportsAndImports(code, filename).exports, '__wywPreval');
+const normalizeOxcPreparedESM = (code) => code
+    .replace(/^(?:[ \t]*\n)+/, '')
+    .replace(/[ \t\n]+$/, '')
+    .replace(/\n{2,}/g, '\n')
+    .replace(/^const /gm, 'var ');
+const ensureOxcPreevalResult = (services, item, originalAst) => {
+    const cached = item.getPreevalResult();
+    if (cached) {
+        return cached;
+    }
+    const { loadedAndParsed } = item;
     if (loadedAndParsed.evaluator === 'ignored') {
-        throw new Error(`Cannot prepare ignored entrypoint ${item.name}`);
-    }
-    const { code, evalConfig } = loadedAndParsed;
-    const { options, babel, eventEmitter } = services;
-    const { pluginOptions } = options;
-    const preevalStageResult = eventEmitter.perf('transform:preeval', () => runPreevalStage(babel, evalConfig, pluginOptions, code, originalAst, eventEmitter));
-    const transformMetadata = (0, TransformMetadata_1.getTransformMetadata)(preevalStageResult.metadata);
-    if (isPrevalOnly(only) && !transformMetadata) {
-        log('[evaluator:end] no metadata');
+        throw new Error('Cannot run Oxc preeval for an ignored entrypoint.');
+    }
+    const filename = loadedAndParsed.evalConfig.filename ?? item.name;
+    const { eventEmitter } = services;
+    const { pluginOptions } = services.options;
+    const root = services.options.root ?? process.cwd();
+    const preevalStageResult = eventEmitter.perf('transform:preeval', () => {
+        const result = runOxcPreevalStage(loadedAndParsed.code, {
+            filename,
+            root,
+        }, {
+            ...pluginOptions,
+            eventEmitter,
+        });
         return {
-            kind: 'short-circuit',
-            code: preevalStageResult.code,
+            ast: originalAst,
+            baseCode: result.baseCode,
+            code: result.code,
+            dependencyNames: result.dependencyNames,
+            evalCode: result.code,
+            metadata: result.metadata,
+            processorClassNames: result.processorClassNames,
+            staticSideEffectImportLocals: [],
+            staticDependencies: result.staticDependencies,
+            staticValuesApplied: false,
+            staticValueCache: result.staticValueCache,
+            staticValueCandidates: result.staticValueCandidates,
         };
+    });
+    item.setPreevalResult(preevalStageResult);
+    return preevalStageResult;
+};
+const prepareOxcCodeImpl = (services, item, originalAst, options = {}) => {
+    const { only, loadedAndParsed, log } = item;
+    if (loadedAndParsed.evaluator === 'ignored') {
+        log('is ignored');
+        return [loadedAndParsed.code ?? '', null, null];
+    }
+    const filename = loadedAndParsed.evalConfig.filename ?? item.name;
+    const { eventEmitter } = services;
+    const { pluginOptions } = services.options;
+    const root = services.options.root ?? process.cwd();
+    const preevalStageResult = ensureOxcPreevalResult(services, item, originalAst);
+    const transformMetadata = preevalStageResult.metadata;
+    const preevalCode = options.stripForEvalRuntime && preevalStageResult.evalCode
+        ? preevalStageResult.evalCode
+        : preevalStageResult.code;
+    if (isPrevalOnly(only) &&
+        !transformMetadata &&
+        !hasWywPrevalExport(preevalCode, filename) &&
+        options.shortCircuitOnMissingMetadata !== false) {
+        log('[evaluator:end] no metadata');
+        const strippedCode = stripTypesAndJsxWithOxc(preevalCode, filename).code;
+        return [
+            normalizeOxcPreparedESM(strippedCode),
+            collectImportsFromOxc(strippedCode, filename),
+            null,
+        ];
     }
     log('[preeval] metadata %O', transformMetadata);
-    return {
-        kind: 'continue',
-        ast: preevalStageResult.ast,
-        code: preevalStageResult.code,
-        evalConfig,
-        evaluatorConfig: {
-            onlyExports: only,
-            highPriorityPlugins: pluginOptions.highPriorityPlugins,
-            features: pluginOptions.features,
-            importOverrides: pluginOptions.importOverrides,
-            root: options.root,
-        },
-        metadata: transformMetadata ?? null,
-    };
+    log('[evaluator:start] using %s', loadedAndParsed.evaluator.name);
+    log.extend('source')('%s', preevalCode);
+    const shaken = eventEmitter.perf('transform:evaluator', () => shakeOxcToESM(preevalCode, filename, {
+        importOverrides: pluginOptions.importOverrides,
+        onlyExports: only,
+        root,
+    }));
+    log('[evaluator:end]');
+    if (!options.emitCommonJS) {
+        const preparedCode = options.stripForEvalRuntime
+            ? stripTypesAndJsxWithOxc(shaken.code, filename).code
+            : shaken.code;
+        return [
+            normalizeOxcPreparedESM(preparedCode),
+            options.stripForEvalRuntime
+                ? collectImportsFromOxc(preparedCode, filename)
+                : shaken.imports,
+            transformMetadata ?? null,
+        ];
+    }
+    const emitted = eventEmitter.perf('transform:emitCommonJS', () => emitOxcCommonJS(shaken.code, filename));
+    return [emitted.code, shaken.imports, transformMetadata ?? null];
 };
-const prepareCode = (services, item, originalAst) => {
+const prepareCodeImpl = (services, item, originalAst, options = {}) => {
     const { log, loadedAndParsed } = item;
     if (loadedAndParsed.evaluator === 'ignored') {
         log('is ignored');
         return [loadedAndParsed.code ?? '', null, null];
     }
     const { evaluator } = loadedAndParsed;
-    const { babel, eventEmitter } = services;
-    const prepared = prepareEvaluatorInput(services, item, originalAst);
-    if (prepared.kind === 'short-circuit') {
-        return [prepared.code, null, null];
-    }
-    log('[evaluator:start] using %s', evaluator.name);
-    log.extend('source')('%s', prepared.code);
-    const [, transformedCode, imports] = eventEmitter.perf('transform:evaluator', () => evaluator(prepared.evalConfig, prepared.ast, prepared.code, prepared.evaluatorConfig, babel));
-    log('[evaluator:end]');
-    return [transformedCode, imports, prepared.metadata];
+    if (evaluator !== oxcShaker) {
+        throw new Error(`[wyw-in-js] ${item.name} matched a legacy evaluator. The Oxc runtime path supports only the default Oxc evaluator.`);
+    }
+    return prepareOxcCodeImpl(services, item, originalAst, options);
 };
-exports.prepareCode = prepareCode;
-function* internalTransform(prepareFn) {
+export const prepareCode = (services, item, originalAst) => prepareCodeImpl(services, item, originalAst);
+export const prepareCodeForEvalRuntime = (services, item, originalAst) => prepareCodeImpl(services, item, originalAst, {
+    shortCircuitOnMissingMetadata: true,
+    stripForEvalRuntime: true,
+});
+function* resolveAndProcessOxcPreparedImports(action, preparedCode, imports) {
+    const { loadedAndParsed } = action.entrypoint;
+    if (imports === null || imports.size === 0) {
+        return preparedCode;
+    }
+    const resolvedImports = yield* action.getNext('resolveImports', action.entrypoint, {
+        imports,
+        phase: 'initial',
+    });
+    let nextCode = preparedCode;
+    let nextResolvedImports = [];
+    let skippedParentDependencyTracking = [];
+    if (resolvedImports.length > 0) {
+        const rewritten = yield* rewriteOptimizedOxcBarrelImports.call(action, preparedCode, loadedAndParsed.evaluator === 'ignored'
+            ? action.entrypoint.name
+            : loadedAndParsed.evalConfig.filename ?? action.entrypoint.name, resolvedImports);
+        nextCode = rewritten.code;
+        if (rewritten.optimizedCount > 0) {
+            skippedParentDependencyTracking = rewritten.generatedSources;
+            const fullyRewrittenSources = new Set(rewritten.fullyRewrittenSources);
+            const partialFallbackSources = new Set(rewritten.partialFallbackSources);
+            for (const dependency of resolvedImports) {
+                if (dependency.resolved &&
+                    (fullyRewrittenSources.has(dependency.source) ||
+                        partialFallbackSources.has(dependency.source))) {
+                    if (partialFallbackSources.has(dependency.source)) {
+                        action.entrypoint.addDependency(dependency);
+                    }
+                    else {
+                        action.entrypoint.addInvalidationDependency(dependency);
+                    }
+                    action.entrypoint.markInvalidateOnDependencyChange(dependency.resolved);
+                }
+            }
+            nextResolvedImports = yield* action.getNext('resolveImports', action.entrypoint, {
+                imports: rewritten.imports,
+                phase: 'rewritten',
+                preResolved: rewritten.preResolvedImports,
+            });
+        }
+        else {
+            nextResolvedImports = resolvedImports;
+        }
+    }
+    if (nextResolvedImports.length !== 0) {
+        yield [
+            'processImports',
+            action.entrypoint,
+            {
+                resolved: nextResolvedImports,
+                skipParentDependencyTracking: skippedParentDependencyTracking,
+            },
+        ];
+    }
+    return nextCode;
+}
+export function* internalTransform(prepareFn) {
     const { only, loadedAndParsed, log } = this.entrypoint;
     if (loadedAndParsed.evaluator === 'ignored') {
         log('is ignored');
@@ -105,23 +199,55 @@ function* internalTransform(prepareFn) {
             metadata: null,
         };
     }
+    if (loadedAndParsed.evaluator !== oxcShaker) {
+        throw new Error(`[wyw-in-js] ${this.entrypoint.name} matched a legacy evaluator. The Oxc runtime path supports only the default Oxc evaluator.`);
+    }
     log('>> (%o)', only);
-    const [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, loadedAndParsed.ast);
-    if (loadedAndParsed.code === preparedCode) {
+    if (loadedAndParsed.evaluator === oxcShaker) {
+        ensureOxcPreevalResult(this.services, this.entrypoint, null);
+        yield* resolveStaticOxcPreevalValues.call(this);
+    }
+    let [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, null);
+    let finalPreparedCode = preparedCode;
+    if (loadedAndParsed.evaluator === oxcShaker) {
+        if (metadata === null && isPrevalOnly(only)) {
+            log('skip resolving imports for __wywPreval-only entrypoint without metadata');
+            return {
+                code: finalPreparedCode,
+                metadata: null,
+            };
+        }
+        let nextCode = yield* resolveAndProcessOxcPreparedImports(this, preparedCode, imports);
+        if (yield* resolveStaticOxcPreevalValues.call(this)) {
+            [preparedCode, imports, metadata] = prepareFn(this.services, this.entrypoint, null);
+            nextCode = yield* resolveAndProcessOxcPreparedImports(this, preparedCode, imports);
+        }
+        finalPreparedCode = this.services.eventEmitter.perf('transform:emitCommonJS', () => emitOxcCommonJS(nextCode, loadedAndParsed.evalConfig.filename ?? this.entrypoint.name).code);
+    }
+    if (loadedAndParsed.code === finalPreparedCode) {
         log('<< (%o)\n === no changes ===', only);
     }
     else {
         log('<< (%o)', only);
-        log.extend('source')('%s', preparedCode || EMPTY_FILE);
+        log.extend('source')('%s', finalPreparedCode || EMPTY_FILE);
     }
-    if (preparedCode === '') {
+    if (finalPreparedCode === '') {
         log('is skipped');
         return {
             code: loadedAndParsed.code ?? '',
+            metadata,
+        };
+    }
+    if (metadata === null && isPrevalOnly(only)) {
+        log('skip resolving imports for __wywPreval-only entrypoint without metadata');
+        return {
+            code: finalPreparedCode,
             metadata: null,
         };
     }
-    if (imports !== null && imports.size > 0) {
+    if (loadedAndParsed.evaluator !== oxcShaker &&
+        imports !== null &&
+        imports.size > 0) {
         const resolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
             imports,
         });
@@ -136,118 +262,10 @@ function* internalTransform(prepareFn) {
         }
     }
     return {
-        code: preparedCode,
+        code: finalPreparedCode,
         metadata,
     };
 }
-/**
- * Prepares the code for evaluation. This includes removing dead and potentially unsafe code.
- * Emits resolveImports and processImports events.
- */
-function* transform() {
-    const { only, loadedAndParsed, log } = this.entrypoint;
-    if (loadedAndParsed.evaluator === 'ignored') {
-        log('is ignored');
-        return {
-            code: loadedAndParsed.code ?? '',
-            metadata: null,
-        };
-    }
-    if (loadedAndParsed.evaluator !== shaker_1.shaker) {
-        return yield* internalTransform.call(this, exports.prepareCode);
-    }
-    log('>> (%o)', only);
-    const prepared = prepareEvaluatorInput(this.services, this.entrypoint, loadedAndParsed.ast);
-    if (prepared.kind === 'short-circuit') {
-        if (loadedAndParsed.code === prepared.code) {
-            log('<< (%o)\n === no changes ===', only);
-        }
-        else {
-            log('<< (%o)', only);
-            log.extend('source')('%s', prepared.code || EMPTY_FILE);
-        }
-        if (prepared.code === '') {
-            log('is skipped');
-            return {
-                code: loadedAndParsed.code ?? '',
-                metadata: null,
-            };
-        }
-        return {
-            code: prepared.code,
-            metadata: null,
-        };
-    }
-    log('[evaluator:start] using %s', loadedAndParsed.evaluator.name);
-    log.extend('source')('%s', prepared.code);
-    const { babel, eventEmitter } = this.services;
-    const [shakenAst, shakenCode, shakenImports] = eventEmitter.perf('transform:evaluator', () => (0, shaker_1.shakeToESM)(prepared.evalConfig, prepared.ast, prepared.code, prepared.evaluatorConfig, babel));
-    let nextAst = shakenAst;
-    let nextCode = shakenCode;
-    let nextResolvedImports = [];
-    if (shakenImports !== null && shakenImports.size > 0) {
-        const resolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
-            imports: shakenImports,
-            phase: 'initial',
-        });
-        if (resolvedImports.length > 0) {
-            const rewritten = yield* rewriteBarrelImports_1.rewriteOptimizedBarrelImports.call(this, shakenAst, shakenCode, resolvedImports);
-            nextAst = rewritten.ast;
-            nextCode = rewritten.code;
-            if (rewritten.optimizedCount > 0) {
-                const fullyRewrittenSources = new Set(rewritten.fullyRewrittenSources);
-                const partialFallbackSources = new Set(rewritten.partialFallbackSources);
-                for (const dependency of resolvedImports) {
-                    if (dependency.resolved &&
-                        (fullyRewrittenSources.has(dependency.source) ||
-                            partialFallbackSources.has(dependency.source))) {
-                        if (partialFallbackSources.has(dependency.source)) {
-                            this.entrypoint.addDependency(dependency);
-                        }
-                        else {
-                            this.entrypoint.addInvalidationDependency(dependency);
-                        }
-                        this.entrypoint.markInvalidateOnDependencyChange(dependency.resolved);
-                    }
-                }
-                nextResolvedImports = yield* this.getNext('resolveImports', this.entrypoint, {
-                    imports: rewritten.imports,
-                    phase: 'rewritten',
-                    preResolved: rewritten.preResolvedImports,
-                });
-            }
-            else {
-                nextResolvedImports = resolvedImports;
-            }
-        }
-    }
-    if (nextResolvedImports.length !== 0) {
-        yield [
-            'processImports',
-            this.entrypoint,
-            {
-                resolved: nextResolvedImports,
-            },
-        ];
-    }
-    const [, preparedCode] = eventEmitter.perf('transform:emitCommonJS', () => (0, shaker_1.emitCommonJS)(prepared.evalConfig, nextAst, nextCode, babel));
-    log('[evaluator:end]');
-    if (loadedAndParsed.code === preparedCode) {
-        log('<< (%o)\n === no changes ===', only);
-    }
-    else {
-        log('<< (%o)', only);
-        log.extend('source')('%s', preparedCode || EMPTY_FILE);
-    }
-    if (preparedCode === '') {
-        log('is skipped');
-        return {
-            code: loadedAndParsed.code ?? '',
-            metadata: null,
-        };
-    }
-    return {
-        code: preparedCode,
-        metadata: prepared.metadata,
-    };
+export function* transform() {
+    return yield* internalTransform.call(this, prepareCode);
 }

package/types/transform/generators/workflow.js

@@ -1,15 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.workflow = workflow;
-const AbortError_1 = require("../actions/AbortError");
-const TransformDiagnostics_1 = require("../../utils/TransformDiagnostics");
-const TransformMetadata_1 = require("../../utils/TransformMetadata");
+import { isAborted } from '../actions/AbortError';
+import { collectTransformDiagnostics } from '../../utils/TransformDiagnostics';
+import { toTransformResultMetadata } from '../../utils/TransformMetadata';
+const isLoadedEntrypointWithoutArtifacts = (entrypoint) => entrypoint.initialCode !== undefined &&
+    entrypoint.only.includes('__wywPreval');
 /**
  * The entry point for file processing. Sequentially calls `processEntrypoint`,
  * `evalFile`, `collect`, and `extract`. Returns the result of transforming
  * the source code as well as all artifacts obtained from code execution.
  */
-function* workflow() {
+export function* workflow() {
     const { cache, options } = this.services;
     const { entrypoint } = this;
     if (entrypoint.ignored) {
@@ -23,18 +22,25 @@ function* workflow() {
         entrypoint.assertNotSuperseded();
     }
     catch (e) {
-        if ((0, AbortError_1.isAborted)(e) && entrypoint.supersededWith) {
+        if (isAborted(e) && entrypoint.supersededWith) {
             entrypoint.log('workflow aborted, schedule the next attempt');
             return yield* this.getNext('workflow', entrypoint.supersededWith, undefined, null);
         }
         throw e;
     }
     const originalCode = entrypoint.loadedAndParsed.code ?? '';
+    function* restartOnSupersede(error) {
+        if (isAborted(error) && entrypoint.supersededWith) {
+            entrypoint.log('workflow aborted, schedule the next attempt');
+            return yield* this.getNext('workflow', entrypoint.supersededWith, undefined, null);
+        }
+        throw error;
+    }
     // File is ignored or does not contain any tags. Return original code.
     if (!entrypoint.hasWywMetadata()) {
-        if (entrypoint.generation === 1) {
-            // 1st generation here means that it's __wywPreval entrypoint
-            // without __wywPreval, so we don't need it cached
+        if (isLoadedEntrypointWithoutArtifacts(entrypoint)) {
+            // A root bundler pass for a plain dependency must not pin eval/cache state.
+            // If another WyW file needs this module, it will be prepared on demand.
             cache.delete('entrypoints', entrypoint.name);
         }
         return {
@@ -43,42 +49,53 @@ function* workflow() {
         };
     }
     // *** 2nd stage ***
-    const evalStageResult = yield* this.getNext('evalFile', entrypoint, undefined, null);
-    if (evalStageResult === null) {
-        return {
-            code: originalCode,
-            sourceMap: options.inputSourceMap,
-        };
-    }
-    const [valueCache, dependencies] = evalStageResult;
-    // *** 3rd stage ***
-    const collectStageResult = yield* this.getNext('collect', entrypoint, {
-        valueCache,
-    }, null);
-    if (!collectStageResult.metadata) {
+    try {
+        const evalStageResult = yield* this.getNext('evalFile', entrypoint, undefined, null);
+        entrypoint.assertNotSuperseded();
+        if (evalStageResult === null) {
+            return {
+                code: originalCode,
+                sourceMap: options.inputSourceMap,
+            };
+        }
+        const [valueCache, dependencies] = evalStageResult;
+        // *** 3rd stage ***
+        const collectStageResult = yield* this.getNext('collect', entrypoint, {
+            valueCache,
+        }, null);
+        entrypoint.assertNotSuperseded();
+        if (!collectStageResult.metadata) {
+            if (isLoadedEntrypointWithoutArtifacts(entrypoint)) {
+                cache.delete('entrypoints', entrypoint.name);
+            }
+            return {
+                code: collectStageResult.code,
+                sourceMap: collectStageResult.map,
+            };
+        }
+        const metadata = options.pluginOptions.outputMetadata
+            ? toTransformResultMetadata(collectStageResult.metadata, dependencies)
+            : null;
+        const diagnostics = collectTransformDiagnostics(entrypoint.name, collectStageResult.metadata.processors);
+        // *** 4th stage
+        const extractStageResult = yield* this.getNext('extract', entrypoint, {
+            processors: collectStageResult.metadata.processors,
+        }, null);
+        entrypoint.assertNotSuperseded();
         return {
-            code: collectStageResult.code,
+            ...extractStageResult,
+            code: collectStageResult.code ?? '',
+            dependencies,
+            ...(diagnostics.length > 0 ? { diagnostics } : {}),
+            ...(metadata ? { metadata } : {}),
+            replacements: [
+                ...extractStageResult.replacements,
+                ...collectStageResult.metadata.replacements,
+            ],
             sourceMap: collectStageResult.map,
         };
     }
-    const metadata = options.pluginOptions.outputMetadata
-        ? (0, TransformMetadata_1.toTransformResultMetadata)(collectStageResult.metadata, dependencies)
-        : null;
-    const diagnostics = (0, TransformDiagnostics_1.collectTransformDiagnostics)(entrypoint.name, collectStageResult.metadata.processors);
-    // *** 4th stage
-    const extractStageResult = yield* this.getNext('extract', entrypoint, {
-        processors: collectStageResult.metadata.processors,
-    }, null);
-    return {
-        ...extractStageResult,
-        code: collectStageResult.code ?? '',
-        dependencies,
-        ...(diagnostics.length > 0 ? { diagnostics } : {}),
-        ...(metadata ? { metadata } : {}),
-        replacements: [
-            ...extractStageResult.replacements,
-            ...collectStageResult.metadata.replacements,
-        ],
-        sourceMap: collectStageResult.map,
-    };
+    catch (error) {
+        return yield* restartOnSupersede.call(this, error);
+    }
 }