@wyw-in-js/transform 1.0.6 → 1.0.8

package/types/plugins/shaker.js

@@ -49,6 +49,9 @@ function getBindingForExport(exportPath) {
         }
         return getNonParamBinding(exportPath, id.name);
     }
+    if (exportPath.isTSEnumDeclaration()) {
+        return getNonParamBinding(exportPath, exportPath.node.id.name);
+    }
     return undefined;
 }
 const withoutRemoved = (items) => items.filter(({ local }) => !(0, isRemoved_1.isRemoved)(local));
@@ -119,28 +122,118 @@ const getPropertyAssignmentStatement = (ref, bindingName) => {
     return statement?.isExpressionStatement() ? statement : null;
 };
 const isWithinAliveExport = (ref, aliveExports) => [...aliveExports].some((alive) => alive === ref || alive.isAncestor(ref));
-function stripExportKeepDeclaration(path) {
+function getExportPathsForVariableDeclaration(declaration, exports) {
+    const exportPaths = [];
+    declaration.get('declarations').forEach((declarator) => {
+        Object.keys(declarator.getOuterBindingIdentifiers()).forEach((name) => {
+            const exportPath = exports[name];
+            if (exportPath && !exportPaths.includes(exportPath)) {
+                exportPaths.push(exportPath);
+            }
+        });
+    });
+    return exportPaths;
+}
+function getDeclaratorExportLiveness(declarator, exports, aliveExports) {
+    const bindingNames = Object.keys(declarator.getOuterBindingIdentifiers());
+    if (bindingNames.length === 0) {
+        return null;
+    }
+    let liveness = null;
+    for (const name of bindingNames) {
+        const exportPath = exports[name];
+        if (!exportPath) {
+            return null;
+        }
+        const isAlive = aliveExports.has(exportPath);
+        if (liveness === null) {
+            liveness = isAlive;
+        }
+        else if (liveness !== isAlive) {
+            return null;
+        }
+    }
+    return liveness;
+}
+function hasRuntimeReferencesToEnum(path) {
+    if (!path.isTSEnumDeclaration()) {
+        return false;
+    }
+    const enumId = path.get('id');
+    const bindingName = enumId.node.name;
+    const program = path.scope.getProgramParent().path;
+    let hasReference = false;
+    program.traverse({
+        Identifier(identifier) {
+            if (hasReference || identifier.node.name !== bindingName) {
+                return;
+            }
+            if (identifier.findParent((ancestor) => ancestor === path)) {
+                return;
+            }
+            if (identifier.find((ancestor) => ancestor.isTSType() || ancestor.isFlowType())) {
+                return;
+            }
+            if (!identifier.isReferencedIdentifier()) {
+                return;
+            }
+            const localBinding = identifier.scope.getBinding(bindingName);
+            if (localBinding && localBinding.path !== enumId) {
+                return;
+            }
+            hasReference = true;
+            identifier.stop();
+        },
+    });
+    return hasReference;
+}
+function stripExportKeepDeclaration(path, exports, aliveExports, t) {
     const exportDeclaration = path.findParent((p) => p.isExportNamedDeclaration());
     if (!exportDeclaration)
-        return false;
+        return null;
     const declaration = exportDeclaration.get('declaration');
     if (!declaration.node)
-        return false;
+        return null;
     if (declaration.isFunctionDeclaration() ||
         declaration.isClassDeclaration() ||
         declaration.isTSEnumDeclaration()) {
-        exportDeclaration.replaceWith(declaration.node);
-        return true;
+        exportDeclaration.replaceWith(t.cloneNode(declaration.node, true));
+        return [path];
     }
     if (declaration.isVariableDeclaration()) {
         const declarators = declaration.get('declarations');
-        if (declarators.length !== 1) {
-            return false;
+        const staleExportPaths = getExportPathsForVariableDeclaration(declaration, exports);
+        if (declarators.length === 1) {
+            exportDeclaration.replaceWith(t.cloneNode(declaration.node, true));
+            return staleExportPaths.length > 0 ? staleExportPaths : [path];
         }
-        exportDeclaration.replaceWith(declaration.node);
-        return true;
+        const segments = [];
+        for (const declarator of declarators) {
+            const isAlive = getDeclaratorExportLiveness(declarator, exports, aliveExports);
+            if (isAlive === null) {
+                return null;
+            }
+            const clonedDeclarator = t.cloneNode(declarator.node, true);
+            const currentSegment = segments[segments.length - 1];
+            if (currentSegment && currentSegment.alive === isAlive) {
+                currentSegment.declarators.push(clonedDeclarator);
+            }
+            else {
+                segments.push({
+                    alive: isAlive,
+                    declarators: [clonedDeclarator],
+                });
+            }
+        }
+        exportDeclaration.replaceWithMultiple(segments.map(({ alive, declarators: groupedDeclarators }) => {
+            const groupedDeclaration = t.variableDeclaration(declaration.node.kind, groupedDeclarators);
+            return alive
+                ? t.exportNamedDeclaration(groupedDeclaration, [])
+                : groupedDeclaration;
+        }));
+        return staleExportPaths.length > 0 ? staleExportPaths : [path];
     }
-    return false;
+    return null;
 }
 function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-shaking', importOverrides, onlyExports, root, }) {
     const shakerLogger = shared_1.logger.extend('shaker');
@@ -377,17 +470,58 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
                             (0, scopeHelpers_1.dereference)(path);
                             dereferenced.push(path);
                         }
-                        if (!deleted.has(path) &&
-                            binding &&
-                            blockingReferences.length > 0 &&
-                            stripExportKeepDeclaration(path)) {
-                            deleted.add(path);
+                        const strippedEnum = !deleted.has(path) && hasRuntimeReferencesToEnum(path)
+                            ? stripExportKeepDeclaration(path, exports, aliveExports, babel.types)
+                            : null;
+                        if (strippedEnum) {
+                            strippedEnum.forEach((stalePath) => {
+                                deleted.add(stalePath);
+                            });
+                            changed = true;
+                            // eslint-disable-next-line no-continue
+                            continue;
+                        }
+                        const strippedWithBlocking = !deleted.has(path) && binding && blockingReferences.length > 0
+                            ? stripExportKeepDeclaration(path, exports, aliveExports, babel.types)
+                            : null;
+                        if (strippedWithBlocking) {
+                            strippedWithBlocking.forEach((stalePath) => {
+                                deleted.add(stalePath);
+                            });
                             changed = true;
                             // eslint-disable-next-line no-continue
                             continue;
                         }
                         if (!deleted.has(path) &&
                             (!binding || blockingReferences.length === 0)) {
+                            // For variable declaration exports, `path` is the init expression
+                            // (not the Identifier). Other forDeleting candidates whose init
+                            // expressions are ancestors of references to this binding can
+                            // incorrectly filter them out of outerReferences. Those candidates
+                            // may later survive via stripExportKeepDeclaration, leaving a
+                            // dangling reference. Strip the export keyword but keep the
+                            // declaration so the unreferenced sweep removes it only when dead.
+                            // This only applies to expression paths (variable init), not
+                            // Identifiers (function/class declarations) which can't be
+                            // ancestors of external references.
+                            const strippedWithoutBlocking = binding && !path.isIdentifier()
+                                ? stripExportKeepDeclaration(path, exports, aliveExports, babel.types)
+                                : null;
+                            if (strippedWithoutBlocking) {
+                                strippedWithoutBlocking.forEach((stalePath) => {
+                                    deleted.add(stalePath);
+                                });
+                                if (removableAssignmentStatements.size > 0) {
+                                    for (const statement of removableAssignmentStatements) {
+                                        if (queueForDeleting(statement)) {
+                                            changed = true;
+                                        }
+                                    }
+                                }
+                                changed = true;
+                                // eslint-disable-next-line no-continue
+                                continue;
+                            }
                             if (removableAssignmentStatements.size > 0) {
                                 for (const statement of removableAssignmentStatements) {
                                     if (queueForDeleting(statement)) {
@@ -412,12 +546,23 @@ function shakerPlugin(babel, { keepSideEffects = false, ifUnknownExport = 'skip-
                         }
                     });
                     dereferenced = [];
+                    // stripExportKeepDeclaration replaces ExportNamedDeclaration with
+                    // its declaration, creating new AST nodes. The old scope bindings
+                    // become stale (pointing at disconnected paths). Recrawl so
+                    // getAllBindings() returns fresh bindings with correct .referenced.
+                    file.scope.crawl();
                     // Find and mark for deleting all unreferenced variables
                     const unreferenced = Object.values(file.scope.getAllBindings()).filter((i) => !i.referenced);
                     for (const binding of unreferenced) {
                         if (binding.path.isVariableDeclarator()) {
                             const id = binding.path.get('id');
-                            if (!(0, isRemoved_1.isRemoved)(id) && !forDeletingSet.has(id)) {
+                            // Skip destructured patterns — removing the declarator would kill
+                            // sibling bindings that may still be referenced (e.g. export {B}
+                            // from `const [A, B] = createContext(...)` when only A is dead).
+                            if (!id.isArrayPattern() &&
+                                !id.isObjectPattern() &&
+                                !(0, isRemoved_1.isRemoved)(id) &&
+                                !forDeletingSet.has(id)) {
                                 // Drop dead variable declarations, e.g. `const foo = make();` when `foo` is no longer referenced.
                                 for (const violation of binding.constantViolations) {
                                     if (queueForDeleting(violation)) {

package/types/shaker.d.ts

@@ -1,3 +1,12 @@
-import type { Evaluator } from '@wyw-in-js/shared';
+import type { TransformOptions } from '@babel/core';
+import type { File } from '@babel/types';
+import type { Evaluator, EvaluatorConfig } from '@wyw-in-js/shared';
+type ShakerStageResult = [
+    ast: File,
+    code: string,
+    imports: Map<string, string[]> | null
+];
+export declare const shakeToESM: (evalConfig: TransformOptions, ast: File, code: string, config: EvaluatorConfig, babel: Parameters<Evaluator>[4]) => ShakerStageResult;
+export declare const emitCommonJS: (evalConfig: TransformOptions, ast: File, code: string, babel: Parameters<Evaluator>[4]) => [ast: File, code: string];
 export declare const shaker: Evaluator;
 export default shaker;

package/types/shaker.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shaker = void 0;
+exports.shaker = exports.emitCommonJS = exports.shakeToESM = void 0;
 const shaker_1 = __importDefault(require("./plugins/shaker"));
 const ShakerMetadata_1 = require("./utils/ShakerMetadata");
 const getPluginKey_1 = require("./utils/getPluginKey");
@@ -11,6 +11,7 @@ const hasKeyInList = (plugin, list) => {
     const pluginKey = (0, getPluginKey_1.getPluginKey)(plugin);
     return pluginKey ? list.some((i) => pluginKey.includes(i)) : false;
 };
+const isCommonJSPlugin = (plugin) => (0, getPluginKey_1.getPluginKey)(plugin) === 'transform-modules-commonjs';
 const safeResolve = (id, paths) => {
     try {
         return require.resolve(id, {
@@ -21,44 +22,50 @@ const safeResolve = (id, paths) => {
         return null;
     }
 };
-const shaker = (evalConfig, ast, code, { highPriorityPlugins, ...config }, babel) => {
+const ensureTypescriptPlugin = (plugins, evalConfig) => {
+    if (!evalConfig.filename?.endsWith('.ts') &&
+        !evalConfig.filename?.endsWith('.tsx') &&
+        !evalConfig.filename?.endsWith('.mts') &&
+        !evalConfig.filename?.endsWith('.cts')) {
+        return;
+    }
+    const hasTypescriptPlugin = plugins.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-typescript');
+    if (hasTypescriptPlugin) {
+        return;
+    }
+    const preset = safeResolve('@babel/preset-typescript', [evalConfig.filename]);
+    const plugin = safeResolve('@babel/plugin-transform-typescript', [
+        evalConfig.filename,
+        preset,
+    ]);
+    if (plugin) {
+        plugins.push([plugin, { allowDeclareFields: true }]);
+    }
+};
+const createShakerPlugins = (evalConfig, config, includeCommonJS) => {
+    const { highPriorityPlugins, ...shakerConfig } = config;
     const preShakePlugins = evalConfig.plugins?.filter((i) => hasKeyInList(i, highPriorityPlugins)) ??
         [];
     const plugins = [
         ...preShakePlugins,
-        [shaker_1.default, config],
-        ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, highPriorityPlugins)),
+        [shaker_1.default, shakerConfig],
+        ...(evalConfig.plugins ?? []).filter((i) => !hasKeyInList(i, highPriorityPlugins) && !isCommonJSPlugin(i)),
     ];
-    const hasCommonjsPlugin = evalConfig.plugins?.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-modules-commonjs');
-    if (!hasCommonjsPlugin) {
+    ensureTypescriptPlugin(plugins, evalConfig);
+    if (includeCommonJS) {
         plugins.push(require.resolve('@babel/plugin-transform-modules-commonjs'));
     }
-    if (evalConfig.filename?.endsWith('.ts') ||
-        evalConfig.filename?.endsWith('.tsx') ||
-        evalConfig.filename?.endsWith('.mts') ||
-        evalConfig.filename?.endsWith('.cts')) {
-        const hasTypescriptPlugin = evalConfig.plugins?.some((i) => (0, getPluginKey_1.getPluginKey)(i) === 'transform-typescript');
-        if (!hasTypescriptPlugin) {
-            const preset = safeResolve('@babel/preset-typescript', [
-                evalConfig.filename,
-            ]);
-            const plugin = safeResolve('@babel/plugin-transform-typescript', [
-                evalConfig.filename,
-                preset,
-            ]);
-            if (plugin) {
-                plugins.push([plugin, { allowDeclareFields: true }]);
-            }
-        }
-    }
-    const transformOptions = {
+    return plugins;
+};
+const shakeToESM = (evalConfig, ast, code, config, babel) => {
+    const transformed = babel.transformFromAstSync(ast, code, {
         ...evalConfig,
+        ast: true,
         caller: {
             name: 'wyw-in-js',
         },
-        plugins,
-    };
-    const transformed = babel.transformFromAstSync(ast, code, transformOptions);
+        plugins: createShakerPlugins(evalConfig, config, false),
+    });
     if (!transformed || !(0, ShakerMetadata_1.hasShakerMetadata)(transformed.metadata)) {
         throw new Error(`${evalConfig.filename} has no shaker metadata`);
     }
@@ -68,5 +75,26 @@ const shaker = (evalConfig, ast, code, { highPriorityPlugins, ...config }, babel
         transformed.metadata.wywEvaluator.imports,
     ];
 };
+exports.shakeToESM = shakeToESM;
+const emitCommonJS = (evalConfig, ast, code, babel) => {
+    const transformed = babel.transformFromAstSync(ast, code, {
+        ...evalConfig,
+        ast: true,
+        caller: {
+            name: 'wyw-in-js',
+        },
+        plugins: [require.resolve('@babel/plugin-transform-modules-commonjs')],
+    });
+    if (!transformed?.ast) {
+        throw new Error('Babel transform failed');
+    }
+    return [transformed.ast, transformed.code ?? ''];
+};
+exports.emitCommonJS = emitCommonJS;
+const shaker = (evalConfig, ast, code, config, babel) => {
+    const [esmAst, esmCode, imports] = (0, exports.shakeToESM)(evalConfig, ast, code, config, babel);
+    const [, commonJSCode] = (0, exports.emitCommonJS)(evalConfig, esmAst, esmCode, babel);
+    return [esmAst, commonJSCode, imports];
+};
 exports.shaker = shaker;
 exports.default = exports.shaker;

package/types/transform/BaseEntrypoint.d.ts

@@ -12,11 +12,13 @@ export declare abstract class BaseEntrypoint {
     readonly only: string[];
     readonly parents: ParentEntrypoint[];
     readonly dependencies: Map<string, IEntrypointDependency>;
+    readonly invalidationDependencies: Map<string, IEntrypointDependency>;
+    readonly invalidateOnDependencyChange: Set<string>;
     static createExports: (log: Debugger) => Record<string | symbol, unknown>;
     readonly idx: string;
     readonly log: Debugger;
     readonly seqId: number;
-    protected constructor(services: Services, evaluatedOnly: string[], exports: Record<string | symbol, unknown> | undefined, generation: number, name: string, only: string[], parents: ParentEntrypoint[], dependencies: Map<string, IEntrypointDependency>);
+    protected constructor(services: Services, evaluatedOnly: string[], exports: Record<string | symbol, unknown> | undefined, generation: number, name: string, only: string[], parents: ParentEntrypoint[], dependencies: Map<string, IEntrypointDependency>, invalidationDependencies: Map<string, IEntrypointDependency>, invalidateOnDependencyChange: Set<string>);
     get exports(): Record<string | symbol, unknown>;
     set exports(value: unknown);
     get ref(): string;

package/types/transform/BaseEntrypoint.js

@@ -116,13 +116,15 @@ class BaseEntrypoint {
     only;
     parents;
     dependencies;
+    invalidationDependencies;
+    invalidateOnDependencyChange;
     static createExports = exports.createExports;
     idx;
     log;
     // eslint-disable-next-line no-plusplus
     seqId = entrypointSeqId++;
     #exports;
-    constructor(services, evaluatedOnly, exports, generation, name, only, parents, dependencies) {
+    constructor(services, evaluatedOnly, exports, generation, name, only, parents, dependencies, invalidationDependencies, invalidateOnDependencyChange) {
         this.services = services;
         this.evaluatedOnly = evaluatedOnly;
         this.generation = generation;
@@ -130,6 +132,8 @@ class BaseEntrypoint {
         this.only = only;
         this.parents = parents;
         this.dependencies = dependencies;
+        this.invalidationDependencies = invalidationDependencies;
+        this.invalidateOnDependencyChange = invalidateOnDependencyChange;
         this.idx = (0, getFileIdx_1.getFileIdx)(name);
         this.log =
             parents[0]?.log.extend(this.ref, '->') ?? services.log.extend(this.ref);

package/types/transform/Entrypoint.d.ts

@@ -10,6 +10,8 @@ export declare class Entrypoint extends BaseEntrypoint {
     readonly initialCode: string | undefined;
     protected readonly resolveTasks: Map<string, Promise<IEntrypointDependency>>;
     readonly dependencies: Map<string, IEntrypointDependency>;
+    readonly invalidationDependencies: Map<string, IEntrypointDependency>;
+    readonly invalidateOnDependencyChange: Set<string>;
     readonly evaluated = false;
     readonly loadedAndParsed: IEntrypointCode | IIgnoredEntrypoint;
     protected onSupersedeHandlers: Array<(newEntrypoint: Entrypoint) => void>;
@@ -35,16 +37,23 @@ export declare class Entrypoint extends BaseEntrypoint {
     protected static create(services: Services, parent: ParentEntrypoint | null, name: string, only: string[], loadedCode: string | undefined): Entrypoint | 'loop';
     private static innerCreate;
     addDependency(dependency: IEntrypointDependency): void;
+    addInvalidationDependency(dependency: IEntrypointDependency): void;
     addResolveTask(name: string, dependency: Promise<IEntrypointDependency>): void;
+    applyDeferredSupersede(): Entrypoint | null;
     assertNotSuperseded(): void;
     assertTransformed(): void;
-    createAction<TType extends ActionTypes, TAction extends ActionByType<TType>>(actionType: TType, data: TAction['data'], abortSignal?: AbortSignal | null): BaseAction<TAction>;
+    beginProcessing(): void;
+    createAction<TType extends ActionTypes, TAction extends ActionByType<TType>>(actionType: TType, data: TAction['data'], abortSignal?: AbortSignal | null, actionContext?: unknown): BaseAction<TAction>;
     createChild(name: string, only: string[], loadedCode?: string): Entrypoint | 'loop';
     createEvaluated(): EvaluatedEntrypoint;
+    endProcessing(): void;
     getDependency(name: string): IEntrypointDependency | undefined;
+    getInvalidationDependency(name: string): IEntrypointDependency | undefined;
+    markInvalidateOnDependencyChange(filename: string): void;
     getResolveTask(name: string): Promise<IEntrypointDependency> | undefined;
     hasWywMetadata(): boolean;
     onSupersede(callback: (newEntrypoint: Entrypoint) => void): () => void;
     setTransformResult(res: ITransformFileResult | null): void;
+    private deferOnlySupersede;
     private supersede;
 }

package/types/transform/Entrypoint.js

@@ -1,15 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entrypoint = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
 const ts_invariant_1 = require("ts-invariant");
 const BaseEntrypoint_1 = require("./BaseEntrypoint");
 const Entrypoint_helpers_1 = require("./Entrypoint.helpers");
-const isStaticallyEvaluatableModule_1 = require("./isStaticallyEvaluatableModule");
 const EvaluatedEntrypoint_1 = require("./EvaluatedEntrypoint");
 const AbortError_1 = require("./actions/AbortError");
 const BaseAction_1 = require("./actions/BaseAction");
 const UnprocessedEntrypointError_1 = require("./actions/UnprocessedEntrypointError");
+const parseRequest_1 = require("../utils/parseRequest");
 const EMPTY_FILE = '=== empty file ===';
+const DEFAULT_ACTION_CONTEXT = Symbol('defaultActionContext');
 function hasLoop(name, parent, processed = []) {
     if (parent.name === name || processed.includes(parent.name)) {
         return true;
@@ -26,18 +31,24 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     initialCode;
     resolveTasks;
     dependencies;
+    invalidationDependencies;
+    invalidateOnDependencyChange;
     evaluated = false;
     loadedAndParsed;
     onSupersedeHandlers = [];
     actionsCache = new Map();
     #hasWywMetadata = false;
+    #isProcessing = false;
+    #pendingOnly = null;
     #supersededWith = null;
     #transformResultCode = null;
-    constructor(services, parents, initialCode, name, only, exports, evaluatedOnly, loadedAndParsed, resolveTasks = new Map(), dependencies = new Map(), generation = 1) {
-        super(services, evaluatedOnly, exports, generation, name, only, parents, dependencies);
+    constructor(services, parents, initialCode, name, only, exports, evaluatedOnly, loadedAndParsed, resolveTasks = new Map(), dependencies = new Map(), invalidationDependencies = new Map(), invalidateOnDependencyChange = new Set(), generation = 1) {
+        super(services, evaluatedOnly, exports, generation, name, only, parents, dependencies, invalidationDependencies, invalidateOnDependencyChange);
         this.initialCode = initialCode;
         this.resolveTasks = resolveTasks;
         this.dependencies = dependencies;
+        this.invalidationDependencies = invalidationDependencies;
+        this.invalidateOnDependencyChange = invalidateOnDependencyChange;
         this.loadedAndParsed =
             loadedAndParsed ??
                 services.loadAndParseFn(services, name, initialCode, parents[0]?.log ?? services.log);
@@ -99,9 +110,18 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     static innerCreate(services, parent, name, only, loadedCode) {
         const { cache } = services;
         const cached = cache.get('entrypoints', name);
-        const changed = loadedCode !== undefined
-            ? cache.invalidateIfChanged(name, loadedCode, undefined, 'loaded')
-            : false;
+        let changed = false;
+        if (loadedCode !== undefined) {
+            changed = cache.invalidateIfChanged(name, loadedCode, undefined, 'loaded');
+        }
+        else if (cached && cached.initialCode === undefined) {
+            try {
+                changed = cache.invalidateIfChanged(name, node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(name), 'utf8'), undefined, 'fs');
+            }
+            catch {
+                changed = false;
+            }
+        }
         if (!cached?.evaluated && cached?.ignored) {
             return ['cached', cached];
         }
@@ -124,20 +144,18 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
                 return [isLoop ? 'loop' : 'cached', cached];
             }
             cached.log('is cached, but with different `only` %o (the cached one %o)', only, cached?.only);
-            return [isLoop ? 'loop' : 'created', cached.supersede(mergedOnly)];
-        }
-        const newEntrypoint = new Entrypoint(services, parent ? [parent] : [], loadedCode, name, mergedOnly, exports, evaluatedOnly, undefined, cached && 'resolveTasks' in cached ? cached.resolveTasks : undefined, cached && 'dependencies' in cached ? cached.dependencies : undefined, cached ? cached.generation + 1 : 1);
-        if (!newEntrypoint.ignored &&
-            !newEntrypoint.only.includes('*') &&
-            !newEntrypoint.only.includes('__wywPreval') &&
-            !newEntrypoint.only.includes('side-effect')) {
-            const { ast } = newEntrypoint.loadedAndParsed;
-            if (ast && (0, isStaticallyEvaluatableModule_1.isStaticallyEvaluatableModule)(ast)) {
-                newEntrypoint.log('[entrypoint] promote `only` to "*" for statically evaluatable module');
-                newEntrypoint.only.length = 0;
-                newEntrypoint.only.push('*');
+            if (cached.#isProcessing) {
+                cached.deferOnlySupersede(mergedOnly);
+                cached.log('is being processed, defer supersede (%o -> %o)', cached.only, mergedOnly);
+                return [isLoop ? 'loop' : 'cached', cached];
             }
+            return [isLoop ? 'loop' : 'created', cached.supersede(mergedOnly)];
         }
+        const newEntrypoint = new Entrypoint(services, parent ? [parent] : [], loadedCode, name, mergedOnly, exports, evaluatedOnly, undefined, cached && 'resolveTasks' in cached ? cached.resolveTasks : undefined, cached && 'dependencies' in cached ? cached.dependencies : undefined, cached && 'invalidationDependencies' in cached
+            ? cached.invalidationDependencies
+            : undefined, cached && 'invalidateOnDependencyChange' in cached
+            ? cached.invalidateOnDependencyChange
+            : undefined, cached ? cached.generation + 1 : 1);
         if (cached && !cached.evaluated) {
             cached.log('is cached, but with different code');
             cached.supersede(newEntrypoint);
@@ -148,9 +166,27 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
         this.resolveTasks.delete(dependency.source);
         this.dependencies.set(dependency.source, dependency);
     }
+    addInvalidationDependency(dependency) {
+        this.resolveTasks.delete(dependency.source);
+        this.invalidationDependencies.set(dependency.source, dependency);
+    }
     addResolveTask(name, dependency) {
         this.resolveTasks.set(name, dependency);
     }
+    applyDeferredSupersede() {
+        if (this.#supersededWith || this.#pendingOnly === null) {
+            return null;
+        }
+        const mergedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.only, this.#pendingOnly);
+        this.#pendingOnly = null;
+        if ((0, Entrypoint_helpers_1.isSuperSet)(this.only, mergedOnly)) {
+            return null;
+        }
+        this.log('apply deferred supersede (%o -> %o)', this.only, mergedOnly);
+        const nextEntrypoint = this.supersede(mergedOnly);
+        this.services.cache.add('entrypoints', this.name, nextEntrypoint);
+        return nextEntrypoint;
+    }
     assertNotSuperseded() {
         if (this.supersededWith) {
             this.log('superseded');
@@ -163,16 +199,23 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
             throw new UnprocessedEntrypointError_1.UnprocessedEntrypointError(this.supersededWith ?? this);
         }
     }
-    createAction(actionType, data, abortSignal = null) {
+    beginProcessing() {
+        this.#isProcessing = true;
+    }
+    createAction(actionType, data, abortSignal = null, actionContext = DEFAULT_ACTION_CONTEXT) {
         if (!this.actionsCache.has(actionType)) {
             this.actionsCache.set(actionType, new Map());
         }
-        const cache = this.actionsCache.get(actionType);
+        const contexts = this.actionsCache.get(actionType);
+        if (!contexts.has(actionContext)) {
+            contexts.set(actionContext, new Map());
+        }
+        const cache = contexts.get(actionContext);
         const cached = cache.get(data);
         if (cached && !cached.abortSignal?.aborted) {
             return cached;
         }
-        const newAction = new BaseAction_1.BaseAction(actionType, this.services, this, data, abortSignal);
+        const newAction = new BaseAction_1.BaseAction(actionType, this.services, this, data, abortSignal, actionContext);
         cache.set(data, newAction);
         this.services.eventEmitter.entrypointEvent(this.seqId, {
             type: 'actionCreated',
@@ -187,13 +230,22 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
     createEvaluated() {
         const evaluatedOnly = (0, Entrypoint_helpers_1.mergeOnly)(this.evaluatedOnly, this.only);
         this.log('create EvaluatedEntrypoint for %o', evaluatedOnly);
-        const evaluated = new EvaluatedEntrypoint_1.EvaluatedEntrypoint(this.services, evaluatedOnly, this.exportsProxy, this.generation + 1, this.name, this.only, this.parents, this.dependencies);
+        const evaluated = new EvaluatedEntrypoint_1.EvaluatedEntrypoint(this.services, evaluatedOnly, this.exportsProxy, this.generation + 1, this.name, this.only, this.parents, this.dependencies, this.invalidationDependencies, this.invalidateOnDependencyChange);
         evaluated.initialCode = this.initialCode;
         return evaluated;
     }
+    endProcessing() {
+        this.#isProcessing = false;
+    }
     getDependency(name) {
         return this.dependencies.get(name);
     }
+    getInvalidationDependency(name) {
+        return this.invalidationDependencies.get(name);
+    }
+    markInvalidateOnDependencyChange(filename) {
+        this.invalidateOnDependencyChange.add(filename);
+    }
     getResolveTask(name) {
         return this.resolveTasks.get(name);
     }
@@ -221,10 +273,16 @@ class Entrypoint extends BaseEntrypoint_1.BaseEntrypoint {
             type: 'setTransformResult',
         });
     }
+    deferOnlySupersede(only) {
+        this.#pendingOnly = this.#pendingOnly
+            ? (0, Entrypoint_helpers_1.mergeOnly)(this.#pendingOnly, only)
+            : [...only];
+    }
     supersede(newOnlyOrEntrypoint) {
+        this.#pendingOnly = null;
         const newEntrypoint = newOnlyOrEntrypoint instanceof Entrypoint
             ? newOnlyOrEntrypoint
-            : new Entrypoint(this.services, this.parents, this.initialCode, this.name, newOnlyOrEntrypoint, this.exports, this.evaluatedOnly, this.loadedAndParsed, this.resolveTasks, this.dependencies, this.generation + 1);
+            : new Entrypoint(this.services, this.parents, this.initialCode, this.name, newOnlyOrEntrypoint, this.exports, this.evaluatedOnly, this.loadedAndParsed, this.resolveTasks, this.dependencies, this.invalidationDependencies, this.invalidateOnDependencyChange, this.generation + 1);
         this.services.eventEmitter.entrypointEvent(this.seqId, {
             type: 'superseded',
             with: newEntrypoint.seqId,

package/types/transform/EvaluatedEntrypoint.d.ts

@@ -9,6 +9,8 @@ export interface IEvaluatedEntrypoint {
     generation: number;
     ignored: false;
     initialCode?: string;
+    invalidationDependencies: Map<string, IEntrypointDependency>;
+    invalidateOnDependencyChange: Set<string>;
     log: Debugger;
     only: string[];
 }