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

package/types/cache.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformCacheCollection = void 0;
-const crypto_1 = require("crypto");
-const node_fs_1 = __importDefault(require("node:fs"));
-const shared_1 = require("@wyw-in-js/shared");
-const getFileIdx_1 = require("./utils/getFileIdx");
-const parseRequest_1 = require("./utils/parseRequest");
+import { createHash } from 'crypto';
+import fs from 'node:fs';
+import { logger } from '@wyw-in-js/shared';
+import { getFileIdx } from './utils/getFileIdx';
+import { stripQueryAndHash } from './utils/parseRequest';
 function hashContent(content) {
-    return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    return createHash('sha256').update(content).digest('hex');
 }
 function isMissingFileError(error) {
     if (!error || typeof error !== 'object') {
@@ -19,13 +13,13 @@ function isMissingFileError(error) {
     const { code } = error;
     return code === 'ENOENT' || code === 'ENOTDIR';
 }
-const cacheLogger = shared_1.logger.extend('cache');
+const cacheLogger = logger.extend('cache');
 const cacheNames = ['barrelManifests', 'entrypoints', 'exports'];
 const loggers = cacheNames.reduce((acc, key) => ({
     ...acc,
     [key]: cacheLogger.extend(key),
 }), {});
-class TransformCacheCollection {
+export class TransformCacheCollection {
     barrelManifests;
     entrypoints;
     exports;
@@ -33,30 +27,67 @@ class TransformCacheCollection {
     contentHashes = new Map();
     fileMtimes = new Map();
     exportDependencies = new Map();
+    keySalt = null;
+    invalidatedFiles = new Map();
+    consumedInvalidationVersions = new Map();
     constructor(caches = {}) {
         this.barrelManifests = caches.barrelManifests || new Map();
         this.entrypoints = caches.entrypoints || new Map();
         this.exports = caches.exports || new Map();
     }
+    setKeySalt(keySalt) {
+        if (this.keySalt === keySalt)
+            return;
+        const prevKeySalt = this.keySalt;
+        this.keySalt = keySalt;
+        if (prevKeySalt === null && keySalt) {
+            const migrate = (cache) => {
+                const entries = Array.from(cache.entries());
+                cache.clear();
+                entries.forEach(([key, value]) => {
+                    cache.set(this.getKey(key), value);
+                });
+            };
+            migrate(this.barrelManifests);
+            migrate(this.entrypoints);
+            migrate(this.exports);
+            migrate(this.barrelManifestDependencies);
+            migrate(this.exportDependencies);
+            return;
+        }
+        this.barrelManifests.clear();
+        this.entrypoints.clear();
+        this.exports.clear();
+        this.clearCacheDependencies('all');
+    }
+    getKey(key) {
+        if (!this.keySalt)
+            return key;
+        return `${key}::${this.keySalt}`;
+    }
+    getKeySalt() {
+        return this.keySalt;
+    }
     add(cacheName, key, value) {
         const cache = this[cacheName];
-        loggers[cacheName]('%s:add %s %f', (0, getFileIdx_1.getFileIdx)(key), key, () => {
+        const cacheKey = this.getKey(key);
+        loggers[cacheName]('%s:add %s %f', getFileIdx(key), key, () => {
             if (value === undefined) {
-                return cache.has(key) ? 'removed' : 'noop';
+                return cache.has(cacheKey) ? 'removed' : 'noop';
             }
-            if (!cache.has(key)) {
+            if (!cache.has(cacheKey)) {
                 return 'added';
             }
-            return cache.get(key) === value ? 'unchanged' : 'updated';
+            return cache.get(cacheKey) === value ? 'unchanged' : 'updated';
         });
         if (value === undefined) {
-            cache.delete(key);
+            cache.delete(cacheKey);
             this.contentHashes.delete(key);
             this.clearCacheDependencies(cacheName, key);
             return;
         }
         this.clearCacheDependencies(cacheName, key);
-        cache.set(key, value);
+        cache.set(cacheKey, value);
         if ('initialCode' in value) {
             const maybeOriginalCode = value
                 .originalCode;
@@ -74,7 +105,7 @@ class TransformCacheCollection {
                 return;
             }
             try {
-                const fileContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(key), 'utf8');
+                const fileContent = fs.readFileSync(stripQueryAndHash(key), 'utf8');
                 this.setContentHash(key, source, hashContent(fileContent));
             }
             catch {
@@ -82,9 +113,9 @@ class TransformCacheCollection {
             }
             return;
         }
-        if (cacheName === 'barrelManifests') {
+        if (cacheName === 'barrelManifests' || cacheName === 'exports') {
             try {
-                const fileContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(key), 'utf8');
+                const fileContent = fs.readFileSync(stripQueryAndHash(key), 'utf8');
                 this.setContentHash(key, 'fs', hashContent(fileContent));
             }
             catch {
@@ -109,76 +140,65 @@ class TransformCacheCollection {
     }
     get(cacheName, key) {
         const cache = this[cacheName];
-        const res = cache.get(key);
+        const res = cache.get(this.getKey(key));
         loggers[cacheName]('get', key, res === undefined ? 'miss' : 'hit');
         return res;
     }
     has(cacheName, key) {
         const cache = this[cacheName];
-        const res = cache.has(key);
+        const res = cache.has(this.getKey(key));
         loggers[cacheName]('has', key, res);
         return res;
     }
     invalidate(cacheName, key) {
         const cache = this[cacheName];
-        if (!cache.has(key)) {
+        const cacheKey = this.getKey(key);
+        if (!cache.has(cacheKey)) {
             return;
         }
         loggers[cacheName]('invalidate', key);
-        cache.delete(key);
+        cache.delete(cacheKey);
         this.clearCacheDependencies(cacheName, key);
     }
     invalidateForFile(filename) {
         cacheNames.forEach((cacheName) => {
             this.invalidate(cacheName, filename);
         });
+        const key = stripQueryAndHash(filename);
+        const version = this.invalidatedFiles.get(key) ?? 0;
+        this.invalidatedFiles.set(key, version + 1);
     }
-    invalidateIfChanged(filename, content, previousVisitedFiles, source = 'loaded', changedFiles = new Set()) {
+    consumeInvalidation(filename) {
+        const key = stripQueryAndHash(filename);
+        const invalidationVersion = this.invalidatedFiles.get(key);
+        if (invalidationVersion === undefined) {
+            return false;
+        }
+        const consumedVersion = this.consumedInvalidationVersions.get(filename) ?? 0;
+        if (consumedVersion >= invalidationVersion) {
+            return false;
+        }
+        this.consumedInvalidationVersions.set(filename, invalidationVersion);
+        return true;
+    }
+    invalidateIfChanged(filename, content, previousVisitedFiles, source = 'loaded', changedFiles = new Set(), dependencyChangeMemo = new Map(), forceContentCheck = false) {
         if (changedFiles.has(filename)) {
             return true;
         }
         const visitedFiles = new Set(previousVisitedFiles);
         const fileEntrypoint = this.get('entrypoints', filename);
         let anyDepChanged = false;
-        // We need to check all dependencies of the file
-        // because they might have changed as well.
         if (!visitedFiles.has(filename) &&
             (fileEntrypoint || this.hasCachedDependencies(filename))) {
             visitedFiles.add(filename);
             const invalidateOnDependencyChange = fileEntrypoint?.invalidateOnDependencyChange;
-            const dependenciesToCheck = new Map();
-            for (const [key, dependency] of fileEntrypoint?.dependencies ?? []) {
-                dependenciesToCheck.set(key, dependency);
-            }
-            for (const [key, dependency,] of fileEntrypoint?.invalidationDependencies ?? []) {
-                if (!dependenciesToCheck.has(key)) {
-                    dependenciesToCheck.set(key, dependency);
-                }
-            }
-            for (const dependencyFilename of this.getCachedDependencies(filename)) {
-                if (![...dependenciesToCheck.values()].some((dependency) => dependency.resolved === dependencyFilename)) {
-                    dependenciesToCheck.set(dependencyFilename, {
-                        resolved: dependencyFilename,
-                    });
-                }
-            }
+            const dependenciesToCheck = this.getDependenciesToCheck(filename, fileEntrypoint);
             for (const [, dependency] of dependenciesToCheck) {
                 const dependencyFilename = dependency.resolved;
                 if (dependencyFilename) {
-                    let dependencyContent;
-                    try {
-                        dependencyContent = node_fs_1.default.readFileSync((0, parseRequest_1.stripQueryAndHash)(dependencyFilename), 'utf8');
-                    }
-                    catch (error) {
-                        if (!isMissingFileError(error)) {
-                            throw error;
-                        }
-                        this.invalidateForFile(dependencyFilename);
-                        anyDepChanged = true;
-                        // eslint-disable-next-line no-continue
-                        continue;
-                    }
-                    const dependencyChanged = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, 'fs', changedFiles);
+                    const dependencyChanged = this.didDependencyChange(dependencyFilename, visitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck ||
+                        invalidateOnDependencyChange?.has(dependencyFilename) ||
+                        false);
                     if (dependencyChanged &&
                         invalidateOnDependencyChange?.has(dependencyFilename)) {
                         cacheLogger('dependency affecting output has changed, invalidate all for %s', filename);
@@ -222,14 +242,163 @@ class TransformCacheCollection {
         }
         return false;
     }
+    getDependenciesToCheck(filename, fileEntrypoint) {
+        const dependenciesToCheck = new Map();
+        for (const [key, dependency] of fileEntrypoint?.dependencies ?? []) {
+            dependenciesToCheck.set(key, dependency);
+        }
+        for (const [key, dependency] of fileEntrypoint?.invalidationDependencies ??
+            []) {
+            if (!dependenciesToCheck.has(key)) {
+                dependenciesToCheck.set(key, dependency);
+            }
+        }
+        for (const dependencyFilename of this.getCachedDependencies(filename)) {
+            if (![...dependenciesToCheck.values()].some((dependency) => dependency.resolved === dependencyFilename)) {
+                dependenciesToCheck.set(dependencyFilename, {
+                    resolved: dependencyFilename,
+                });
+            }
+        }
+        return dependenciesToCheck;
+    }
+    didDependencyChange(dependencyFilename, visitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck = false) {
+        if (changedFiles.has(dependencyFilename)) {
+            return true;
+        }
+        const memoized = dependencyChangeMemo.get(dependencyFilename);
+        if (memoized !== undefined) {
+            return memoized;
+        }
+        if (visitedFiles.has(dependencyFilename)) {
+            return false;
+        }
+        const strippedDependencyFilename = stripQueryAndHash(dependencyFilename);
+        const cachedMtime = this.fileMtimes.get(dependencyFilename);
+        const cachedEntrypoint = this.get('entrypoints', dependencyFilename);
+        if (cachedMtime !== undefined) {
+            let currentMtime;
+            try {
+                currentMtime = fs.statSync(strippedDependencyFilename).mtimeMs;
+            }
+            catch (error) {
+                if (!isMissingFileError(error)) {
+                    throw error;
+                }
+                this.invalidateForFile(dependencyFilename);
+                changedFiles.add(dependencyFilename);
+                dependencyChangeMemo.set(dependencyFilename, true);
+                return true;
+            }
+            if (currentMtime === cachedMtime) {
+                const nestedDependencies = this.getDependenciesToCheck(dependencyFilename, cachedEntrypoint);
+                if (forceContentCheck &&
+                    this.didFileContentHashChange(dependencyFilename, strippedDependencyFilename, changedFiles)) {
+                    dependencyChangeMemo.set(dependencyFilename, true);
+                    return true;
+                }
+                // A cached file without a cached entrypoint was invalidated earlier.
+                if (!cachedEntrypoint && nestedDependencies.size === 0) {
+                    dependencyChangeMemo.set(dependencyFilename, true);
+                    return true;
+                }
+                if (nestedDependencies.size === 0) {
+                    dependencyChangeMemo.set(dependencyFilename, false);
+                    return false;
+                }
+                const nextVisitedFiles = new Set(visitedFiles);
+                nextVisitedFiles.add(dependencyFilename);
+                for (const [, nestedDependency] of nestedDependencies) {
+                    if (nestedDependency.resolved &&
+                        this.didDependencyChange(nestedDependency.resolved, nextVisitedFiles, changedFiles, dependencyChangeMemo, forceContentCheck)) {
+                        this.invalidateForFile(dependencyFilename);
+                        changedFiles.add(dependencyFilename);
+                        dependencyChangeMemo.set(dependencyFilename, true);
+                        return true;
+                    }
+                }
+                dependencyChangeMemo.set(dependencyFilename, false);
+                return false;
+            }
+        }
+        let dependencyContent;
+        try {
+            dependencyContent = fs.readFileSync(strippedDependencyFilename, 'utf8');
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(dependencyFilename);
+            changedFiles.add(dependencyFilename);
+            dependencyChangeMemo.set(dependencyFilename, true);
+            return true;
+        }
+        const invalidated = this.invalidateIfChanged(dependencyFilename, dependencyContent, visitedFiles, 'fs', changedFiles, dependencyChangeMemo, forceContentCheck);
+        dependencyChangeMemo.set(dependencyFilename, invalidated);
+        return invalidated;
+    }
+    didFileContentHashChange(filename, strippedFilename, changedFiles) {
+        const previousHash = this.contentHashes.get(filename)?.fs;
+        if (previousHash === undefined) {
+            return false;
+        }
+        let content;
+        try {
+            content = fs.readFileSync(strippedFilename, 'utf8');
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(filename);
+            changedFiles.add(filename);
+            return true;
+        }
+        const nextHash = hashContent(content);
+        if (previousHash === nextHash) {
+            return false;
+        }
+        this.setContentHash(filename, 'fs', nextHash);
+        this.invalidateForFile(filename);
+        changedFiles.add(filename);
+        return true;
+    }
     setCacheDependencies(cacheName, key, dependencies) {
         const cache = this.getDependencyCache(cacheName);
         const nextDependencies = new Set([...dependencies].filter((dependency) => dependency.length > 0));
+        const cacheKey = this.getKey(key);
         if (nextDependencies.size === 0) {
-            cache.delete(key);
+            cache.delete(cacheKey);
             return;
         }
-        cache.set(key, nextDependencies);
+        cache.set(cacheKey, nextDependencies);
+    }
+    /**
+     * Fast check if a file changed on disk since last seen.
+     * Uses mtime as a fast path and only reads the file if mtime differs.
+     */
+    checkFreshness(filename, strippedFilename) {
+        try {
+            const currentMtime = fs.statSync(strippedFilename).mtimeMs;
+            const cachedMtime = this.fileMtimes.get(filename);
+            if (cachedMtime !== undefined && currentMtime === cachedMtime) {
+                return false;
+            }
+            const content = fs.readFileSync(strippedFilename, 'utf8');
+            this.fileMtimes.set(filename, currentMtime);
+            if (this.invalidateIfChanged(filename, content, undefined, 'fs')) {
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            this.invalidateForFile(filename);
+            return true;
+        }
     }
     clearCacheDependencies(cacheName, key) {
         if (cacheName === 'all') {
@@ -242,7 +411,7 @@ class TransformCacheCollection {
                 this.barrelManifestDependencies.clear();
             }
             else {
-                this.barrelManifestDependencies.delete(key);
+                this.barrelManifestDependencies.delete(this.getKey(key));
             }
             return;
         }
@@ -251,14 +420,15 @@ class TransformCacheCollection {
                 this.exportDependencies.clear();
             }
             else {
-                this.exportDependencies.delete(key);
+                this.exportDependencies.delete(this.getKey(key));
             }
         }
     }
     getCachedDependencies(filename) {
+        const key = this.getKey(filename);
         return new Set([
-            ...(this.barrelManifestDependencies.get(filename) ?? []),
-            ...(this.exportDependencies.get(filename) ?? []),
+            ...(this.barrelManifestDependencies.get(key) ?? []),
+            ...(this.exportDependencies.get(key) ?? []),
         ]);
     }
     getDependencyCache(cacheName) {
@@ -269,33 +439,6 @@ class TransformCacheCollection {
     hasCachedDependencies(filename) {
         return this.getCachedDependencies(filename).size > 0;
     }
-    /**
-     * Fast check if a file changed on disk since last seen.
-     * Uses mtime as a fast path — only reads the file if mtime differs.
-     * Returns true if the file changed (cache was invalidated).
-     */
-    checkFreshness(filename, strippedFilename) {
-        try {
-            const currentMtime = node_fs_1.default.statSync(strippedFilename).mtimeMs;
-            const cachedMtime = this.fileMtimes.get(filename);
-            if (cachedMtime !== undefined && currentMtime === cachedMtime) {
-                return false;
-            }
-            const content = node_fs_1.default.readFileSync(strippedFilename, 'utf-8');
-            this.fileMtimes.set(filename, currentMtime);
-            if (this.invalidateIfChanged(filename, content, undefined, 'fs')) {
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            if (!isMissingFileError(error)) {
-                throw error;
-            }
-            this.invalidateForFile(filename);
-            return true;
-        }
-    }
     setContentHash(filename, source, hash) {
         const current = this.contentHashes.get(filename);
         if (current) {
@@ -306,7 +449,7 @@ class TransformCacheCollection {
         }
         if (source === 'fs') {
             try {
-                this.fileMtimes.set(filename, node_fs_1.default.statSync((0, parseRequest_1.stripQueryAndHash)(filename)).mtimeMs);
+                this.fileMtimes.set(filename, fs.statSync(stripQueryAndHash(filename)).mtimeMs);
             }
             catch {
                 // ignore
@@ -314,4 +457,3 @@ class TransformCacheCollection {
         }
     }
 }
-exports.TransformCacheCollection = TransformCacheCollection;

package/types/debug/fileReporter.js

@@ -1,17 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileReporter = void 0;
 /* eslint-disable no-console */
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const EventEmitter_1 = require("../utils/EventEmitter");
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+import { EventEmitter, isOnActionStartArgs } from '../utils/EventEmitter';
 const workingDir = process.cwd();
 function replacer(_key, value) {
-    if (typeof value === 'string' && path_1.default.isAbsolute(value)) {
-        return path_1.default.relative(workingDir, value);
+    if (typeof value === 'string' && path.isAbsolute(value)) {
+        return path.relative(workingDir, value);
     }
     if (value instanceof Map) {
         return Array.from(value.entries()).reduce((obj, [k, v]) => {
@@ -38,7 +32,7 @@ function printTimings(timings, startedAt, sourceRoot) {
             .sort(([a], [b]) => a.localeCompare(b))
             .forEach(([value, time]) => {
             const name = value.startsWith(sourceRoot)
-                ? path_1.default.relative(sourceRoot, value)
+                ? path.relative(sourceRoot, value)
                 : value;
             console.log(`    ${name}: ${time}ms`);
         });
@@ -47,24 +41,25 @@ function printTimings(timings, startedAt, sourceRoot) {
 const writeJSONl = (stream, data) => {
     stream.write(`${JSON.stringify(data, replacer)}\n`);
 };
-const createFileReporter = (options = false) => {
+export const createFileReporter = (options = false) => {
     if (!options || !options.dir) {
         return {
-            emitter: EventEmitter_1.EventEmitter.dummy,
+            emitter: EventEmitter.dummy,
             onDone: () => { },
         };
     }
-    const reportFolder = (0, fs_1.existsSync)(options.dir)
+    const reportFolder = existsSync(options.dir)
         ? options.dir
-        : (0, fs_1.mkdirSync)(options.dir, {
+        : mkdirSync(options.dir, {
             recursive: true,
         });
     if (!reportFolder) {
         throw new Error(`Could not create directory ${options.dir}`);
     }
-    const actionStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'actions.jsonl'));
-    const dependenciesStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'dependencies.jsonl'));
-    const entrypointStream = (0, fs_1.createWriteStream)(path_1.default.join(options.dir, 'entrypoints.jsonl'));
+    const actionStream = createWriteStream(path.join(options.dir, 'actions.jsonl'));
+    const dependenciesStream = createWriteStream(path.join(options.dir, 'dependencies.jsonl'));
+    const entrypointStream = createWriteStream(path.join(options.dir, 'entrypoints.jsonl'));
+    const staticResolveStream = createWriteStream(path.join(options.dir, 'static-resolve.jsonl'));
     const startedAt = performance.now();
     const timings = new Map();
     const addTiming = (label, key, value) => {
@@ -85,6 +80,10 @@ const createFileReporter = (options = false) => {
     const processSingleEvent = (meta) => {
         if (meta.type === 'dependency') {
             processDependencyEvent(meta);
+            return;
+        }
+        if (meta.type === 'staticResolve') {
+            writeJSONl(staticResolveStream, meta);
         }
     };
     const startTimes = new Map();
@@ -109,7 +108,7 @@ const createFileReporter = (options = false) => {
     };
     let actionId = 0;
     const onAction = (...args) => {
-        if ((0, EventEmitter_1.isOnActionStartArgs)(args)) {
+        if (isOnActionStartArgs(args)) {
             const [, timestamp, type, idx, entrypointRef] = args;
             writeJSONl(actionStream, {
                 actionId,
@@ -134,7 +133,7 @@ const createFileReporter = (options = false) => {
     const onEntrypointEvent = (emitterId, timestamp, event) => {
         entrypointStream.write(`${JSON.stringify([emitterId, timestamp, event])}\n`);
     };
-    const emitter = new EventEmitter_1.EventEmitter(onEvent, onAction, onEntrypointEvent);
+    const emitter = new EventEmitter(onEvent, onAction, onEntrypointEvent);
     return {
         emitter,
         onDone: (sourceRoot) => {
@@ -144,8 +143,9 @@ const createFileReporter = (options = false) => {
             }
             actionStream.end();
             dependenciesStream.end();
+            entrypointStream.end();
+            staticResolveStream.end();
             timings.clear();
         },
     };
 };
-exports.createFileReporter = createFileReporter;

package/types/eval/broker.d.ts

@@ -0,0 +1,88 @@
+import type { Entrypoint } from '../transform/Entrypoint';
+import type { Services } from '../transform/types';
+type EvaluateResult = {
+    values: Map<string, unknown> | null;
+    dependencies: string[];
+};
+export declare const stripEntrypointGlobalsFromRunnerContext: (globals: Record<string, unknown>, entrypoint: string) => Record<string, unknown>;
+export declare class EvalBroker {
+    private readonly services;
+    private readonly asyncResolve;
+    private runner;
+    private runnerInputQueue;
+    private runnerReady;
+    private lastInitKey;
+    private lastHappyDomEnabled;
+    private evalQueue;
+    private readonly pending;
+    private nextId;
+    private readonly resolveCache;
+    private readonly resolveInFlight;
+    private readonly loadCache;
+    private readonly loadInFlight;
+    private readonly importsByModule;
+    private readonly onlyByModule;
+    private readonly runtimeDependenciesByModule;
+    private readonly emittedDependencies;
+    private readonly lastSentLoadByModule;
+    private pendingEvals;
+    private evalFlushScheduled;
+    private stableInitHashCache;
+    private evalSeq;
+    private happyDomDisabled;
+    private happyDomDisableWarned;
+    private activeResolveRootId;
+    private currentServices;
+    constructor(services: Services, asyncResolve: (what: string, importer: string, stack: string[]) => Promise<string | null>);
+    private ensureImportsMapping;
+    private getImportOnly;
+    private getLoadRequestOnly;
+    evaluate(entrypoint: Entrypoint, services?: Services): Promise<EvaluateResult>;
+    private scheduleEvalFlush;
+    private runEvalBatch;
+    private runOneEntrypoint;
+    private resetPerEntrypointState;
+    private applyModuleExports;
+    dispose(): void;
+    private createRunnerProcess;
+    private attachRunnerListeners;
+    private ensureRunner;
+    private initIsolatedRunner;
+    private replaceRunner;
+    private getStableInitHash;
+    private initRunner;
+    private getRunnerFeatures;
+    private getInitTimeoutMs;
+    private warnHappyDomDisabledOnce;
+    private onData;
+    private handleMessage;
+    private handleRunnerStderr;
+    private handleWarn;
+    private handleResolve;
+    private normalizeResolvedId;
+    private resolveImport;
+    private getResolveStack;
+    private resolveImportImpl;
+    private finalizeResolvedImport;
+    private emitDependency;
+    private trackRuntimeDependency;
+    private trackImporterDependency;
+    private collectEntrypointDependencies;
+    private applyImportOverrides;
+    private resolveWithNodeFallback;
+    private maybeWarnNodeFallback;
+    private handleLoad;
+    private loadModule;
+    private loadModuleImpl;
+    private sendLoadResult;
+    private sendMessage;
+    private handleSendMessageError;
+    private request;
+    private resolvePending;
+    private rejectPending;
+    private rejectAllPending;
+    private mergeKnownDependencyOnly;
+}
+export declare const disposeEvalBroker: (cache: Services["cache"]) => void;
+export declare const getEvalBroker: (services: Services, asyncResolve: (what: string, importer: string, stack: string[]) => Promise<string | null>, cacheKey: string) => EvalBroker;
+export {};