@rollipop/rolldown 1.0.20 → 1.0.22

package/dist/shared/{define-config-xmEHQczI.d.mts → define-config-BdEm3DW7.d.mts}

@@ -1,5 +1,5 @@
 import { a as RolldownLog, i as RolldownError, n as LogLevelOption, o as RolldownLogWithString, r as LogOrStringHandler, t as LogLevel } from "./logging-BSNejiLS.mjs";
-import { F as JsxOptions, H as PreRenderedChunk, I as MinifyOptions$1, K as TransformOptions$1, M as ExternalMemoryStatus, V as ParserOptions, _ as BindingTransformHookExtraArgs, c as BindingHookResolveIdExtraArgs, d as BindingPluginContextResolveOptions, j as BindingWatcherBundler, p as BindingRenderedChunk, t as BindingBuiltinPluginName, u as BindingMagicString, z as OxcReactCompilerOptions } from "./binding-DE7ERejD.mjs";
+import { F as JsxOptions$1, H as PreRenderedChunk, I as MinifyOptions$1, M as ExternalMemoryStatus, U as ReactRefreshOptions$1, V as ParserOptions, _ as BindingTransformHookExtraArgs, c as BindingHookResolveIdExtraArgs, d as BindingPluginContextResolveOptions, j as BindingWatcherBundler, p as BindingRenderedChunk, q as TransformOptions$1, t as BindingBuiltinPluginName, u as BindingMagicString, z as OxcReactCompilerOptions } from "./binding-CckXxUel.mjs";
 import { TopLevelFilterExpression } from "@rolldown/pluginutils";
 import { Program } from "@oxc-project/types";
 
