@rollipop/rolldown 1.0.26 → 1.0.28

package/dist/shared/{bindingify-input-options-BXQG8xz-.mjs → bindingify-input-options-CK5aV8zx.mjs}

@@ -1,8 +1,8 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
 import { i as logFailedValidation, l as logPluginError, n as error, o as logInvalidLogPosition, r as logCycleLoading, t as augmentCodeLocation } from "./logs-DmYCAKcW.mjs";
-import { i as bindingifyManifestPlugin, n as BuiltinPlugin, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-CiPu-0L6.mjs";
+import { i as bindingifyManifestPlugin, n as BuiltinPlugin, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-D58FhCur.mjs";
 import { i as noop, n as isPathFragment, o as unreachable, s as unsupported, t as arraify } from "./misc-DOSKtd97.mjs";
-import { a as bindingifySourcemap, i as unwrapBindingResult, t as aggregateBindingErrorsIntoJsError } from "./error-bm-jLrD1.mjs";
+import { a as bindingifySourcemap, i as unwrapBindingResult, t as aggregateBindingErrorsIntoJsError } from "./error-C9I-OQs1.mjs";
 import { parseAst } from "../parse-ast-index.mjs";
 import fs from "node:fs";
 import path from "node:path";
@@ -10,7 +10,7 @@ import * as filter from "@rolldown/pluginutils";
 import fsp from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 //#region package.json
-var version = "1.0.26";
+var version = "1.0.28";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 //#endregion
 //#region src/constants/version.ts
@@ -236,7 +236,7 @@ function bindingAssetSource(source) {
 	return { inner: source };
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.142.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.143.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1793,8 +1793,221 @@ function extractHookUsage(plugin) {
 	return hookUsage;
 }
 //#endregion
+//#region src/utils/plugin-timings.ts
+/**
+* Measure what plugin hooks cost, from inside the JavaScript callback.
+*
+* Internal to Rolldown. Nothing here is on a public entry point, and the measurement is not
+* offered as an API — the only consumer is the core, which pulls it while the build closes.
+*
+* The bundler core can only bracket *dispatch* and *completion*. For a hook it invokes
+* concurrently those two points are separated mostly by the queue the call waited in on
+* JavaScript's single thread, and the queue is deepest behind whichever callback is doing
+* the most work — so the hook blocking the thread dilutes its own credit while cheap hooks
+* collect credit for waiting. Ranking from those numbers reliably puts the *cheapest* hook
+* first.
+*
+* The missing quantity is when the callback began running, and that is known here. Starting
+* the clock inside the callback removes the dispatch queue by construction.
+*
+* ## `maxInFlight` decides whether a total means anything
+*
+* Entry-to-exit spans may be summed only if they never overlap. A synchronous callback
+* cannot overlap: it holds the thread until it returns. An `async` one can — it may suspend
+* at an `await` and let another call of the same hook begin, and then both spans cover the
+* same wall clock and the sum counts it twice.
+*
+* Overlap also changes what the span is measuring. A hook that awaits the bundler (say
+* `this.resolve`) spends most of its span waiting for Rust, so the number describes the
+* bundler rather than the plugin. Observed on a real build: one `resolveId` accumulated
+* ~47,000s of span inside a 44s module-loading window.
+*
+* So overlap is measured rather than assumed, per hook: `overlapMs` is the wall time
+* double counted in `ms` because two or more calls were in flight together. A hook is
+* reported with a number when that is a negligible share of its span, and named without one
+* when it is not.
+*
+* The test is deliberately a tolerance rather than "did this ever happen". A peak in-flight
+* count of 2 can mean one incidental overlap in twenty thousand calls, and discarding a
+* twelve-second measurement over that both throws away good data and makes the report
+* depend on scheduling luck — the same hook would appear in one run and vanish in the next.
+*
+* This keeps the rule the core followed — never present a number that cannot be defended —
+* while narrowing "cannot measure" from a property of the *call site* to a property of the
+* *callback*, which is where it actually lives. A hook dispatched concurrently but whose
+* body barely overlaps is measured to within the tolerance.
+*
+* A measured row is still wall time for that callback rather than CPU: a hook that awaits
+* I/O without overlapping another call of itself is charged for the wait. Excluding the
+* dispatch queue is what this buys; it does not distinguish running from awaiting.
+*/
+/**
+* How much of a hook's span may be double counted before its total stops being reportable,
+* as a fraction of that span.
+*/
+const OVERLAP_TOLERANCE = .01;
+/**
+* One recorder per build, keyed on the object that identifies it.
+*
+* Counters cannot be module-global. A plugin is free to run a nested `rolldown()` build of
+* its own, which finishes first; shared counters would let it flush the outer build's
+* half-accumulated totals and report a window belonging to neither.
+*/
+const recorders = /* @__PURE__ */ new WeakMap();
+/** The recorder for one build, created on first use. */
+function pluginTimingsRecorderFor(key) {
+	let recorder = recorders.get(key);
+	if (recorder === void 0) {
+		recorder = {
+			costs: /* @__PURE__ */ new Map(),
+			busyMs: 0,
+			inFlight: 0,
+			busyStart: 0
+		};
+		recorders.set(key, recorder);
+	}
+	return recorder;
+}
+function costFor(recorder, owner, hookName) {
+	let byHook = recorder.costs.get(owner.key);
+	if (byHook === void 0) {
+		byHook = /* @__PURE__ */ new Map();
+		recorder.costs.set(owner.key, byHook);
+	}
+	let cost = byHook.get(hookName);
+	if (cost === void 0) {
+		cost = {
+			owner: owner.name,
+			kind: owner.kind,
+			hookName,
+			calls: 0,
+			ms: 0,
+			inFlight: 0,
+			maxInFlight: 0,
+			overlapMs: 0,
+			lastChange: 0
+		};
+		byHook.set(hookName, cost);
+	}
+	return cost;
+}
+/**
+* Fold the interval since the last in-flight change into `overlapMs`, then move the mark.
+* Call immediately before every increment and decrement of `cost.inFlight`.
+*/
+function markInFlightChange(cost, at) {
+	if (cost.inFlight > 1) cost.overlapMs += (cost.inFlight - 1) * (at - cost.lastChange);
+	cost.lastChange = at;
+}
+/**
+* Close out one call. A module-level function rather than a closure per invocation: hooks
+* run hundreds of thousands of times in a large build, and the synchronous path would
+* otherwise allocate one closure per call only to invoke it immediately.
+*/
+function settle(recorder, cost, started) {
+	const ended = performance.now();
+	markInFlightChange(cost, ended);
+	cost.inFlight -= 1;
+	cost.ms += ended - started;
+	recorder.inFlight -= 1;
+	if (recorder.inFlight === 0) recorder.busyMs += ended - recorder.busyStart;
+}
+/**
+* Wrap one callback so its execution time is recorded.
+*
+* Returns the callback untouched when there is no recorder, so a build that is not
+* measuring pays nothing beyond one branch at setup.
+*/
+function measureHookCost(recorder, owner, hookName, handler) {
+	if (recorder === void 0) return handler;
+	const cost = costFor(recorder, owner, hookName);
+	return function(...args) {
+		const started = performance.now();
+		markInFlightChange(cost, started);
+		cost.calls += 1;
+		cost.inFlight += 1;
+		if (cost.inFlight > cost.maxInFlight) cost.maxInFlight = cost.inFlight;
+		if (recorder.inFlight === 0) recorder.busyStart = started;
+		recorder.inFlight += 1;
+		let result;
+		try {
+			result = handler.apply(this, args);
+		} catch (error) {
+			settle(recorder, cost, started);
+			throw error;
+		}
+		if (typeof result?.then === "function") return result.then((value) => {
+			settle(recorder, cost, started);
+			return value;
+		}, (error) => {
+			settle(recorder, cost, started);
+			throw error;
+		});
+		settle(recorder, cost, started);
+		return result;
+	};
+}
+/**
+* The owner shown for user callbacks the core invokes directly rather than through a
+* plugin. One shared identity: they are all configured on the same options object.
+*/
+const OUTPUT_OPTIONS_OWNER = {
+	key: Symbol("output options"),
+	name: "output options",
+	kind: "outputOption"
+};
+/** As {@link OUTPUT_OPTIONS_OWNER}, for callbacks configured on the input options. */
+const INPUT_OPTIONS_OWNER = {
+	key: Symbol("input options"),
+	name: "input options",
+	kind: "inputOption"
+};
+/**
+* Wrap `value` when the user supplied a function, and leave every other form alone.
+*
+* Most option callbacks are declared as `string | RegExp | Function | ...`, so this keeps
+* the one cast the wrapping needs in a single place.
+*/
+function measureIfFunction(recorder, owner, hookName, value) {
+	if (typeof value !== "function") return value;
+	return measureHookCost(recorder, owner, hookName, value);
+}
+/**
+* What the build's callbacks have cost so far, leaving the recorder in place.
+*
+* Ungated on purpose: whether a build is worth reporting on is decided from the clocks Rust
+* holds, so the question is not this side's to ask.
+*
+* Rust calls this while the build is closing, so what it gets includes `closeBundle`.
+*/
+function summarizePluginTimings(key) {
+	const recorder = recorders.get(key);
+	if (recorder === void 0) return {
+		busyMs: 0,
+		rows: []
+	};
+	const rows = [];
+	for (const byHook of recorder.costs.values()) for (const cost of byHook.values()) {
+		if (cost.calls === 0) continue;
+		rows.push({
+			owner: cost.owner,
+			kind: cost.kind,
+			hook: cost.hookName,
+			calls: cost.calls,
+			ms: cost.ms,
+			maxInFlight: cost.maxInFlight,
+			overlapMs: cost.overlapMs,
+			rankable: cost.overlapMs <= cost.ms * OVERLAP_TOLERANCE
+		});
+	}
+	return {
+		busyMs: recorder.busyMs,
+		rows
+	};
+}
+//#endregion
 //#region src/plugin/bindingify-plugin.ts
-function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode) {
+function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode, timings) {
 	const args = {
 		plugin,
 		options,
@@ -1829,7 +2042,7 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 	const { plugin: closeWatcher, meta: closeWatcherMeta } = bindingifyCloseWatcher(args);
 	const { plugin: transformCacheHit, meta: transformCacheHitMeta } = bindingifyTransformCacheHit(args);
 	let hookUsage = extractHookUsage(plugin).inner();
-	return wrapHandlers({
+	const result = {
 		name: plugin.name,
 		buildStart,
 		buildStartMeta,
@@ -1882,9 +2095,14 @@ function bindingifyPlugin(plugin, options, outputOptions, pluginContextData, nor
 		transformCacheHit,
 		transformCacheHitMeta,
 		hookUsage
-	});
+	};
+	return wrapHandlers(result, {
+		key: plugin,
+		name: result.name,
+		kind: "plugin"
+	}, timings);
 }
-function wrapHandlers(plugin) {
+function wrapHandlers(plugin, owner, timings) {
 	for (const hookName of [
 		"buildStart",
 		"resolveId",
@@ -1910,7 +2128,8 @@ function wrapHandlers(plugin) {
 		"closeWatcher",
 		"transformCacheHit"
 	]) {
-		const handler = plugin[hookName];
+		const raw = plugin[hookName];
+		const handler = raw && measureHookCost(timings, owner, hookName, raw);
 		if (handler) plugin[hookName] = async (...args) => {
 			try {
 				return await handler(...args);
@@ -1980,27 +2199,27 @@ function getDefaultDevRuntime(host = "localhost", port = 3e3) {
 }
 //#endregion
 //#region src/utils/bindingify-input-options.ts
-function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode) {
+function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode, timings) {
 	const plugins = rawPlugins.map((plugin) => {
 		if (getParallelPluginInfo(plugin)) return;
 		if (plugin instanceof BuiltinPlugin) switch (plugin.name) {
 			case "builtin:vite-manifest": return bindingifyManifestPlugin(plugin, pluginContextData);
 			default: return bindingifyBuiltInPlugin(plugin);
 		}
-		return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode);
+		return bindingifyPlugin(plugin, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode, timings);
 	});
 	const normalizedTransform = normalizeTransformOptions(inputOptions);
 	return {
 		input: bindingifyInput(inputOptions.input),
 		plugins,
 		cwd: inputOptions.cwd ?? process.cwd(),
-		external: bindingifyExternal(inputOptions.external),
+		external: bindingifyExternal(inputOptions.external, timings),
 		resolve: bindingifyResolve(inputOptions.resolve),
 		platform: inputOptions.platform,
 		shimMissingExports: inputOptions.shimMissingExports,
 		logLevel: bindingifyLogLevel(logLevel),
 		onLog,
-		treeshake: bindingifyTreeshakeOptions(inputOptions.treeshake),
+		treeshake: bindingifyTreeshakeOptions(inputOptions.treeshake, timings),
 		moduleTypes: inputOptions.moduleTypes,
 		define: normalizedTransform.define,
 		inject: bindingifyInject(normalizedTransform.inject),
@@ -2011,6 +2230,7 @@ function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, pluginC
 		dropLabels: normalizedTransform.dropLabels,
 		keepNames: outputOptions.keepNames,
 		checks: inputOptions.checks,
+		pluginTimings: timings ? () => summarizePluginTimings(inputOptions) : void 0,
 		deferSyncScanData: () => {
 			let ret = [];
 			pluginContextData.moduleOptionMap.forEach((value, key) => {
@@ -2053,12 +2273,15 @@ function bindingifyAttachDebugInfo(attachDebugInfo) {
 		case "none": return import_binding.BindingAttachDebugInfo.None;
 	}
 }
-function bindingifyExternal(external) {
+function bindingifyExternal(external, timings) {
 	if (external) {
-		if (typeof external === "function") return (id, importer, isResolved) => {
-			if (id.startsWith("\0")) return false;
-			return external(id, importer, isResolved) ?? false;
-		};
+		if (typeof external === "function") {
+			const measured = measureHookCost(timings, INPUT_OPTIONS_OWNER, "external", external);
+			return (id, importer, isResolved) => {
+				if (id.startsWith("\0")) return false;
+				return measured(id, importer, isResolved) ?? false;
+			};
+		}
 		return arraify(external);
 	}
 }
@@ -2149,11 +2372,7 @@ function bindingifyInput(input) {
 }
 function bindingifyWatch(watch) {
 	if (watch) {
-		if (watch.notify) console.warn("The \"watch.notify\" option is deprecated. Please use \"watch.watcher\" instead.");
-		const watcher = {
-			...watch.notify,
-			...watch.watcher
-		};
+		const watcher = watch.watcher ?? {};
 		return {
 			buildDelay: watch.buildDelay,
 			skipWrite: watch.skipWrite,
@@ -2169,7 +2388,7 @@ function bindingifyWatch(watch) {
 		};
 	}
 }
-function bindingifyTreeshakeOptions(config) {
+function bindingifyTreeshakeOptions(config, timings) {
 	if (config === false) return;
 	if (config === true || config === void 0) return { moduleSideEffects: true };
 	let normalizedConfig = {
@@ -2200,7 +2419,7 @@ function bindingifyTreeshakeOptions(config) {
 		external: false,
 		sideEffects: true
 	}];
-	else normalizedConfig.moduleSideEffects = config.moduleSideEffects;
+	else normalizedConfig.moduleSideEffects = measureIfFunction(timings, INPUT_OPTIONS_OWNER, "treeshake.moduleSideEffects", config.moduleSideEffects);
 	return normalizedConfig;
 }
 function bindingifyMakeAbsoluteExternalsRelative(makeAbsoluteExternalsRelative) {
@@ -2222,4 +2441,4 @@ function bindingifyPreserveEntrySignatures(preserveEntrySignatures) {
 	};
 }
 //#endregion
-export { version as C, description as S, LOG_LEVEL_ERROR as _, transformModuleInfo as a, logLevelPriority as b, __decorate as c, PlainObjectLike as d, MinimalPluginContextImpl as f, LOG_LEVEL_DEBUG as g, normalizeLog as h, PluginContextData as i, transformAssetSource as l, normalizeHook as m, bindingifyPlugin as n, transformToRollupOutput as o, getParallelPluginInfo as p, RolldownMagicString as r, transformRenderedChunk as s, bindingifyInputOptions as t, lazyProp as u, LOG_LEVEL_INFO as v, VERSION as x, LOG_LEVEL_WARN as y };
+export { LOG_LEVEL_WARN as C, version as D, description as E, LOG_LEVEL_INFO as S, VERSION as T, getParallelPluginInfo as _, measureIfFunction as a, LOG_LEVEL_DEBUG as b, PluginContextData as c, transformRenderedChunk as d, __decorate as f, MinimalPluginContextImpl as g, PlainObjectLike as h, measureHookCost as i, transformModuleInfo as l, lazyProp as m, bindingifyPlugin as n, pluginTimingsRecorderFor as o, transformAssetSource as p, OUTPUT_OPTIONS_OWNER as r, RolldownMagicString as s, bindingifyInputOptions as t, transformToRollupOutput as u, normalizeHook as v, logLevelPriority as w, LOG_LEVEL_ERROR as x, normalizeLog as y };

package/dist/shared/{constructors-CNB5XL7Q.mjs → constructors-D-nFqBpo.mjs}

@@ -1,4 +1,4 @@
-import { a as makeBuiltinPluginCallable, n as BuiltinPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-CiPu-0L6.mjs";
+import { a as makeBuiltinPluginCallable, n as BuiltinPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-D58FhCur.mjs";
 //#region src/builtin-plugin/constructors.ts
 function viteModulePreloadPolyfillPlugin(config) {
 	return new BuiltinPlugin("builtin:vite-module-preload-polyfill", config);

package/dist/shared/{constructors-BIHQ8UmW.d.mts → constructors-ZoBQ0vUm.d.mts}

@@ -1,5 +1,5 @@
 import { A as BindingViteResolvePluginConfig, C as BindingViteDynamicImportVarsPluginConfig, D as BindingViteModulePreloadPolyfillPluginConfig, O as BindingViteReactRefreshWrapperPluginConfig, S as BindingViteBuildImportAnalysisPluginConfig, T as BindingViteJsonPluginConfig, k as BindingViteReporterPluginConfig, l as BindingIsolatedDeclarationPluginConfig, s as BindingEsmExternalRequirePluginConfig, w as BindingViteImportGlobPluginConfig } from "./binding-We_IfeZk.mjs";
-import { Gt as StringOrRegExp, I as BuiltinPlugin } from "./define-config-thpMQ05a.mjs";
+import { Gt as StringOrRegExp, I as BuiltinPlugin } from "./define-config-B4s318Ge.mjs";
 //#region src/builtin-plugin/constructors.d.ts
 declare function viteModulePreloadPolyfillPlugin(config?: BindingViteModulePreloadPolyfillPluginConfig): BuiltinPlugin;
 type DynamicImportVarsPluginConfig = Omit<BindingViteDynamicImportVarsPluginConfig, "include" | "exclude"> & {

package/dist/shared/{create-bundler-option-Be4KJzGL.mjs → create-bundler-option-BCSGycof.mjs}

@@ -1,7 +1,7 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
 import { a as logInputHookInOutputPlugin, n as error } from "./logs-DmYCAKcW.mjs";
-import { n as BuiltinPlugin } from "./normalize-string-or-regex-CiPu-0L6.mjs";
-import { a as transformModuleInfo, b as logLevelPriority, f as MinimalPluginContextImpl, g as LOG_LEVEL_DEBUG, h as normalizeLog, i as PluginContextData, l as transformAssetSource, m as normalizeHook, p as getParallelPluginInfo, s as transformRenderedChunk, t as bindingifyInputOptions, x as VERSION, y as LOG_LEVEL_WARN } from "./bindingify-input-options-BXQG8xz-.mjs";
+import { n as BuiltinPlugin } from "./normalize-string-or-regex-D58FhCur.mjs";
+import { C as LOG_LEVEL_WARN, T as VERSION, _ as getParallelPluginInfo, a as measureIfFunction, b as LOG_LEVEL_DEBUG, c as PluginContextData, d as transformRenderedChunk, g as MinimalPluginContextImpl, i as measureHookCost, l as transformModuleInfo, o as pluginTimingsRecorderFor, p as transformAssetSource, r as OUTPUT_OPTIONS_OWNER, t as bindingifyInputOptions, v as normalizeHook, w as logLevelPriority, y as normalizeLog } from "./bindingify-input-options-CK5aV8zx.mjs";
 import { a as unimplemented } from "./misc-DOSKtd97.mjs";
 import { Worker } from "node:worker_threads";
 import path, { sep } from "node:path";
@@ -2924,10 +2924,10 @@ function createTestingLogger() {
 }
 //#endregion
 //#region src/utils/bindingify-output-options.ts
-function bindingifyOutputOptions(outputOptions, pluginContextData) {
+function bindingifyOutputOptions(outputOptions, pluginContextData, timings) {
 	const { dir, format, exports, hashCharacters, sourcemap, sourcemapBaseUrl, sourcemapDebugIds, sourcemapFileNames, sourcemapExcludeSources, sourcemapIgnoreList, sourcemapPathTransform, name, assetFileNames, entryFileNames, chunkFileNames, banner, footer, postBanner, postFooter, intro, outro, esModule, globals, paths, generatedCode, file, sanitizeFileName, preserveModules, virtualDirname, legalComments, comments, preserveModulesRoot, manualChunks, topLevelVar, cleanDir, strictExecutionOrder } = outputOptions;
 	if (legalComments != null) logger.warn("`legalComments` option is deprecated, please use `comments.legal` instead.");
-	const { inlineDynamicImports, advancedChunks } = bindingifyCodeSplitting(outputOptions.codeSplitting, outputOptions.inlineDynamicImports, outputOptions.advancedChunks, manualChunks, pluginContextData);
+	const { inlineDynamicImports, advancedChunks } = bindingifyCodeSplitting(outputOptions.codeSplitting, outputOptions.inlineDynamicImports, outputOptions.advancedChunks, manualChunks, pluginContextData, timings);
 	return {
 		dir,
 		file: file == null ? void 0 : file,
@@ -2937,25 +2937,25 @@ function bindingifyOutputOptions(outputOptions, pluginContextData) {
 		sourcemap: bindingifySourcemap(sourcemap),
 		sourcemapBaseUrl,
 		sourcemapDebugIds,
-		sourcemapFileNames,
+		sourcemapFileNames: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "sourcemapFileNames", sourcemapFileNames),
 		sourcemapExcludeSources,
-		sourcemapIgnoreList: sourcemapIgnoreList ?? /node_modules/,
-		sourcemapPathTransform,
-		banner: bindingifyAddon(banner),
-		footer: bindingifyAddon(footer),
-		postBanner: bindingifyAddon(postBanner),
-		postFooter: bindingifyAddon(postFooter),
-		intro: bindingifyAddon(intro),
-		outro: bindingifyAddon(outro),
+		sourcemapIgnoreList: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "sourcemapIgnoreList", sourcemapIgnoreList ?? /node_modules/),
+		sourcemapPathTransform: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "sourcemapPathTransform", sourcemapPathTransform),
+		banner: bindingifyAddon(banner, "banner", timings),
+		footer: bindingifyAddon(footer, "footer", timings),
+		postBanner: bindingifyAddon(postBanner, "postBanner", timings),
+		postFooter: bindingifyAddon(postFooter, "postFooter", timings),
+		intro: bindingifyAddon(intro, "intro", timings),
+		outro: bindingifyAddon(outro, "outro", timings),
 		extend: outputOptions.extend,
-		globals,
-		paths,
+		globals: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "globals", globals),
+		paths: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "paths", paths),
 		generatedCode,
 		esModule,
 		name,
 		assetFileNames: bindingifyAssetFilenames(assetFileNames),
-		entryFileNames,
-		chunkFileNames,
+		entryFileNames: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "entryFileNames", entryFileNames),
+		chunkFileNames: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "chunkFileNames", chunkFileNames),
 		plugins: [],
 		minify: outputOptions.minify,
 		externalLiveBindings: outputOptions.externalLiveBindings,
@@ -2977,9 +2977,12 @@ function bindingifyOutputOptions(outputOptions, pluginContextData) {
 		persistentCache: outputOptions.persistentCache
 	};
 }
-function bindingifyAddon(configAddon) {
+function bindingifyAddon(configAddon, name, timings) {
 	if (configAddon == null || configAddon === "") return;
-	if (typeof configAddon === "function") return async (chunk) => configAddon(transformRenderedChunk(chunk));
+	if (typeof configAddon === "function") {
+		const measured = measureHookCost(timings, OUTPUT_OPTIONS_OWNER, name, configAddon);
+		return async (chunk) => measured(transformRenderedChunk(chunk));
+	}
 	return configAddon;
 }
 function bindingifyFormat(format) {
@@ -3024,7 +3027,7 @@ function bindingifyComments(comments) {
 	if (typeof comments === "boolean") return comments;
 	return comments;
 }
-function bindingifyCodeSplitting(codeSplitting, inlineDynamicImportsOption, advancedChunks, manualChunks, pluginContextData) {
+function bindingifyCodeSplitting(codeSplitting, inlineDynamicImportsOption, advancedChunks, manualChunks, pluginContextData, timings) {
 	let inlineDynamicImports;
 	let effectiveChunksOption;
 	if (codeSplitting === false) {
@@ -3067,10 +3070,11 @@ function bindingifyCodeSplitting(codeSplitting, inlineDynamicImportsOption, adva
 		advancedChunksResult = {
 			...restOptions,
 			groups: groups?.map((group) => {
-				const { name, ...restGroup } = group;
+				const { name, test, ...restGroup } = group;
 				return {
 					...restGroup,
-					name: typeof name === "function" ? (id, ctx) => name(id, new ChunkingContextImpl(ctx, pluginContextData)) : name
+					test: typeof test === "function" ? measureHookCost(timings, OUTPUT_OPTIONS_OWNER, "codeSplitting groups[].test", test) : test,
+					name: typeof name === "function" ? measureHookCost(timings, OUTPUT_OPTIONS_OWNER, "codeSplitting groups[].name", (id, ctx) => name(id, new ChunkingContextImpl(ctx, pluginContextData))) : name
 				};
 			})
 		};
@@ -3147,7 +3151,7 @@ const availableParallelism = () => {
 };
 //#endregion
 //#region src/utils/create-bundler-option.ts
-async function createBundlerOptions(inputOptions, outputOptions, watchMode) {
+async function createBundlerOptions(inputOptions, outputOptions, watchMode, measureTimings = false) {
 	const inputPlugins = await normalizePluginOption(inputOptions.plugins);
 	const outputPlugins = await normalizePluginOption(outputOptions.plugins);
 	const logLevel = inputOptions.logLevel || "info";
@@ -3157,14 +3161,20 @@ async function createBundlerOptions(inputOptions, outputOptions, watchMode) {
 	const normalizedInputPlugins = normalizePlugins(inputPlugins, ANONYMOUS_PLUGIN_PREFIX);
 	const normalizedOutputPlugins = normalizePlugins(hookOutputPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX);
 	let plugins = [...normalizedInputPlugins, ...checkOutputPluginOption(normalizedOutputPlugins, onLog)];
+	const timings = measureTimings && inputOptions.checks?.pluginTimings !== false ? pluginTimingsRecorderFor(inputOptions) : void 0;
+	if (timings) outputOptions = {
+		...outputOptions,
+		assetFileNames: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "assetFileNames", outputOptions.assetFileNames),
+		sanitizeFileName: measureIfFunction(timings, OUTPUT_OPTIONS_OWNER, "sanitizeFileName", outputOptions.sanitizeFileName)
+	};
 	const parallelPluginInitResult = await initializeParallelPlugins(plugins);
 	if (inputOptions.experimental?.strictExecutionOrder !== void 0) console.warn("`experimental.strictExecutionOrder` has been stabilized and moved to `output.strictExecutionOrder`. Please update your configuration.");
 	try {
 		const pluginContextData = new PluginContextData(onLog, outputOptions, normalizedInputPlugins, normalizedOutputPlugins);
 		return {
 			bundlerOptions: {
-				inputOptions: bindingifyInputOptions(plugins, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode),
-				outputOptions: bindingifyOutputOptions(outputOptions, pluginContextData),
+				inputOptions: bindingifyInputOptions(plugins, inputOptions, outputOptions, pluginContextData, normalizedOutputPlugins, onLog, logLevel, watchMode, timings),
+				outputOptions: bindingifyOutputOptions(outputOptions, pluginContextData, timings),
 				parallelPluginsRegistry: parallelPluginInitResult?.registry
 			},
 			inputOptions,

package/dist/shared/{define-config-thpMQ05a.d.mts → define-config-B4s318Ge.d.mts}

@@ -3402,10 +3402,6 @@ interface WatcherOptions {
    * File watcher options for configuring how file changes are detected.
    */
   watcher?: WatcherFileWatcherOptions;
-  /**
-   * @deprecated Use {@linkcode watcher} instead.
-   */
-  notify?: WatcherFileWatcherOptions;
   /**
    * Filter to limit the file-watching to certain files.
    *
@@ -4009,8 +4005,9 @@ interface InputOptions {
    * Devtools integration options.
    *
    * When enabled, Rolldown writes JSON-lines devtools output under
-   * `node_modules/.rolldown/{session_id}/`. Consumers can parse the output with
-   * `@rollipop/rolldown-debug` after `await bundle.close()` resolves.
+   * `node_modules/.rolldown/{session_id}/`, resolved against {@linkcode cwd}.
+   * Consumers can parse the output with `@rollipop/rolldown-debug` after
+   * `await bundle.close()` resolves.
    *
    * @experimental
    */

package/dist/shared/{error-bm-jLrD1.mjs → error-C9I-OQs1.mjs}

@@ -1,4 +1,4 @@
-import { t as require_binding } from "./binding-D_XVvOPT.mjs";
+import { t as require_binding } from "./binding-ifF5pKXl.mjs";
 //#region src/types/sourcemap.ts
 function bindingifySourcemap(map) {
 	if (map == null) return;

package/dist/shared/{load-config-Bu7-JwX4.mjs → load-config-CE9Pt71R.mjs}

@@ -1,4 +1,4 @@
-import { t as rolldown } from "./rolldown-CnVo3ESi.mjs";
+import { t as rolldown } from "./rolldown-DU5IqqRG.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { readdir } from "node:fs/promises";

package/dist/shared/{normalize-string-or-regex-CiPu-0L6.mjs → normalize-string-or-regex-D58FhCur.mjs}

@@ -1,4 +1,4 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
 import { l as logPluginError, n as error } from "./logs-DmYCAKcW.mjs";
 //#region src/builtin-plugin/utils.ts
 var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);

package/dist/shared/{parse-DFZrcERz.mjs → parse-BySe_25L.mjs}

@@ -1,5 +1,5 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
-//#region ../../node_modules/.pnpm/oxc-parser@0.142.0/node_modules/oxc-parser/src-js/wrap.js
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.143.0/node_modules/oxc-parser/src-js/wrap.js
 var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
 function wrap(result) {
 	let program, module, comments, errors;

package/dist/shared/{resolve-tsconfig-CsDgQmsO.mjs → resolve-tsconfig-DJFsWuhV.mjs}

@@ -1,5 +1,5 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
-import { a as bindingifySourcemap, n as normalizeBindingError } from "./error-bm-jLrD1.mjs";
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
+import { a as bindingifySourcemap, n as normalizeBindingError } from "./error-C9I-OQs1.mjs";
 //#region src/utils/minify.ts
 var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
 /**

package/dist/shared/{rolldown-CnVo3ESi.mjs → rolldown-DU5IqqRG.mjs}

@@ -1,7 +1,7 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
-import { c as __decorate, d as PlainObjectLike, o as transformToRollupOutput, u as lazyProp } from "./bindingify-input-options-BXQG8xz-.mjs";
-import { l as PluginDriver, s as validateOption, t as createBundlerOptions } from "./create-bundler-option-Be4KJzGL.mjs";
-import { i as unwrapBindingResult } from "./error-bm-jLrD1.mjs";
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
+import { f as __decorate, h as PlainObjectLike, m as lazyProp, u as transformToRollupOutput } from "./bindingify-input-options-CK5aV8zx.mjs";
+import { l as PluginDriver, s as validateOption, t as createBundlerOptions } from "./create-bundler-option-BCSGycof.mjs";
+import { i as unwrapBindingResult } from "./error-C9I-OQs1.mjs";
 //#region src/types/rolldown-output-impl.ts
 var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
 var RolldownOutputImpl = class extends PlainObjectLike {
@@ -123,7 +123,7 @@ var RolldownBuild = class {
 	async #build(isWrite, outputOptions) {
 		validateOption("output", outputOptions);
 		await this.#stopWorkers?.();
-		const option = await createBundlerOptions(this.#inputOptions, outputOptions, false);
+		const option = await createBundlerOptions(this.#inputOptions, outputOptions, false, true);
 		try {
 			this.#stopWorkers = option.stopWorkers;
 			let output;

package/dist/shared/{watch-WV6bq5kw.mjs → watch-BwY0As4l.mjs}

@@ -1,9 +1,9 @@
-import { n as __toESM, t as require_binding } from "./binding-D_XVvOPT.mjs";
+import { n as __toESM, t as require_binding } from "./binding-ifF5pKXl.mjs";
 import { s as logMultipleWatcherOption } from "./logs-DmYCAKcW.mjs";
-import { y as LOG_LEVEL_WARN } from "./bindingify-input-options-BXQG8xz-.mjs";
+import { C as LOG_LEVEL_WARN } from "./bindingify-input-options-CK5aV8zx.mjs";
 import { t as arraify } from "./misc-DOSKtd97.mjs";
-import { l as PluginDriver, t as createBundlerOptions } from "./create-bundler-option-Be4KJzGL.mjs";
-import { t as aggregateBindingErrorsIntoJsError } from "./error-bm-jLrD1.mjs";
+import { l as PluginDriver, t as createBundlerOptions } from "./create-bundler-option-BCSGycof.mjs";
+import { t as aggregateBindingErrorsIntoJsError } from "./error-C9I-OQs1.mjs";
 //#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
 /**
 * This is not the set of all possible signals.
@@ -327,7 +327,7 @@ function warnMultiplePollingOptions(bundlerOptions) {
 	let found = false;
 	for (const option of bundlerOptions) {
 		const watch = option.inputOptions.watch;
-		const watcher = watch && typeof watch === "object" ? watch.watcher ?? watch.notify : void 0;
+		const watcher = watch && typeof watch === "object" ? watch.watcher : void 0;
 		if (watcher && (watcher.usePolling != null || watcher.pollInterval != null)) {
 			if (found) {
 				option.onLog(LOG_LEVEL_WARN, logMultipleWatcherOption());

package/dist/utils-index.d.mts

@@ -2,7 +2,7 @@ import { b as BindingTsconfigRawOptions, y as BindingTsconfigCompilerOptions } f
 import { a as MinifyOptions, c as minifySync, d as parse, f as parseSync, i as transformSync, l as ParseResult, n as TransformResult, o as MinifyResult, p as TsconfigCache, r as transform, s as minify, t as TransformOptions, u as ParserOptions } from "./shared/transform-CsZGbS4Q.mjs";
 import * as ESTree from "@oxc-project/types";
 import { Program } from "@oxc-project/types";
-//#region ../../node_modules/.pnpm/oxc-parser@0.142.0/node_modules/oxc-parser/src-js/generated/visit/visitor.d.ts
+//#region ../../node_modules/.pnpm/oxc-parser@0.143.0/node_modules/oxc-parser/src-js/generated/visit/visitor.d.ts
 interface VisitorObject$1 {
   DebuggerStatement?: (node: ESTree.DebuggerStatement) => void;
   "DebuggerStatement:exit"?: (node: ESTree.DebuggerStatement) => void;