rolldown 1.1.5 → 1.2.1

package/dist/experimental-index.mjs

@@ -1,17 +1,18 @@
-import { n as __toESM, t as require_binding } from "./shared/binding-TuFFIE_J.mjs";
-import { n as BuiltinPlugin, t as normalizedStringOrRegex } from "./shared/normalize-string-or-regex-dnh67V_w.mjs";
-import { o as transformToRollupOutput } from "./shared/bindingify-input-options-XPJLJOD0.mjs";
-import { c as validateOption, n as createBundlerOptions, t as RolldownBuild, u as PluginDriver } from "./shared/rolldown-build-CtPvmZgJ.mjs";
-import { i as unwrapBindingResult, r as normalizeBindingResult } from "./shared/error-BHRSI0R7.mjs";
-import { n as parseSync$1, t as parse$1 } from "./shared/parse-D4dtlfWy.mjs";
-import { a as viteDynamicImportVarsPlugin, c as viteLoadFallbackPlugin, d as viteReporterPlugin, f as viteResolvePlugin, i as viteBuildImportAnalysisPlugin, l as viteModulePreloadPolyfillPlugin, n as isolatedDeclarationPlugin, o as viteImportGlobPlugin, p as viteWebWorkerPostPlugin, r as oxcRuntimePlugin, s as viteJsonPlugin, u as viteReactRefreshWrapperPlugin } from "./shared/constructors-D_3i7dpX.mjs";
-import { a as minify$1, i as transformSync$1, n as resolveTsconfig, o as minifySync$1, r as transform$1, t as TsconfigCache$1 } from "./shared/resolve-tsconfig-DxqIJB3x.mjs";
+import { n as __toESM, t as require_binding } from "./shared/binding-Cv62mM1i.mjs";
+import { n as BuiltinPlugin, t as normalizedStringOrRegex } from "./shared/normalize-string-or-regex-BVNGzRe4.mjs";
+import { o as transformToRollupOutput } from "./shared/bindingify-input-options-EnUlEF0T.mjs";
+import { l as PluginDriver, s as validateOption, t as createBundlerOptions } from "./shared/create-bundler-option-4QtiLLuz.mjs";
+import { i as unwrapBindingResult, r as normalizeBindingResult } from "./shared/error-BgfXq0Tb.mjs";
+import { n as parseSync$1, t as parse$1 } from "./shared/parse-DQIYJwT4.mjs";
+import { a as viteDynamicImportVarsPlugin, c as viteLoadFallbackPlugin, d as viteReporterPlugin, f as viteResolvePlugin, i as viteBuildImportAnalysisPlugin, l as viteModulePreloadPolyfillPlugin, n as isolatedDeclarationPlugin, o as viteImportGlobPlugin, p as viteWebWorkerPostPlugin, r as oxcRuntimePlugin, s as viteJsonPlugin, u as viteReactRefreshWrapperPlugin } from "./shared/constructors-CuqzPFxJ.mjs";
+import { a as minify$1, i as transformSync$1, n as resolveTsconfig, o as minifySync$1, r as transform$1, t as TsconfigCache$1 } from "./shared/resolve-tsconfig-CQndqeLj.mjs";
 import { pathToFileURL } from "node:url";
 //#region src/api/dev/dev-engine.ts
 var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
 var DevEngine = class DevEngine {
 	#inner;
 	#cachedBuildFinishPromise = null;
+	#asyncRuntimeReleased = false;
 	static async create(inputOptions, outputOptions = {}, devOptions = {}) {
 		inputOptions = await PluginDriver.callOptionsHook(inputOptions);
 		const options = await createBundlerOptions(inputOptions, outputOptions, false);
@@ -44,8 +45,9 @@ var DevEngine = class DevEngine {
 			onAdditionalAssets: userOnAdditionalAssets ? function(output) {
 				userOnAdditionalAssets(transformToRollupOutput(output));
 			} : void 0,
-			rebuildStrategy: devOptions.rebuildStrategy ? devOptions.rebuildStrategy === "always" ? import_binding.BindingRebuildStrategy.Always : devOptions.rebuildStrategy === "auto" ? import_binding.BindingRebuildStrategy.Auto : import_binding.BindingRebuildStrategy.Never : void 0,
+			rebuildStrategy: devOptions.rebuildStrategy ? devOptions.rebuildStrategy === "always" ? import_binding.BindingRebuildStrategy.Always : import_binding.BindingRebuildStrategy.Never : void 0,
 			watch: devOptions.watch && {
+				enabled: devOptions.watch.enabled,
 				skipWrite: devOptions.watch.skipWrite,
 				usePolling: devOptions.watch.usePolling,
 				pollInterval: devOptions.watch.pollInterval,
@@ -58,6 +60,7 @@ var DevEngine = class DevEngine {
 			}
 		};
 		const inner = new import_binding.BindingDevEngine(options.bundlerOptions, bindingDevOptions);
+		(0, import_binding.startAsyncRuntime)();
 		return new DevEngine(inner);
 	}
 	constructor(inner) {
@@ -83,17 +86,31 @@ var DevEngine = class DevEngine {
 	triggerFullBuild() {
 		this.#inner.triggerFullBuild();
 	}
-	async invalidate(file, firstInvalidatedBy) {
-		return unwrapBindingResult(await this.#inner.invalidate(file, firstInvalidatedBy));
+	/**
+	* Client-connect signal (the clientId hello): creates the per-client session
+	* with an empty ship map. Reconnects arrive as fresh clientIds.
+	*/
+	async registerClient(clientId) {
+		await this.#inner.registerClient(clientId);
 	}
-	async registerModules(clientId, modules) {
-		await this.#inner.registerModules(clientId, modules);
+	/**
+	* Delivery notification from the serving middleware: the response for
+	* `filename` completed, so record its modules as shipped to that client.
+	*/
+	async notifyPayloadDelivered(filename) {
+		await this.#inner.notifyPayloadDelivered(filename);
 	}
 	async removeClient(clientId) {
 		await this.#inner.removeClient(clientId);
 	}
 	async close() {
-		await this.#inner.close();
+		const shouldRelease = !this.#asyncRuntimeReleased;
+		this.#asyncRuntimeReleased = true;
+		try {
+			await this.#inner.close();
+		} finally {
+			if (shouldRelease) (0, import_binding.shutdownAsyncRuntime)();
+		}
 	}
 	/**
 	* Compile a lazy entry module and return HMR-style patch code.
@@ -104,7 +121,8 @@ var DevEngine = class DevEngine {
 	*
 	* @param moduleId - The absolute file path of the module to compile
 	* @param clientId - The client ID requesting this compilation
-	* @returns The compiled JavaScript code as a string (HMR patch format)
+	* @returns The compiled chunk: its code plus the filename whose delivery the
+	* serving middleware reports via {@link notifyPayloadDelivered}
 	*/
 	async compileEntry(moduleId, clientId) {
 		return this.#inner.compileEntry(moduleId, clientId);
@@ -173,18 +191,25 @@ function freeExternalMemory(handle, keepDataAlive = false) {
 const scan = async (rawInputOptions, rawOutputOptions = {}) => {
 	validateOption("input", rawInputOptions);
 	validateOption("output", rawOutputOptions);
-	const ret = await createBundlerOptions(await PluginDriver.callOptionsHook(rawInputOptions), rawOutputOptions, false);
+	const inputOptions = await PluginDriver.callOptionsHook(rawInputOptions);
+	const ret = await createBundlerOptions(inputOptions, rawOutputOptions, false);
 	const bundler = new import_binding.BindingBundler();
-	if (RolldownBuild.asyncRuntimeShutdown) (0, import_binding.startAsyncRuntime)();
+	(0, import_binding.startAsyncRuntime)();
+	let cleanedUp = false;
 	async function cleanup() {
-		await bundler.close();
-		await ret.stopWorkers?.();
-		(0, import_binding.shutdownAsyncRuntime)();
-		RolldownBuild.asyncRuntimeShutdown = true;
+		if (cleanedUp) return;
+		cleanedUp = true;
+		try {
+			await bundler.close();
+			await ret.stopWorkers?.();
+		} finally {
+			(0, import_binding.shutdownAsyncRuntime)();
+		}
 	}
 	let cleanupPromise = Promise.resolve();
 	try {
-		unwrapBindingResult(await bundler.scan(ret.bundlerOptions));
+		const result = await bundler.scan(ret.bundlerOptions);
+		unwrapBindingResult(result);
 	} catch (err) {
 		await cleanup();
 		throw err;

package/dist/experimental-runtime-base.mjs

@@ -0,0 +1,95 @@
+export var __create = Object.create;
+export var __defProp = Object.defineProperty;
+export var __name = (target, value) => __defProp(target, 'name', { value, configurable: true });
+export var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+export var __getOwnPropNames = Object.getOwnPropertyNames;
+export var __getProtoOf = Object.getPrototypeOf;
+export var __hasOwnProp = Object.prototype.hasOwnProperty;
+export var __esm = (fn, res, err) =>
+  function () {
+    if (err) throw err[0];
+    try {
+      return (fn && (res = (0, fn[__getOwnPropNames(fn)[0]])((fn = 0))), res);
+    } catch (e) {
+      throw ((err = [e]), e);
+    }
+  };
+export var __esmMin = (fn, res, err) => () => {
+  if (err) throw err[0];
+  try {
+    return (fn && (res = fn((fn = 0))), res);
+  } catch (e) {
+    throw ((err = [e]), e);
+  }
+};
+export var __commonJS = (cb, mod) =>
+  function () {
+    return (
+      mod || ((0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), cb = null), mod.exports
+    );
+  };
+export var __commonJSMin = (cb, mod) => () => (
+  mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports
+);
+export var __exportAll = (all, no_symbols) => {
+  let target = {};
+  for (var name in all) {
+    __defProp(target, name, { get: all[name], enumerable: true });
+  }
+  if (!no_symbols) {
+    __defProp(target, Symbol.toStringTag, { value: 'Module' });
+  }
+  return target;
+};
+export var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === 'object') || typeof from === 'function') {
+    for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp.call(to, key) && key !== except) {
+        __defProp(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+      }
+    }
+  }
+  return to;
+};
+export var __reExport = (target, mod, secondTarget) => (
+  __copyProps(target, mod, 'default'), secondTarget && __copyProps(secondTarget, mod, 'default')
+);
+export var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    // `__esModule` alone is not enough: the module must own a `default` (#10360).
+    isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, 'default')
+      ? __defProp(target, 'default', { value: mod, enumerable: true })
+      : target,
+    mod,
+  )
+);
+export var __toCommonJS = (mod) =>
+  __hasOwnProp.call(mod, 'module.exports')
+    ? mod['module.exports']
+    : __copyProps(__defProp({}, '__esModule', { value: true }), mod);
+export var __toBinaryNode = (base64) => new Uint8Array(Buffer.from(base64, 'base64'));
+export var __toBinary = /* @__PURE__ */ (() => {
+  var table = new Uint8Array(128);
+  for (var i = 0; i < 64; i++) {
+    table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;
+  }
+  return (base64) => {
+    var n = base64.length,
+      bytes = new Uint8Array((((n - (base64[n - 1] == '=') - (base64[n - 2] == '=')) * 3) / 4) | 0);
+    for (var i = 0, j = 0; i < n; ) {
+      var c0 = table[base64.charCodeAt(i++)],
+        c1 = table[base64.charCodeAt(i++)];
+      var c2 = table[base64.charCodeAt(i++)],
+        c3 = table[base64.charCodeAt(i++)];
+      bytes[j++] = (c0 << 2) | (c1 >> 4);
+      bytes[j++] = (c1 << 4) | (c2 >> 2);
+      bytes[j++] = (c2 << 6) | c3;
+    }
+    return bytes;
+  };
+})();

package/dist/experimental-runtime-types.d.ts

@@ -1,31 +1,87 @@
 /**
- * @typedef {{ type: 'hmr:module-registered', modules: string[] }} DevRuntimeMessage
- * @typedef {{ send(message: DevRuntimeMessage): void }} Messenger
+ * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+ * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+ * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+ * @typedef {{ ids: string[], localCount: number, edges: number[][], dynamicEdges?: number[][] }} ModuleGraphDelta
+ * @typedef {{ createModuleHotContext(moduleId: string): any, onModuleCacheRemoval(moduleId: string): void }} DevRuntimeHooks
  */
+export class MissingFactoryError {
+    /**
+     * @param {string} id
+     */
+    constructor(id: string);
+    id: string;
+}
 export class DevRuntime {
     /**
-     * @param {Messenger} messenger
      * @param {string} clientId
      */
-    constructor(messenger: Messenger, clientId: string);
+    constructor(clientId: string);
     /**
      * Client ID generated at runtime initialization, used for lazy compilation requests.
      * @type {string}
      */
     clientId: string;
-    messenger: Messenger;
     /**
-     * @type {Record<string, Module>}
+     * Static import edges from `registerGraph` — entries persist across `removeModuleCache`
+     * and change only by replacement from a newer payload (last write wins).
+     * @type {Map<string, { edges: string[] }>}
      */
-    modules: Record<string, Module>;
+    staticImports: Map<string, {
+        edges: string[];
+    }>;
     /**
-     * @param {string} _moduleId
+     * Reverse index over the static imports.
+     * @type {Map<string, Set<string>>}
      */
-    createModuleHotContext(_moduleId: string): void;
+    importers: Map<string, Set<string>>;
     /**
-     * @param {[string, string][]} _boundaries
+     * Dynamic `import()` edges from `registerGraph`, keyed by importer — mirror of
+     * `staticImports` for the dynamic reverse index.
+     * @type {Map<string, { edges: string[] }>}
      */
-    applyUpdates(_boundaries: [string, string][]): void;
+    dynamicImports: Map<string, {
+        edges: string[];
+    }>;
+    /**
+     * Reverse index over the dynamic imports.
+     * @type {Map<string, Set<string>>}
+     */
+    dynamicImporters: Map<string, Set<string>>;
+    /**
+     * The module cache. Membership means "this module's side effects ran in this tab" —
+     * registration is emitted ahead of every module body, and nothing un-registers on
+     * unwind, so a factory that throws mid-body stays registered. A `Map` rather than a
+     * plain object: HMR eviction deletes entries, and a `delete` on an object drops V8
+     * into dictionary mode, taxing every later lookup on the hottest read path.
+     * @type {Map<string, Module>}
+     */
+    moduleCache: Map<string, Module>;
+    /**
+     * Re-runnable factories from HMR patches and lazy chunks. The initial bundle stays
+     * scope-hoisted and contributes none.
+     * @type {Map<string, { kind: 'esm' | 'cjs', fn: (id: string) => void }>}
+     */
+    factories: Map<string, {
+        kind: "esm" | "cjs";
+        fn: (id: string) => void;
+    }>;
+    /**
+     * Installed by the dev client at boot. The runtime is a store + executor and makes
+     * no HMR decisions; accepting, disposing, and reloading live behind these hooks.
+     * @type {DevRuntimeHooks | null}
+     */
+    hooks: DevRuntimeHooks | null;
+    /**
+     * @param {ModuleGraphDelta} delta
+     */
+    registerGraph(delta: ModuleGraphDelta): void;
+    /**
+     * @param {string} id
+     * @param {'esm' | 'cjs'} kind
+     * @param {(id: string) => void} fn
+     */
+    registerFactory(id: string, kind: "esm" | "cjs", fn: (id: string) => void): void;
     /**
      * @param {string} id
      * @param {{ exports: any }} exportsHolder
@@ -35,35 +91,37 @@ export class DevRuntime {
     }): void;
     /**
      * @param {string} id
+     * @returns {string[]}
      */
-    loadExports(id: string): any;
+    getImporters(id: string): string[];
     /**
-     * __esmMin
-     *
-     * When `dedup` is truthy and `id` is already registered on the runtime,
-     * skip the factory: another lazy blob got there first. HMR patches pass
-     * no `dedup` so they always re-run the factory and replace the registered
-     * exports.
-     *
-     * @type {<T>(id: string, fn: any, dedup: any, res: T) => () => T}
-     * @internal
+     * @param {string} id
      */
-    createEsmInitializer: <T>(id: string, fn: any, dedup: any, res: T) => () => T;
+    isExecuted(id: string): any;
     /**
-     * __commonJSMin
-     *
-     * Same dedup gate as createEsmInitializer. With `dedup` truthy and `id`
-     * registered, reuse the registered exports object; otherwise run the
-     * factory.
-     *
-     * @type {<T extends { exports: any }>(id: string, cb: any, dedup: any, mod: { exports: any }, registered: any) => () => T}
-     * @internal
+     * @param {string} id
      */
-    createCjsInitializer: <T extends {
-        exports: any;
-    }>(id: string, cb: any, dedup: any, mod: {
-        exports: any;
-    }, registered: any) => () => T;
+    hasFactory(id: string): any;
+    /**
+     * Module-cache delete only — static imports and factories persist. Removal is what
+     * re-arms a cache-gated factory for `initModule`.
+     * @param {string} id
+     */
+    removeModuleCache(id: string): void;
+    /**
+     * The one re-execution gate: registered → return the live exports; otherwise run the
+     * mapped factory (which registers itself first, then runs the body).
+     * @param {string} id
+     */
+    initModule(id: string): any;
+    /**
+     * @param {string} id
+     */
+    loadExports(id: string): any;
+    /**
+     * @param {string} moduleId
+     */
+    createModuleHotContext(moduleId: string): any;
     /** @internal */
     __toESM: any;
     /** @internal */
@@ -78,14 +136,26 @@ export class DevRuntime {
     __toDynamicImportESM: (isNodeMode?: boolean) => (mod: any) => any;
     /** @internal */
     __reExport: any;
-    sendModuleRegisteredMessage: (module: string) => void;
 }
-export type DevRuntimeMessage = {
-    type: "hmr:module-registered";
-    modules: string[];
+/**
+ * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+ * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+ * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+ */
+export type ModuleGraphDelta = {
+    ids: string[];
+    localCount: number;
+    edges: number[][];
+    dynamicEdges?: number[][];
 };
-export type Messenger = {
-    send(message: DevRuntimeMessage): void;
+/**
+ * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+ * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+ * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+ */
+export type DevRuntimeHooks = {
+    createModuleHotContext(moduleId: string): any;
+    onModuleCacheRemoval(moduleId: string): void;
 };
 declare class Module {
     /**

package/dist/experimental-runtime.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+ * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+ * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+ * @typedef {{ ids: string[], localCount: number, edges: number[][], dynamicEdges?: number[][] }} ModuleGraphDelta
+ * @typedef {{ createModuleHotContext(moduleId: string): any, onModuleCacheRemoval(moduleId: string): void }} DevRuntimeHooks
+ */
+export class MissingFactoryError {
+    /**
+     * @param {string} id
+     */
+    constructor(id: string);
+    id: string;
+}
+export class DevRuntime {
+    /**
+     * @param {string} clientId
+     */
+    constructor(clientId: string);
+    /**
+     * Client ID generated at runtime initialization, used for lazy compilation requests.
+     * @type {string}
+     */
+    clientId: string;
+    /**
+     * Static import edges from `registerGraph` — entries persist across `removeModuleCache`
+     * and change only by replacement from a newer payload (last write wins).
+     * @type {Map<string, { edges: string[] }>}
+     */
+    staticImports: Map<string, {
+        edges: string[];
+    }>;
+    /**
+     * Reverse index over the static imports.
+     * @type {Map<string, Set<string>>}
+     */
+    importers: Map<string, Set<string>>;
+    /**
+     * Dynamic `import()` edges from `registerGraph`, keyed by importer — mirror of
+     * `staticImports` for the dynamic reverse index.
+     * @type {Map<string, { edges: string[] }>}
+     */
+    dynamicImports: Map<string, {
+        edges: string[];
+    }>;
+    /**
+     * Reverse index over the dynamic imports.
+     * @type {Map<string, Set<string>>}
+     */
+    dynamicImporters: Map<string, Set<string>>;
+    /**
+     * The module cache. Membership means "this module's side effects ran in this tab" —
+     * registration is emitted ahead of every module body, and nothing un-registers on
+     * unwind, so a factory that throws mid-body stays registered. A `Map` rather than a
+     * plain object: HMR eviction deletes entries, and a `delete` on an object drops V8
+     * into dictionary mode, taxing every later lookup on the hottest read path.
+     * @type {Map<string, Module>}
+     */
+    moduleCache: Map<string, Module>;
+    /**
+     * Re-runnable factories from HMR patches and lazy chunks. The initial bundle stays
+     * scope-hoisted and contributes none.
+     * @type {Map<string, { kind: 'esm' | 'cjs', fn: (id: string) => void }>}
+     */
+    factories: Map<string, {
+        kind: "esm" | "cjs";
+        fn: (id: string) => void;
+    }>;
+    /**
+     * Installed by the dev client at boot. The runtime is a store + executor and makes
+     * no HMR decisions; accepting, disposing, and reloading live behind these hooks.
+     * @type {DevRuntimeHooks | null}
+     */
+    hooks: DevRuntimeHooks | null;
+    /**
+     * @param {ModuleGraphDelta} delta
+     */
+    registerGraph(delta: ModuleGraphDelta): void;
+    /**
+     * @param {string} id
+     * @param {'esm' | 'cjs'} kind
+     * @param {(id: string) => void} fn
+     */
+    registerFactory(id: string, kind: "esm" | "cjs", fn: (id: string) => void): void;
+    /**
+     * @param {string} id
+     * @param {{ exports: any }} exportsHolder
+     */
+    registerModule(id: string, exportsHolder: {
+        exports: any;
+    }): void;
+    /**
+     * @param {string} id
+     * @returns {string[]}
+     */
+    getImporters(id: string): string[];
+    /**
+     * @param {string} id
+     */
+    isExecuted(id: string): any;
+    /**
+     * @param {string} id
+     */
+    hasFactory(id: string): any;
+    /**
+     * Module-cache delete only — static imports and factories persist. Removal is what
+     * re-arms a cache-gated factory for `initModule`.
+     * @param {string} id
+     */
+    removeModuleCache(id: string): void;
+    /**
+     * The one re-execution gate: registered → return the live exports; otherwise run the
+     * mapped factory (which registers itself first, then runs the body).
+     * @param {string} id
+     */
+    initModule(id: string): any;
+    /**
+     * @param {string} id
+     */
+    loadExports(id: string): any;
+    /**
+     * @param {string} moduleId
+     */
+    createModuleHotContext(moduleId: string): any;
+    /** @internal */
+    __toESM: any;
+    /** @internal */
+    __toCommonJS: any;
+    /** @internal */
+    __exportAll: any;
+    /**
+     * @param {boolean} [isNodeMode]
+     * @returns {(mod: any) => any}
+     * @internal
+     */
+    __toDynamicImportESM: (isNodeMode?: boolean) => (mod: any) => any;
+    /** @internal */
+    __reExport: any;
+}
+/**
+ * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+ * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+ * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+ */
+export type ModuleGraphDelta = {
+    ids: string[];
+    localCount: number;
+    edges: number[][];
+    dynamicEdges?: number[][];
+};
+/**
+ * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+ * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+ * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+ */
+export type DevRuntimeHooks = {
+    createModuleHotContext(moduleId: string): any;
+    onModuleCacheRemoval(moduleId: string): void;
+};
+declare class Module {
+    /**
+     * @param {string} id
+     */
+    constructor(id: string);
+    /**
+     * @type {{ exports: any }}
+     */
+    exportsHolder: {
+        exports: any;
+    };
+    /**
+     * @type {string}
+     */
+    id: string;
+    get exports(): any;
+}
+export {};