@@ -420,6 +420,22 @@ interface OutputOptions {
   */
   sourcemapBaseUrl?: string;
   /**
+  * The pattern to use for sourcemaps created from entry points, or a function that is called per entry chunk with {@linkcode PreRenderedChunk} to return such a pattern.
+  *
+  * Patterns support the following placeholders:
+  * - `[format]`: The rendering format defined in the output options. The value is any of {@linkcode InternalModuleFormat}.
+  * - `[hash]`: A hash based only on the content of the final generated sourcemap.  You can also set a specific hash length via e.g. `[hash:10]`. By default, it will create a base-64 hash. If you need a reduced character set, see {@linkcode hashCharacters | output.hashCharacters}.
+  * - `[chunkhash]`: The same hash as the one used for the corresponding generated chunk (if any).
+  * - `[name]`: The name of the corresponding chunk.
+  *
+  * Forward slashes (`/`) can be used to place files in sub-directories. This pattern will also be used for every file when setting the {@linkcode preserveModules | output.preserveModules} option.
+  *
+  * See also {@linkcode assetFileNames | output.assetFileNames}, {@linkcode chunkFileNames | output.chunkFileNames}.
+  *
+  * @default the corresponding chunk filename with `.map` appended
+  */
+  sourcemapFileNames?: string | ChunkFileNamesFunction;
+  /**
   * Whether to include [debug IDs](https://github.com/tc39/ecma426/blob/main/proposals/debug-id.md) in the sourcemap.
   *
   * When `true`, a unique debug ID will be emitted in source and sourcemaps which streamlines identifying sourcemaps across different builds.
@@ -1304,7 +1320,7 @@ declare class RolldownBuild {
   *
   * @example
   * ```js
-  * import { rolldown } from 'rolldown';
+  * import { rolldown } from '@rollipop/rolldown';
   *
   * {
   *   using bundle = await rolldown({ input: 'src/main.js' });
@@ -1335,7 +1351,7 @@ declare class RolldownBuild {
 *
 * @example
 * ```js
-* import { rolldown } from 'rolldown';
+* import { rolldown } from '@rollipop/rolldown';
 *
 * let bundle, failed = false;
 * try {
@@ -1445,7 +1461,7 @@ interface RolldownWatcher {
 *
 * @example
 * ```js
-* import { watch } from 'rolldown';
+* import { watch } from '@rollipop/rolldown';
 *
 * const watcher = watch({ /* ... *\/ });
 * watcher.on('event', (event) => {
@@ -1529,6 +1545,9 @@ interface ChecksOptions {
   * Annotations placed where they cannot annotate a call expression (e.g. before a non-call expression,
   * before a statement declaration, or between an identifier and `=` in a variable declarator) are
   * ignored by the parser. Matches Rollup's `INVALID_ANNOTATION` log code.
+  *
+  * By default, warnings are emitted only for local project files inside `cwd` and outside
+  * `node_modules`. Set this option to `false` to disable the warning entirely.
   * @default true
   * */
   invalidAnnotation?: boolean;
@@ -1659,6 +1678,26 @@ interface ChecksOptions {
 }
 //#endregion
 //#region src/options/transform-options.d.ts
+interface ReactRefreshOptions extends ReactRefreshOptions$1 {
+  /**
+  * File patterns to transform. Empty means all files that enter the transform pipeline.
+  */
+  include?: StringOrRegExp | StringOrRegExp[];
+  /**
+  * File patterns to skip.
+  */
+  exclude?: StringOrRegExp | StringOrRegExp[];
+}
+interface JsxOptions extends Omit<JsxOptions$1, "refresh"> {
+  /**
+  * Enable React Fast Refresh.
+  */
+  refresh?: boolean | ReactRefreshOptions;
+  /**
+  * Enable React Compiler.
+  */
+  compiler?: OxcReactCompilerOptions;
+}
 interface TransformOptions extends Omit<TransformOptions$1, "sourceType" | "lang" | "cwd" | "sourcemap" | "define" | "inject" | "jsx"> {
   /**
   * Replace global variables or [property accessors](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors) with the provided values.
@@ -1769,7 +1808,6 @@ interface TransformOptions extends Omit<TransformOptions$1, "sourceType" | "lang
   * - If set to `'preserve'`, JSX syntax will be preserved as-is.
   */
   jsx?: false | "react" | "react-jsx" | "preserve" | JsxOptions;
-  reactCompiler?: OxcReactCompilerOptions;
 }
 //#endregion
 //#region src/options/normalized-input-options.d.ts
@@ -1806,6 +1844,8 @@ interface NormalizedOutputOptions {
   dir: string | undefined;
   /** @see {@linkcode OutputOptions.entryFileNames | entryFileNames} */
   entryFileNames: string | ChunkFileNamesFunction;
+  /** @see {@linkcode OutputOptions.sourcemapFileNames | sourcemapFileNames} */
+  sourcemapFileNames: string | ChunkFileNamesFunction | undefined;
   /** @see {@linkcode OutputOptions.chunkFileNames | chunkFileNames} */
   chunkFileNames: string | ChunkFileNamesFunction;
   /** @see {@linkcode OutputOptions.assetFileNames | assetFileNames} */
@@ -2627,8 +2667,8 @@ type OverrideFilterObject = {
 * @example
 * ```ts
 * import yaml from '@rollup/plugin-yaml';
-* import { defineConfig } from 'rolldown';
-* import { withFilter } from 'rolldown/filter';
+* import { defineConfig } from '@rollipop/rolldown';
+* import { withFilter } from '@rollipop/rolldown/filter';
 *
 * export default defineConfig({
 *   plugins: [
@@ -2652,6 +2692,28 @@ type ModuleSideEffects = boolean | "no-treeshake" | null;
 type ModuleType = "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | (string & {});
 /** @category Plugin APIs */
 type ImportKind = BindingHookResolveIdExtraArgs["kind"];
+/**
+* Descriptive metadata a plugin can expose about itself.
+*
+* Set it via the {@linkcode Plugin.meta | meta} property of the plugin object.
+*
+* @category Plugin APIs
+*/
+interface PluginMeta {
+  /**
+  * The name of the npm package the plugin ships in, e.g. `@vitejs/plugin-vue`.
+  */
+  packageName?: string;
+  /**
+  * The version of the npm package the plugin ships in, e.g. `5.0.0`. The
+  * `version` field of that package's `package.json`.
+  */
+  version?: string;
+  /**
+  * A short, human-readable description of what the plugin does.
+  */
+  description?: string;
+}
 /** @category Plugin APIs */
 interface CustomPluginOptions {
   [plugin: string]: any;
@@ -2661,6 +2723,31 @@ interface ModuleOptions {
   moduleSideEffects: ModuleSideEffects;
   /** See [Custom module meta-data section](https://rolldown.rs/apis/plugin-api/inter-plugin-communication#custom-module-meta-data) for more details. */
   meta: CustomPluginOptions;
+  /**
+  * A short, human-readable description of the module.
+  *
+  * This is useful for virtual modules, whose ids (e.g.
+  * `\0vite/modulepreload-polyfill.js`) do not convey their purpose on their own.
+  *
+  * @example
+  * ```js
+  * function polyfillPlugin() {
+  *   return {
+  *     name: 'vite:modulepreload-polyfill',
+  *      load: {
+  *        filter: { id: /^\0vite\/modulepreload-polyfill\.js$/ },
+  *        handler(id) {
+  *          return {
+  *            code: '',
+  *            description: 'A polyfill for `link` tag with `rel="modulepreload"`',
+  *          };
+  *        }
+  *      },
+  *   };
+  * }
+  * ```
+  */
+  description?: string;
   invalidate?: boolean;
   packageJsonPath?: string;
 }
@@ -3090,6 +3177,15 @@ interface OutputPlugin extends Partial<{ [K in keyof PluginHooks as K & OutputPl
   name: string;
   /** The version of the plugin, for use in inter-plugin communication scenarios. */
   version?: string;
+  /**
+  * Descriptive metadata about the plugin, such as the npm package it ships in.
+  *
+  * This does not affect bundling; it is informational and intended to be
+  * surfaced by tooling that inspects a build. See {@linkcode PluginMeta}.
+  *
+  * @experimental
+  */
+  meta?: PluginMeta;
 }
 /**
 * The Plugin interface.
@@ -3371,7 +3467,7 @@ interface InputOptions {
   *
   * @example
   * ```js
-  * import { defineConfig } from 'rolldown'
+  * import { defineConfig } from '@rollipop/rolldown'
   *
   * export default defineConfig({
   *   plugins: [
@@ -3575,7 +3671,7 @@ interface InputOptions {
   *
   * @example
   * ```js
-  * import { defineConfig } from 'rolldown'
+  * import { defineConfig } from '@rollipop/rolldown'
   *
   * export default defineConfig({
   *   moduleTypes: {
@@ -3776,7 +3872,7 @@ interface InputOptions {
     * describing your use case so we can address it before the option is gone.
     *
     * @see {@link https://rolldown.rs/in-depth/lazy-barrel-optimization | Lazy Barrel Documentation}
-    * @default true
+    * @default false
     */
     lazyBarrel?: boolean;
   };
@@ -3892,7 +3988,7 @@ type RolldownOptionsFunction = (commandLineArguments: Record<string, any>) => Ma
 *
 * @example
 * ```js [rolldown.config.js]
-* import { defineConfig } from 'rolldown';
+* import { defineConfig } from '@rollipop/rolldown';
 *
 * export default defineConfig({
 *   input: 'src/main.js',
@@ -3909,4 +4005,4 @@ declare function defineConfig(config: RolldownOptions[]): RolldownOptions[];
 declare function defineConfig(config: RolldownOptionsFunction): RolldownOptionsFunction;
 declare function defineConfig(config: ConfigExport): ConfigExport;
 //#endregion
-export { PluginContextMeta as $, RolldownPluginOption as A, CodeSplittingGroup as At, OutputBundle as B, PreRenderedAsset as Bt, ParallelPluginHooks as C, build as Ct, ResolveIdResult as D, BuiltinModuleTag as Dt, ResolveIdExtraOptions as E, AdvancedChunksOptions as Et, RUNTIME_MODULE_ID as F, GeneratedCodePreset as Ft, EmittedFile as G, OutputChunk as Gt, TransformPluginContext as H, PartialNull as Ht, VERSION as I, GlobalsFunction as It, PluginContext as J, RolldownOutput as Jt, EmittedPrebuiltChunk as K, RenderedChunk as Kt, BundleError as L, MinifyOptions as Lt, TransformResult as M, CodeSplittingOptions as Mt, withFilter as N, CommentsOptions as Nt, ResolvedId as O, ChunkFileNamesFunction as Ot, BuiltinPlugin as P, GeneratedCodeOptions as Pt, MinimalPluginContext as Q, SourcemapIgnoreListOption as Qt, ExistingRawSourceMap as R, ModuleFormat as Rt, ObjectHook as S, BuildOptions as St, Plugin as T, AdvancedChunksGroup as Tt, EmittedAsset as U, StringOrRegExp as Ut, TreeshakingOptions as V, MaybePromise as Vt, EmittedChunk as W, OutputAsset as Wt, DefineParallelPluginResult as X, freeExternalMemory as Xt, PluginContextResolveOptions as Y, SourceMap as Yt, defineParallelPlugin as Z, ModuleInfo as Zt, HookFilterExtension as _, RolldownWatcherEvent as _t, ChunkOptimizationOptions as a, RolldownFileStats as at, ModuleOptions as b, rolldown as bt, InputOption as c, NormalizedOutputOptions as ct, OptimizationOptions as d, ChecksOptions as dt, GeneralHookFilter as et, WatcherFileWatcherOptions as f, LoggingFunction as ft, FunctionPluginHooks as g, RolldownWatcher as gt, CustomPluginOptions as h, watch as ht, RolldownOptions as i, RolldownDirectoryEntry as it, SourceDescription as j, CodeSplittingNameFunction as jt, RolldownPlugin as k, ChunkingContext as kt, InputOptions as l, NormalizedInputOptions as lt, AsyncPluginHooks as m, RolldownMagicString as mt, RolldownOptionsFunction as n, ModuleTypeFilter as nt, ExternalOption as o, RolldownFsModule as ot, WatcherOptions as p, WarningHandlerWithDefault as pt, GetModuleInfo as q, RenderedModule as qt, defineConfig as r, BufferEncoding as rt, ExternalOptionFunction as s, InternalModuleFormat as st, ConfigExport as t, HookFilter as tt, ModuleTypes as u, TransformOptions as ut, ImportKind as v, RolldownWatcherWatcherEventMap as vt, PartialResolvedId as w, AddonFunction as wt, ModuleType as x, RolldownBuild as xt, LoadResult as y, WatchOptions as yt, SourceMapInput as z, OutputOptions as zt };
+export { MinimalPluginContext as $, SourcemapIgnoreListOption as $t, RolldownPlugin as A, ChunkingContext as At, SourceMapInput as B, OutputOptions as Bt, ParallelPluginHooks as C, BuildOptions as Ct, ResolveIdExtraOptions as D, AdvancedChunksOptions as Dt, PluginMeta as E, AdvancedChunksGroup as Et, BuiltinPlugin as F, GeneratedCodeOptions as Ft, EmittedChunk as G, OutputAsset as Gt, TreeshakingOptions as H, MaybePromise as Ht, RUNTIME_MODULE_ID as I, GeneratedCodePreset as It, GetModuleInfo as J, RenderedModule as Jt, EmittedFile as K, OutputChunk as Kt, VERSION as L, GlobalsFunction as Lt, SourceDescription as M, CodeSplittingNameFunction as Mt, TransformResult as N, CodeSplittingOptions as Nt, ResolveIdResult as O, BuiltinModuleTag as Ot, withFilter as P, CommentsOptions as Pt, defineParallelPlugin as Q, ModuleInfo as Qt, BundleError as R, MinifyOptions as Rt, ObjectHook as S, RolldownBuild as St, Plugin as T, AddonFunction as Tt, TransformPluginContext as U, PartialNull as Ut, OutputBundle as V, PreRenderedAsset as Vt, EmittedAsset as W, StringOrRegExp as Wt, PluginContextResolveOptions as X, SourceMap as Xt, PluginContext as Y, RolldownOutput as Yt, DefineParallelPluginResult as Z, freeExternalMemory as Zt, HookFilterExtension as _, RolldownWatcher as _t, ChunkOptimizationOptions as a, RolldownDirectoryEntry as at, ModuleOptions as b, WatchOptions as bt, InputOption as c, InternalModuleFormat as ct, OptimizationOptions as d, TransformOptions as dt, PluginContextMeta as et, WatcherFileWatcherOptions as f, ChecksOptions as ft, FunctionPluginHooks as g, watch as gt, CustomPluginOptions as h, RolldownMagicString as ht, RolldownOptions as i, BufferEncoding as it, RolldownPluginOption as j, CodeSplittingGroup as jt, ResolvedId as k, ChunkFileNamesFunction as kt, InputOptions as l, NormalizedOutputOptions as lt, AsyncPluginHooks as m, WarningHandlerWithDefault as mt, RolldownOptionsFunction as n, HookFilter as nt, ExternalOption as o, RolldownFileStats as ot, WatcherOptions as p, LoggingFunction as pt, EmittedPrebuiltChunk as q, RenderedChunk as qt, defineConfig as r, ModuleTypeFilter as rt, ExternalOptionFunction as s, RolldownFsModule as st, ConfigExport as t, GeneralHookFilter as tt, ModuleTypes as u, NormalizedInputOptions as ut, ImportKind as v, RolldownWatcherEvent as vt, PartialResolvedId as w, build as wt, ModuleType as x, rolldown as xt, LoadResult as y, RolldownWatcherWatcherEventMap as yt, ExistingRawSourceMap as z, ModuleFormat as zt };

package/dist/shared/dist-DKbukT1H.mjs

@@ -0,0 +1,154 @@
+import { Module } from "node:module";
+import { MessageChannel } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+//#region ../../node_modules/.pnpm/fresh-import@0.2.1/node_modules/fresh-import/dist/index.js
+const instanceId = Math.random().toString(36).slice(2);
+const relativeImportRE = /^\.{1,2}(?:\/|\\)/;
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* The tracking query name `fresh-import-<instance>`, where `<instance>` is a
+* random value unique to this loaded module instance. Any two instances (even
+* two copies of the same build loaded into the same process) get distinct
+* names, so each hook only recognizes the imports it tagged itself.
+*/
+function buildQueryName() {
+	return `fresh-import-${instanceId}`;
+}
+/**
+* Build the regex that matches the tracking query `?<name>=<id>,<context>`
+* (or the `&<name>=...` form).
+*/
+function buildQueryRE(queryName) {
+	return new RegExp(`(?:\\?|&)${escapeRegExp(queryName)}=(\\d+),([^&]+)(?:&|$)`);
+}
+/**
+* Build the tracking query `?<name>=<id>,<context>` that `collect` appends to
+* the entry specifier. `id` cache-busts the import (a distinct URL forces a
+* fresh evaluation) and `context` tags the import graph so the resolve hook can
+* attribute resolved dependencies back to the originating collect.
+*/
+function formatTrackingQuery(queryName, id, context) {
+	return `?${queryName}=${id},${context}`;
+}
+/**
+* Shared body of the resolve hook for both the on-thread and off-thread
+* importers. Given an already-resolved `result`, decides whether it is a tracked
+* relative file dependency; if so, reports it via `onDependency` and tags the
+* URL so the query propagates to its own dependencies.
+*
+* The sync/async difference between the two hooks lives entirely in the caller
+* (which awaits `nextResolve` or not); this function performs no I/O. `result`
+* is mutated in place and returned.
+*/
+function trackResolved(specifier, context, result, queryName, queryRE, onDependency) {
+	const isRelativeImport = relativeImportRE.test(specifier);
+	if (result.format === "builtin" || !isRelativeImport) return result;
+	if (!context.parentURL || queryRE.test(result.url) || !result.url.startsWith("file:")) return result;
+	const m = queryRE.exec(context.parentURL);
+	if (m) {
+		const [, id, contextFile] = m;
+		onDependency(contextFile, result.url);
+		result.url = result.url.replace(/(\?)|$/, (_n, n1) => `?${queryName}=${id},${contextFile}${n1 === "?" ? "&" : ""}`);
+	}
+	return result;
+}
+var loader_default = "data:text/javascript,Math.random().toString(36).slice(2);%0Aconst relativeImportRE = /^\\.{1,2}(%3F:\\/|\\\\)/;%0Afunction escapeRegExp(value) {%0A%09return value.replace(/[.*+%3F^${}()|[\\]\\\\]/g, \"\\\\$&\");%0A}%0A/**%0A* Build the regex that matches the tracking query `%3F<name>=<id>,<context>`%0A* (or the `&<name>=...` form).%0A*/%0Afunction buildQueryRE(queryName) {%0A%09return new RegExp(`(%3F:\\\\%3F|&)${escapeRegExp(queryName)}=(\\\\d+),([^&]+)(%3F:&|$)`);%0A}%0A/**%0A* Shared body of the resolve hook for both the on-thread and off-thread%0A* importers. Given an already-resolved `result`, decides whether it is a tracked%0A* relative file dependency; if so, reports it via `onDependency` and tags the%0A* URL so the query propagates to its own dependencies.%0A*%0A* The sync/async difference between the two hooks lives entirely in the caller%0A* (which awaits `nextResolve` or not); this function performs no I/O. `result`%0A* is mutated in place and returned.%0A*/%0Afunction trackResolved(specifier, context, result, queryName, queryRE, onDependency) {%0A%09const isRelativeImport = relativeImportRE.test(specifier);%0A%09if (result.format === \"builtin\" || !isRelativeImport) return result;%0A%09if (!context.parentURL || queryRE.test(result.url) || !result.url.startsWith(\"file:\")) return result;%0A%09const m = queryRE.exec(context.parentURL);%0A%09if (m) {%0A%09%09const [, id, contextFile] = m;%0A%09%09onDependency(contextFile, result.url);%0A%09%09result.url = result.url.replace(/(\\%3F)|$/, (_n, n1) => `%3F${queryName}=${id},${contextFile}${n1 === \"%3F\" %3F \"&\" : \"\"}`);%0A%09}%0A%09return result;%0A}%0A//%23endregion%0A//%23region src/off-thread/loader.ts%0Alet port;%0Alet queryName;%0Alet queryRE;%0Aconst initialize = async (data) => {%0A%09port = data.port;%0A%09queryName = data.queryName;%0A%09queryRE = buildQueryRE(queryName);%0A};%0Aconst resolve = async (specifier, context, nextResolve) => {%0A%09return trackResolved(specifier, context, await nextResolve(specifier, context), queryName, queryRE, (ctx, url) => {%0A%09%09port.postMessage({%0A%09%09%09context: ctx,%0A%09%09%09url%0A%09%09});%0A%09});%0A};%0A//%23endregion%0Aexport { initialize, resolve };%0A";
+let nextId$1 = 0;
+/**
+* Off-thread importer: registers an ESM loader in a worker thread via
+* `Module.register` and receives tracked dependencies over a `MessagePort`.
+* Used on Node versions without `Module.registerHooks`.
+*/
+function createOffThreadImporter() {
+	const queryName = buildQueryName();
+	const { port1, port2 } = new MessageChannel();
+	Module.register(loader_default, {
+		data: {
+			port: port2,
+			queryName
+		},
+		transferList: [port2]
+	});
+	port1.unref();
+	return { async collect(specifier) {
+		const id = nextId$1++;
+		const depsList = /* @__PURE__ */ new Set();
+		const onMessage = (e) => {
+			if (e.context === specifier) depsList.add(e.url);
+		};
+		port1.on("message", onMessage);
+		port1.unref();
+		try {
+			const result = await import(specifier + formatTrackingQuery(queryName, id, specifier));
+			await new Promise((resolve) => setImmediate(resolve));
+			return {
+				result,
+				dependencies: [...depsList].filter((url) => url.startsWith("file:")).map((url) => fileURLToPath(url))
+			};
+		} finally {
+			port1.off("message", onMessage);
+		}
+	} };
+}
+let nextId = 0;
+/**
+* On-thread importer: registers synchronous resolution hooks via
+* `Module.registerHooks` (Node 22.15+/23.5+).
+*/
+function createOnThreadImporter() {
+	const registry = /* @__PURE__ */ new Map();
+	const queryName = buildQueryName();
+	const queryRE = buildQueryRE(queryName);
+	const resolve = (specifier, context, nextResolve) => {
+		return trackResolved(specifier, context, nextResolve(specifier, context), queryName, queryRE, (ctx, url) => {
+			registry.get(ctx)?.add(url);
+		});
+	};
+	Module.registerHooks({ resolve });
+	return { async collect(specifier) {
+		const id = nextId++;
+		const depsList = /* @__PURE__ */ new Set();
+		registry.set(specifier, depsList);
+		try {
+			return {
+				result: await import(specifier + formatTrackingQuery(queryName, id, specifier)),
+				dependencies: [...depsList].filter((url) => url.startsWith("file:")).map((url) => fileURLToPath(url))
+			};
+		} finally {
+			registry.delete(specifier);
+		}
+	} };
+}
+/**
+* Create the importer best suited to the current runtime, or `undefined` if it
+* provides neither module-hook API.
+*/
+function createImporter() {
+	if (Module.registerHooks) return createOnThreadImporter();
+	if (Module.register) return createOffThreadImporter();
+}
+let importer;
+let initialized = false;
+/**
+* Import an ESM entry in its own fresh module graph (separate from Node's module
+* cache and from other concurrent imports) and report the dependency files it
+* pulled in.
+*
+* Each call re-evaluates the entry in a fresh graph; concurrent calls stay
+* isolated from one another. Only statically-imported relative dependencies are
+* tracked, not dynamic imports.
+*
+* Returns `undefined` on runtimes that provide neither `Module.registerHooks`
+* nor `Module.register`.
+*/
+function freshImport(specifier) {
+	if (!initialized) {
+		importer = createImporter();
+		initialized = true;
+	}
+	return importer?.collect(specifier);
+}
+//#endregion
+export { freshImport };

package/dist/shared/{error-BmTEI0xY.mjs → error-D2KvICgd.mjs}

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

package/dist/shared/{get-log-filter-BpNVNJ5-.d.mts → get-log-filter-B4LpBryx.d.mts}

@@ -13,8 +13,8 @@ type GetLogFilter = (filters: string[]) => (log: RolldownLog) => boolean;
 *
 * @example
 * ```ts
-* import { defineConfig } from 'rolldown';
-* import { getLogFilter } from 'rolldown/getLogFilter';
+* import { defineConfig } from '@rollipop/rolldown';
+* import { getLogFilter } from '@rollipop/rolldown/getLogFilter';
 *
 * const logFilter = getLogFilter(['code:FOO', 'code:BAR']);
 *

package/dist/shared/{load-config-DY5kAiwf.mjs → load-config-C-H6Sxai.mjs}

@@ -1,4 +1,4 @@
-import { t as rolldown } from "./rolldown-C6DTtWMe.mjs";
+import { t as rolldown } from "./rolldown-BCi17Yn9.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { readdir } from "node:fs/promises";
@@ -98,21 +98,38 @@ function tryStatSync(file) {
 		return fs.statSync(file, { throwIfNoEntry: false });
 	} catch {}
 }
+async function loadNativeConfig(resolvedPath) {
+	const url = pathToFileURL(resolvedPath).href;
+	const { freshImport } = await import("./dist-DKbukT1H.mjs");
+	const freshImported = freshImport(url);
+	if (freshImported) {
+		const { result } = await freshImported;
+		return result.default;
+	}
+	return (await import(url + "?t=" + Date.now())).default;
+}
 /**
 * Load config from a file in a way that Rolldown does.
 *
 * @param configPath The path to the config file. If empty, it will look for `rolldown.config` with supported extensions in the current working directory.
+* @param options Loading options. `configLoader` selects `'bundle'` (default) or `'native'`.
 * @returns The loaded config export
 *
 * @category Config
 */
-async function loadConfig(configPath) {
+async function loadConfig(configPath, options = {}) {
+	const configLoader = options.configLoader ?? "bundle";
 	const ext = path.extname(configPath = configPath || await findConfigFileNameInCwd());
 	try {
+		if (configLoader === "native") return await loadNativeConfig(path.resolve(configPath));
 		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext) || process.env.NODE_OPTIONS?.includes("--import=tsx") && SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) return (await import(pathToFileURL(configPath).href)).default;
 		else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) return await loadTsConfig(path.resolve(configPath));
 		else throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(",")}\` but got \`${ext}\``);
 	} catch (err) {
+		if (configLoader === "native") {
+			const tsHint = SUPPORTED_TS_CONFIG_FORMATS.includes(ext) && !process.features.typescript ? " This runtime does not natively support TypeScript config files." : "";
+			throw new Error(`Failed to load the config file "${configPath}" using the "native" config loader.${tsHint} Try "--configLoader bundle", or register a loader such as "--import tsx".`, { cause: err });
+		}
 		throw new Error("Error happened while loading config.", { cause: err });
 	}
 }

package/dist/shared/{logs-aMKUxRpj.mjs → logs-ZGEh6uhb.mjs}

@@ -97,7 +97,12 @@ function locate(source, search, options) {
 }
 //#endregion
 //#region src/log/logs.ts
-const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING", MULTIPLE_WATCHER_OPTION = "MULTIPLE_WATCHER_OPTION", PARSE_ERROR = "PARSE_ERROR";
+const INVALID_LOG_POSITION = "INVALID_LOG_POSITION";
+const PLUGIN_ERROR = "PLUGIN_ERROR";
+const INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN";
+const CYCLE_LOADING = "CYCLE_LOADING";
+const MULTIPLE_WATCHER_OPTION = "MULTIPLE_WATCHER_OPTION";
+const PARSE_ERROR = "PARSE_ERROR";
 function logParseError(message, id, pos) {
 	return {
 		code: PARSE_ERROR,

package/dist/shared/{normalize-string-or-regex-Ddbkskw6.mjs → normalize-string-or-regex-BzQ-7a-8.mjs}

@@ -1,5 +1,5 @@
-import { n as __toESM, t as require_binding } from "./binding-DamCAbY6.mjs";
-import { c as logPluginError, n as error } from "./logs-aMKUxRpj.mjs";
+import { n as __toESM, t as require_binding } from "./binding-9kL0gFYL.mjs";
+import { c as logPluginError, n as error } from "./logs-ZGEh6uhb.mjs";
 //#region src/builtin-plugin/utils.ts
 var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
 var BuiltinPlugin = class {

package/dist/shared/{parse-CNsctGYH.mjs → parse-CanHtd_6.mjs}

@@ -1,5 +1,5 @@
-import { n as __toESM, t as require_binding } from "./binding-DamCAbY6.mjs";
-//#region ../../node_modules/.pnpm/oxc-parser@0.137.0/node_modules/oxc-parser/src-js/wrap.js
+import { n as __toESM, t as require_binding } from "./binding-9kL0gFYL.mjs";
+//#region ../../node_modules/.pnpm/oxc-parser@0.139.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;