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

package/types/eval/broker.js

@@ -11,8 +11,8 @@ import { isStaticallyEvaluatableModule } from '../transform/isStaticallyEvaluata
 import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey, } from '../utils/importOverrides';
 import { getFileIdx } from '../utils/getFileIdx';
 import { collectOxcExportsAndImports } from '../utils/collectOxcExportsAndImports';
+import { resolveWithNativeResolver } from '../utils/nativeResolver';
 import { parseRequest, stripQueryAndHash } from '../utils/parseRequest';
-import { resolveFilenameWithConditions } from '../utils/resolveWithConditions';
 import { hasCachedWywPrevalExport, } from '../utils/hasCachedWywPrevalExport';
 import { isSuperSet, mergeOnly } from '../transform/Entrypoint.helpers';
 import { oxcShaker } from '../shaker';
@@ -22,19 +22,6 @@ import { prepareModuleOnDemand, } from './prepareModuleOnDemand';
 import { deserializeValue, encodeGlobals, serializeValue, } from './serialize';
 import { createWriteQueue, writeToStream } from './writeQueue';
 const DefaultModuleImplementation = NativeModule;
-const CJS_DEFAULT_CONDITIONS = ['require', 'node', 'default'];
-const expandConditions = (conditionNames) => {
-    const result = new Set();
-    conditionNames.forEach((name) => {
-        if (name === '...') {
-            CJS_DEFAULT_CONDITIONS.forEach((condition) => result.add(condition));
-            return;
-        }
-        result.add(name);
-    });
-    return result;
-};
-const NOOP = () => { };
 const isBuiltinSpecifier = (specifier) => {
     const normalized = specifier.startsWith('node:')
         ? specifier.slice(5)
@@ -187,7 +174,7 @@ const getSerializableStaticImportKeys = (services, id, cachedEntrypoint, require
     return requiredOnly.includes('*') ? evaluatedOnly : requiredOnly;
 };
 const DEFAULT_EVAL_OPTIONS = {
-    mode: 'strict',
+    errors: 'strict',
     require: 'warn-and-run',
     resolver: 'bundler',
 };
@@ -236,6 +223,32 @@ const resolveDebugEvalDir = () => {
 };
 const debugEvalDir = resolveDebugEvalDir();
 let debugEvalDirReady = false;
+const toBase64 = (value) => Buffer.from(value, 'utf8').toString('base64');
+const toJsonBase64 = (value) => toBase64(JSON.stringify(value));
+const serializedExportsToDebugValues = (serializedExports) => ({
+    exports: Object.fromEntries(Object.entries(serializedExports).map(([key, serialized]) => [
+        key,
+        {
+            serialized,
+            status: 'serialized',
+        },
+    ])),
+});
+const getDebugValuesStatus = (values) => {
+    const statuses = [
+        ...Object.values(values?.exports ?? {}),
+        ...Object.values(values?.preval ?? {}),
+    ].map((value) => value.status);
+    if (statuses.length === 0) {
+        return 'none';
+    }
+    const hasSerialized = statuses.includes('serialized');
+    const hasStringified = statuses.includes('stringified');
+    if (hasSerialized && hasStringified) {
+        return 'mixed';
+    }
+    return hasStringified ? 'stringified' : 'serialized';
+};
 const ensureDebugEvalDir = () => {
     if (!debugEvalDir || debugEvalDirReady) {
         return;
@@ -365,7 +378,7 @@ const buildRunnerInitPayload = (services, entrypoint, featuresOverride) => {
         evalOptions: {
             globals: encodeGlobalsCached(sanitizedGlobals),
             importOverrides,
-            mode: evalOptions.mode ?? 'strict',
+            errors: evalOptions.errors ?? 'strict',
             require: evalOptions.require ?? 'warn-and-run',
             root,
             extensions,
@@ -703,9 +716,6 @@ const canonicalizeForHash = (value) => {
     }
     return value;
 };
-const getInitPayloadKey = (payload) => createHash('sha256')
-    .update(JSON.stringify(canonicalizeForHash(payload)))
-    .digest('hex');
 // Hash everything in the init payload that affects whether the runner needs
 // a fresh INIT — i.e. everything except `entrypoint` (which only affects
 // __filename/__dirname rebinding, not context reuse). The broker memoizes
@@ -713,7 +723,8 @@ const getInitPayloadKey = (payload) => createHash('sha256')
 // with one SHA-256 of the stable bits + a cheap string concat per
 // entrypoint.
 const getStableInitPayloadHash = (payload) => {
-    const { entrypoint: _entrypoint, ...stable } = payload;
+    const { entrypoint, ...stable } = payload;
+    void entrypoint;
     return createHash('sha256')
         .update(JSON.stringify(canonicalizeForHash(stable)))
         .digest('hex');
@@ -769,6 +780,12 @@ export class EvalBroker {
     loadInFlight = new Map();
     importsByModule = new Map();
     onlyByModule = new Map();
+    // Modules that are part of the current eval session's link graph. Used
+    // to scope `mergeKnownDependencyOnly` to entrypoints that share the
+    // current runner's VM, instead of unioning across every cached
+    // entrypoint project-wide. Cleared whenever the runner is killed or
+    // respawned (mirrors lastSentLoadByModule).
+    sessionLinkGraph = new Set();
     runtimeDependenciesByModule = new Map();
     emittedDependencies = new Set();
     // Mirrors the runner's view: for each module id, the (hash, mergedOnly) of
@@ -792,6 +809,7 @@ export class EvalBroker {
     // re-canonicalizing+stringifying+SHA-256ing the whole payload per call.
     stableInitHashCache = null;
     evalSeq = 0;
+    evalFileDebugLines = null;
     happyDomDisabled = false;
     happyDomDisableWarned = false;
     activeResolveRootId = null;
@@ -908,6 +926,7 @@ export class EvalBroker {
         this.activeResolveRootId = resolveRootId;
         this.resetPerEntrypointState(entrypoint);
         this.evalSeq += 1;
+        this.evalFileDebugLines = activeServices.eventEmitter.enabled ? [] : null;
         if (debugEvalDir) {
             debugAction({
                 type: 'eval:start',
@@ -919,6 +938,7 @@ export class EvalBroker {
         try {
             await this.initRunner(entrypoint);
             const payload = await this.request('EVAL', { id: entrypoint.name }, EVAL_TIMEOUT_MS);
+            this.flushEvalFileDebugLines(payload.debugEvalFiles);
             if (debugEvalDir) {
                 debugAction({
                     type: 'eval:finish',
@@ -944,11 +964,64 @@ export class EvalBroker {
             };
         }
         finally {
+            this.evalFileDebugLines = null;
             if (this.activeResolveRootId === resolveRootId) {
                 this.activeResolveRootId = null;
             }
         }
     }
+    recordEvalFileDebugLine(payload, prepared, shouldShipCode) {
+        if (!this.evalFileDebugLines) {
+            return;
+        }
+        if (shouldShipCode && prepared.code) {
+            this.evalFileDebugLines.push({
+                contentBase64: toBase64(prepared.code),
+                evalSeq: this.evalSeq,
+                hash: prepared.hash ?? null,
+                id: payload.id,
+                importer: payload.importerId ?? null,
+                only: prepared.only,
+                payloadKind: 'code',
+                request: payload.request ?? null,
+                type: 'eval-file',
+                valueStatus: 'none',
+                valuesBase64: null,
+            });
+            return;
+        }
+        if (prepared.exports) {
+            const values = serializedExportsToDebugValues(prepared.exports);
+            this.evalFileDebugLines.push({
+                contentBase64: null,
+                evalSeq: this.evalSeq,
+                hash: prepared.hash ?? null,
+                id: payload.id,
+                importer: payload.importerId ?? null,
+                only: prepared.only,
+                payloadKind: 'serialized-exports',
+                request: payload.request ?? null,
+                type: 'eval-file',
+                valueStatus: getDebugValuesStatus(values),
+                valuesBase64: toJsonBase64(values),
+            });
+        }
+    }
+    flushEvalFileDebugLines(valuesById) {
+        const lines = this.evalFileDebugLines;
+        if (!lines) {
+            return;
+        }
+        for (const line of lines) {
+            this.currentServices.eventEmitter.single({
+                ...line,
+                valueStatus: line.valueStatus === 'none'
+                    ? getDebugValuesStatus(valuesById?.[line.id])
+                    : line.valueStatus,
+                valuesBase64: line.valuesBase64 ?? toJsonBase64(valuesById?.[line.id] ?? {}),
+            });
+        }
+    }
     resetPerEntrypointState(entrypoint) {
         this.runtimeDependenciesByModule.clear();
         this.emittedDependencies.clear();
@@ -956,6 +1029,8 @@ export class EvalBroker {
         this.onlyByModule.clear();
         this.resolveCache.clear();
         this.resolveInFlight.clear();
+        this.sessionLinkGraph.clear();
+        this.sessionLinkGraph.add(entrypoint.name);
         this.onlyByModule.set(entrypoint.name, ['__wywPreval']);
     }
     applyModuleExports(modules) {
@@ -1001,6 +1076,7 @@ export class EvalBroker {
         this.lastInitKey = null;
         this.lastHappyDomEnabled = false;
         this.lastSentLoadByModule.clear();
+        this.sessionLinkGraph.clear();
         this.stableInitHashCache = null;
         flushDebugStreams();
     }
@@ -1037,6 +1113,7 @@ export class EvalBroker {
             this.lastInitKey = null;
             this.lastHappyDomEnabled = false;
             this.lastSentLoadByModule.clear();
+            this.sessionLinkGraph.clear();
         });
     }
     async ensureRunner() {
@@ -1147,6 +1224,7 @@ export class EvalBroker {
         // New process ⇒ runner's moduleCache/moduleHashes are empty, so our mirror
         // of "what we already shipped" is stale.
         this.lastSentLoadByModule.clear();
+        this.sessionLinkGraph.clear();
     }
     getStableInitHash(services, features) {
         const pluginOptionsRef = services.options.pluginOptions;
@@ -1178,13 +1256,18 @@ export class EvalBroker {
     async initRunner(entrypoint) {
         const features = this.getRunnerFeatures();
         const stableHash = this.getStableInitHash(this.currentServices, features);
-        const initKey = `${stableHash}::${entrypoint.name}`;
+        const debugEvalFiles = this.currentServices.eventEmitter.enabled;
+        const debugEvalFilesKeyPart = debugEvalFiles ? '1' : '0';
+        const initKey = `${stableHash}::${entrypoint.name}::debugEvalFiles:${debugEvalFilesKeyPart}`;
         if (this.lastInitKey === initKey) {
             return;
         }
         const nextHappyDomEnabled = isFeatureEnabled(features, 'happyDOM', entrypoint.name);
         const payload = buildRunnerInitPayload(this.services, entrypoint, features);
         payload.reuseModules = true;
+        if (debugEvalFiles) {
+            payload.debugEvalFiles = true;
+        }
         const timeoutMs = this.getInitTimeoutMs(entrypoint, features);
         if (this.runner &&
             this.lastInitKey !== null &&
@@ -1205,8 +1288,11 @@ export class EvalBroker {
                     const fallbackFeatures = this.getRunnerFeatures();
                     const fallbackPayload = buildRunnerInitPayload(this.services, entrypoint, fallbackFeatures);
                     fallbackPayload.reuseModules = true;
+                    if (debugEvalFiles) {
+                        fallbackPayload.debugEvalFiles = true;
+                    }
                     await this.request('INIT', fallbackPayload, INIT_TIMEOUT_MS);
-                    this.lastInitKey = `${this.getStableInitHash(this.currentServices, fallbackFeatures)}::${entrypoint.name}`;
+                    this.lastInitKey = `${this.getStableInitHash(this.currentServices, fallbackFeatures)}::${entrypoint.name}::debugEvalFiles:${debugEvalFilesKeyPart}`;
                     this.lastHappyDomEnabled = false;
                     return;
                 }
@@ -1229,8 +1315,11 @@ export class EvalBroker {
                 const fallbackFeatures = this.getRunnerFeatures();
                 const fallbackPayload = buildRunnerInitPayload(this.services, entrypoint, fallbackFeatures);
                 fallbackPayload.reuseModules = true;
+                if (debugEvalFiles) {
+                    fallbackPayload.debugEvalFiles = true;
+                }
                 await this.request('INIT', fallbackPayload, INIT_TIMEOUT_MS);
-                this.lastInitKey = getInitPayloadKey(fallbackPayload);
+                this.lastInitKey = `${this.getStableInitHash(this.currentServices, fallbackFeatures)}::${entrypoint.name}::debugEvalFiles:${debugEvalFilesKeyPart}`;
                 this.lastHappyDomEnabled = false;
                 return;
             }
@@ -1299,16 +1388,29 @@ export class EvalBroker {
                     // context rebuild or reuseModules:false). Drop our shipped-code
                     // mirror so handleLoad ships fresh code on the next LOAD.
                     this.lastSentLoadByModule.clear();
+                    this.sessionLinkGraph.clear();
                 }
                 this.resolvePending(message.id, {});
                 return;
-            case 'EVAL_RESULT':
+            case 'EVAL_RESULT': {
+                // Runner reports any ids it dropped from its caches during this
+                // session (e.g. modules whose link errored after a transient missing
+                // import). Mirror those evictions here — otherwise lastSentLoadByModule
+                // would keep claiming the runner has them and handleLoad would ship
+                // empty `code` on the next session, leaving the runner stuck.
+                const evictedIds = message.payload?.evictedIds;
+                if (evictedIds && evictedIds.length > 0) {
+                    for (const evictedId of evictedIds) {
+                        this.lastSentLoadByModule.delete(evictedId);
+                    }
+                }
                 if (message.error) {
                     this.rejectPending(message.id, message.error);
                     return;
                 }
                 this.resolvePending(message.id, message.payload);
                 return;
+            }
             case 'RESOLVE':
                 this.handleResolve(message.id, message.payload).catch((error) => {
                     void this.sendMessage({
@@ -1384,7 +1486,7 @@ export class EvalBroker {
             },
         });
     }
-    normalizeResolvedId(resolvedId, specifier, importerId) {
+    normalizeResolvedId(resolvedId, specifier, importerId, kind) {
         const stripped = stripQueryAndHash(resolvedId);
         if (!stripped)
             return resolvedId;
@@ -1416,17 +1518,29 @@ export class EvalBroker {
         if (importerId) {
             try {
                 const importerFile = stripQueryAndHash(importerId);
-                const resolved = DefaultModuleImplementation._resolveFilename(stripped, {
-                    id: importerFile,
-                    filename: importerFile,
-                    paths: DefaultModuleImplementation._nodeModulePaths(path.dirname(importerFile)),
+                const { conditionNames, extensions, oxcOptions } = this.services.options.pluginOptions;
+                const resolved = resolveWithNativeResolver({
+                    conditionNames,
+                    extensions,
+                    importer: importerFile,
+                    kind,
+                    oxcOptions,
+                    specifier: resolvedId,
                 });
                 if (resolved && resolved !== stripped) {
-                    return `${resolved}${suffix}`;
+                    return resolved;
                 }
             }
-            catch {
-                // ignore fallback failures
+            catch (error) {
+                if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+                    // eslint-disable-next-line no-console
+                    console.warn('[wyw-eval:resolve:native-normalize-miss]', {
+                        specifier,
+                        importerId,
+                        kind,
+                        error,
+                    });
+                }
             }
         }
         return resolvedId;
@@ -1460,7 +1574,7 @@ export class EvalBroker {
         }
         const strippedSpecifier = stripQueryAndHash(specifier);
         if (path.isAbsolute(strippedSpecifier)) {
-            const normalized = this.normalizeResolvedId(specifier, specifier, importerId);
+            const normalized = this.normalizeResolvedId(specifier, specifier, importerId, kind);
             const overridden = this.applyImportOverrides({
                 source: specifier,
                 resolved: normalized,
@@ -1478,15 +1592,15 @@ export class EvalBroker {
                     only: ['*'],
                 });
             }
-            const normalized = this.normalizeResolvedId(cached.resolvedId, specifier, importerId);
+            const normalized = this.normalizeResolvedId(cached.resolvedId, specifier, importerId, kind);
             const overridden = this.applyImportOverrides({
                 source: specifier,
                 resolved: normalized,
                 only,
                 external: cached.external,
             }, importerId, stack);
-            if (cached.usedNodeFallback) {
-                this.maybeWarnNodeFallback({
+            if (cached.usedNativeFallback) {
+                this.maybeWarnNativeFallback({
                     importerId,
                     specifier,
                     resolvedId: normalized,
@@ -1504,15 +1618,15 @@ export class EvalBroker {
                     only: ['*'],
                 });
             }
-            const normalized = this.normalizeResolvedId(cachedResult.resolvedId, specifier, importerId);
+            const normalized = this.normalizeResolvedId(cachedResult.resolvedId, specifier, importerId, kind);
             const overridden = this.applyImportOverrides({
                 source: specifier,
                 resolved: normalized,
                 only,
                 external: cachedResult.external,
             }, importerId, stack);
-            if (cachedResult.usedNodeFallback) {
-                this.maybeWarnNodeFallback({
+            if (cachedResult.usedNativeFallback) {
+                this.maybeWarnNativeFallback({
                     importerId,
                     specifier,
                     resolvedId: normalized,
@@ -1525,7 +1639,7 @@ export class EvalBroker {
             if (evalOptions.customResolver) {
                 const customResolved = await evalOptions.customResolver(specifier, importerId, kind);
                 if (customResolved) {
-                    const normalized = this.normalizeResolvedId(customResolved.id, specifier, importerId);
+                    const normalized = this.normalizeResolvedId(customResolved.id, specifier, importerId, kind);
                     if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
                         // eslint-disable-next-line no-console
                         console.warn('[wyw-eval:resolve:custom]', {
@@ -1545,7 +1659,47 @@ export class EvalBroker {
                     return { resolvedId: null };
                 }
             }
-            if (evalOptions.resolver !== 'node') {
+            if (evalOptions.resolver === 'hybrid') {
+                try {
+                    const nativeResolved = this.resolveWithNativeFallback(specifier, importerId, kind);
+                    if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+                        // eslint-disable-next-line no-console
+                        console.warn('[wyw-eval:resolve:native]', {
+                            specifier,
+                            importerId,
+                            resolved: nativeResolved.resolvedId,
+                        });
+                    }
+                    return nativeResolved;
+                }
+                catch (error) {
+                    if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+                        // eslint-disable-next-line no-console
+                        console.warn('[wyw-eval:resolve:native-miss]', {
+                            specifier,
+                            importerId,
+                            kind,
+                            error,
+                        });
+                    }
+                    // Hybrid mode lets the bundler resolver handle aliases, virtual IDs,
+                    // and other specifiers that the native resolver cannot resolve.
+                }
+            }
+            if (evalOptions.resolver === 'native') {
+                const nativeResolved = this.resolveWithNativeFallback(specifier, importerId, kind);
+                if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+                    // eslint-disable-next-line no-console
+                    console.warn('[wyw-eval:resolve:native]', {
+                        specifier,
+                        importerId,
+                        resolved: nativeResolved.resolvedId,
+                    });
+                }
+                return nativeResolved;
+            }
+            if (evalOptions.resolver === 'bundler' ||
+                evalOptions.resolver === 'hybrid') {
                 let resolved = null;
                 try {
                     resolved = await this.asyncResolve(specifier, importerId, stack);
@@ -1554,7 +1708,7 @@ export class EvalBroker {
                     resolved = null;
                 }
                 if (resolved) {
-                    const normalized = this.normalizeResolvedId(resolved, specifier, importerId);
+                    const normalized = this.normalizeResolvedId(resolved, specifier, importerId, kind);
                     if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
                         // eslint-disable-next-line no-console
                         console.warn('[wyw-eval:resolve:async]', {
@@ -1569,19 +1723,19 @@ export class EvalBroker {
                     };
                 }
             }
-            if (evalOptions.resolver === 'node' || evalOptions.require !== 'off') {
-                const nodeResolved = this.resolveWithNodeFallback(specifier, importerId);
+            if (evalOptions.resolver === 'bundler' && evalOptions.require !== 'off') {
+                const nativeResolved = this.resolveWithNativeFallback(specifier, importerId, kind);
                 if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
                     // eslint-disable-next-line no-console
-                    console.warn('[wyw-eval:resolve:node]', {
+                    console.warn('[wyw-eval:resolve:native-fallback]', {
                         specifier,
                         importerId,
-                        resolved: nodeResolved.resolvedId,
+                        resolved: nativeResolved.resolvedId,
                     });
                 }
                 return {
-                    ...nodeResolved,
-                    usedNodeFallback: evalOptions.resolver !== 'node',
+                    ...nativeResolved,
+                    usedNativeFallback: true,
                 };
             }
             if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
@@ -1609,8 +1763,8 @@ export class EvalBroker {
                 only,
                 external: result.external,
             }, importerId, stack);
-            if (result.usedNodeFallback && result.resolvedId) {
-                this.maybeWarnNodeFallback({
+            if (result.usedNativeFallback && result.resolvedId) {
+                this.maybeWarnNativeFallback({
                     importerId,
                     specifier,
                     resolvedId: result.resolvedId,
@@ -1716,56 +1870,33 @@ export class EvalBroker {
             only: nextOnly,
         };
     }
-    resolveWithNodeFallback(specifier, importerId) {
-        const extensions = DefaultModuleImplementation._extensions;
-        const added = [];
-        const { conditionNames } = this.services.options.pluginOptions;
-        const conditions = conditionNames?.length
-            ? expandConditions(conditionNames)
-            : undefined;
+    resolveWithNativeFallback(specifier, importerId, kind) {
+        const { conditionNames, extensions, oxcOptions } = this.services.options.pluginOptions;
         try {
-            this.services.options.pluginOptions.extensions.forEach((ext) => {
-                if (ext in extensions)
-                    return;
-                extensions[ext] = NOOP;
-                added.push(ext);
+            const resolved = resolveWithNativeResolver({
+                conditionNames,
+                extensions,
+                importer: importerId,
+                kind,
+                oxcOptions,
+                specifier,
             });
-            const filename = importerId;
-            const strippedId = stripQueryAndHash(specifier);
-            let resolved;
-            try {
-                resolved = resolveFilenameWithConditions(DefaultModuleImplementation, strippedId, {
-                    id: filename,
-                    filename,
-                    paths: DefaultModuleImplementation._nodeModulePaths(path.dirname(filename)),
-                }, conditions);
-            }
-            catch (error) {
-                throw new Error([
-                    `[wyw-in-js] Node resolver failed during eval.`,
-                    ``,
-                    `importer: ${filename}`,
-                    `source:   ${specifier}`,
-                    ``,
-                    `error: ${error instanceof Error ? error.message : String(error)}`,
-                ].join('\n'));
-            }
-            const isFileSpecifier = strippedId.startsWith('.') || path.isAbsolute(strippedId);
-            if (isFileSpecifier &&
-                path.extname(strippedId) === '' &&
-                resolved.endsWith('.cjs') &&
-                fs.existsSync(`${resolved.slice(0, -4)}.js`)) {
-                resolved = `${resolved.slice(0, -4)}.js`;
-            }
             return {
-                resolvedId: this.normalizeResolvedId(resolved, specifier, importerId),
+                resolvedId: this.normalizeResolvedId(resolved, specifier, importerId, kind),
             };
         }
-        finally {
-            added.forEach((ext) => delete extensions[ext]);
+        catch (error) {
+            throw new Error([
+                `[wyw-in-js] Native resolver failed during eval.`,
+                ``,
+                `importer: ${importerId}`,
+                `source:   ${specifier}`,
+                ``,
+                `error: ${error instanceof Error ? error.message : String(error)}`,
+            ].join('\n'));
         }
     }
-    maybeWarnNodeFallback({ importerId, specifier, resolvedId, kind, }) {
+    maybeWarnNativeFallback({ importerId, specifier, resolvedId, kind, }) {
         const evalOptions = getEvalOptions(this.services);
         const { root } = this.services.options;
         const keyInfo = toImportKey({
@@ -1784,7 +1915,7 @@ export class EvalBroker {
         }
         if (policy === 'error') {
             throw new Error([
-                `[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+                `[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
                 ``,
                 `importer: ${importerId}`,
                 `source:   ${specifier}`,
@@ -1800,7 +1931,7 @@ export class EvalBroker {
         if (policy === 'warn' && !warnedUnknownImports.has(keyInfo.key)) {
             warnedUnknownImports.add(keyInfo.key);
             const warningMessage = [
-                `[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+                `[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
                 ``,
                 `importer: ${importerId}`,
                 `source:   ${specifier}`,
@@ -1864,6 +1995,7 @@ export class EvalBroker {
                 ts: performance.now(),
             });
         }
+        this.recordEvalFileDebugLine(payload, prepared, shouldShipCode);
         await this.sendLoadResult(id, {
             id: payload.id,
             code: shouldShipCode ? prepared.code : '',
@@ -1881,6 +2013,14 @@ export class EvalBroker {
                 only: merged,
             });
         }
+        // Session link graph tracks every module that's been admitted into
+        // the current runner's VM. mergeKnownDependencyOnly uses this to
+        // narrow its consumer-set to entrypoints actually linking against
+        // the same module instance.
+        this.sessionLinkGraph.add(payload.id);
+        if (payload.importerId) {
+            this.sessionLinkGraph.add(payload.importerId);
+        }
     }
     async loadModule({ id, importerId, request, }) {
         const actionEntrypoint = importerId ?? id;
@@ -2222,6 +2362,15 @@ export class EvalBroker {
         }
         let mergedOnly = storedOnly;
         for (const cachedEntrypoint of this.services.cache.entrypoints.values()) {
+            // Scope the union to entrypoints that are part of the CURRENT
+            // session's link graph. Cached entrypoints from prior transforms
+            // already evaluated against their own VMs; their imports must not
+            // widen this load. Empty session graph (initial load) falls back
+            // to project-wide for safety.
+            if (this.sessionLinkGraph.size > 0 &&
+                !this.sessionLinkGraph.has(cachedEntrypoint.name)) {
+                continue;
+            }
             const { dependencies } = cachedEntrypoint;
             if (!dependencies) {
                 continue;

package/types/eval/protocol.d.ts

@@ -2,7 +2,7 @@ import type { EvalResolverKind, EvalWarning, FeatureFlags, ImportOverrides } fro
 import type { SerializedError, SerializedValue } from './serialize';
 export type EvalRunnerInitPayload = {
     evalOptions: {
-        mode: 'strict' | 'loose';
+        errors: 'strict' | 'loose';
         require: 'warn-and-run' | 'error' | 'off';
         globals: Record<string, unknown>;
         importOverrides?: ImportOverrides;
@@ -10,6 +10,7 @@ export type EvalRunnerInitPayload = {
         extensions?: string[];
     };
     features: FeatureFlags<'happyDOM'>;
+    debugEvalFiles?: boolean;
     entrypoint: string;
     reuseModules?: boolean;
 };
@@ -19,6 +20,19 @@ export type EvalRequest = {
 export type EvalResultPayload = {
     values: Record<string, SerializedValue> | null;
     modules?: Record<string, Record<string, SerializedValue>>;
+    debugEvalFiles?: Record<string, DebugEvalFileValues>;
+};
+export type DebugEvalFileValue = {
+    serialized: SerializedValue;
+    status: 'serialized';
+} | {
+    reason: string;
+    status: 'stringified';
+    stringified: string;
+};
+export type DebugEvalFileValues = {
+    exports?: Record<string, DebugEvalFileValue>;
+    preval?: Record<string, DebugEvalFileValue>;
 };
 export type ResolveRequestPayload = {
     specifier: string;