rolldown 0.14.0 → 0.15.0

package/dist/types/plugin/index.d.ts

@@ -1,22 +1,23 @@
-import type { BindingHookResolveIdExtraArgs, BindingTransformHookExtraArgs, RenderedChunk } from '../binding';
+import type { BindingHookResolveIdExtraArgs, BindingTransformHookExtraArgs } from '../binding';
 import type { NormalizedInputOptions } from '../options/normalized-input-options';
 import type { NullValue, MaybePromise, PartialNull, MakeAsync } from '../types/utils';
 import type { SourceMapInput } from '../types/sourcemap';
 import type { ModuleInfo } from '../types/module-info';
 import type { OutputBundle } from '../types/output-bundle';
-import { PluginContext } from './plugin-context';
+import type { PluginContext } from './plugin-context';
 import type { TransformPluginContext } from './transform-plugin-context';
 import type { NormalizedOutputOptions } from '../options/normalized-output-options';
 import type { LogLevel } from '../log/logging';
 import type { RollupLog } from '../rollup';
-import type { MinimalPluginContext } from '../log/logger';
-import { InputOptions, OutputOptions } from '..';
-import { BuiltinPlugin } from './builtin-plugin';
-import { ParallelPlugin } from './parallel-plugin';
+import type { MinimalPluginContext } from './minimal-plugin-context';
+import type { InputOptions, OutputOptions } from '..';
+import type { BuiltinPlugin } from '../builtin-plugin/constructors';
+import type { ParallelPlugin } from './parallel-plugin';
 import type { DefinedHookNames } from '../constants/plugin';
-import { DEFINED_HOOK_NAMES } from '../constants/plugin';
-import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
-import { HookFilter } from './hook-filter';
+import type { DEFINED_HOOK_NAMES } from '../constants/plugin';
+import type { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
+import type { HookFilter } from './hook-filter';
+import { RolldownRenderedChunk } from '../types/rolldown-output';
 export type ModuleSideEffects = boolean | 'no-treeshake' | null;
 export type ModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
 export type ImportKind = BindingHookResolveIdExtraArgs['kind'];
@@ -69,11 +70,11 @@ export interface FunctionPluginHooks {
     [DEFINED_HOOK_NAMES.moduleParsed]: (this: PluginContext, moduleInfo: ModuleInfo) => void;
     [DEFINED_HOOK_NAMES.buildEnd]: (this: PluginContext, err?: Error) => void;
     [DEFINED_HOOK_NAMES.renderStart]: (this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions) => void;
-    [DEFINED_HOOK_NAMES.renderChunk]: (this: PluginContext, code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) => NullValue | string | {
+    [DEFINED_HOOK_NAMES.renderChunk]: (this: PluginContext, code: string, chunk: RolldownRenderedChunk, outputOptions: NormalizedOutputOptions) => NullValue | string | {
         code: string;
         map?: SourceMapInput;
     };
-    [DEFINED_HOOK_NAMES.augmentChunkHash]: (this: PluginContext, chunk: RenderedChunk) => string | void;
+    [DEFINED_HOOK_NAMES.augmentChunkHash]: (this: PluginContext, chunk: RolldownRenderedChunk) => string | void;
     [DEFINED_HOOK_NAMES.renderError]: (this: PluginContext, error: Error) => void;
     [DEFINED_HOOK_NAMES.generateBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean) => void;
     [DEFINED_HOOK_NAMES.writeBundle]: (this: PluginContext, outputOptions: NormalizedOutputOptions, bundle: OutputBundle) => void;
@@ -85,12 +86,12 @@ export interface FunctionPluginHooks {
 }
 export type ChangeEvent = 'create' | 'update' | 'delete';
 export type PluginOrder = 'pre' | 'post' | null;
-export type ObjectHookMeta<O = {}> = {
+export type ObjectHookMeta = {
     order?: PluginOrder;
-} & O;
+};
 export type ObjectHook<T, O = {}> = T | ({
     handler: T;
-} & ObjectHookMeta<O>);
+} & ObjectHookMeta & O);
 export type SyncPluginHooks = DefinedHookNames['augmentChunkHash' | 'onLog' | 'outputOptions'];
 export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
 export type FirstPluginHooks = DefinedHookNames['load' | 'resolveDynamicImport' | 'resolveId'];
@@ -98,15 +99,15 @@ export type SequentialPluginHooks = DefinedHookNames['augmentChunkHash' | 'gener
 export type AddonHooks = DefinedHookNames['banner' | 'footer' | 'intro' | 'outro'];
 export type OutputPluginHooks = DefinedHookNames['augmentChunkHash' | 'generateBundle' | 'outputOptions' | 'renderChunk' | 'renderError' | 'renderStart' | 'writeBundle'];
 export type ParallelPluginHooks = Exclude<keyof FunctionPluginHooks | AddonHooks, FirstPluginHooks | SequentialPluginHooks>;
-export type hookFilterExtension<K extends keyof FunctionPluginHooks> = K extends 'transform' ? {
+export type HookFilterExtension<K extends keyof FunctionPluginHooks> = K extends 'transform' ? {
     filter?: HookFilter;
 } : K extends 'load' | 'resolveId' ? {
     filter?: Pick<HookFilter, 'id'>;
 } : {};
 export type PluginHooks = {
-    [K in keyof FunctionPluginHooks]: ObjectHook<K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K], hookFilterExtension<K>>;
+    [K in keyof FunctionPluginHooks]: ObjectHook<K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K], HookFilterExtension<K>>;
 };
-export type AddonHookFunction = (this: PluginContext, chunk: RenderedChunk) => string | Promise<string>;
+export type AddonHookFunction = (this: PluginContext, chunk: RolldownRenderedChunk) => string | Promise<string>;
 export type AddonHook = string | AddonHookFunction;
 export interface OutputPlugin extends Partial<{
     [K in OutputPluginHooks]: PluginHooks[K];
@@ -119,5 +120,7 @@ export interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
     api?: A;
 }
 export type RolldownPlugin<A = any> = Plugin<A> | BuiltinPlugin | ParallelPlugin;
-export type RolldownPluginRec<A = any> = RolldownPlugin<A> | RolldownPlugin<A>[];
+export type RolldownPluginOption<A = any> = MaybePromise<NullValue<RolldownPlugin<A>> | false | RolldownPluginOption[]>;
+export type RolldownOutputPlugin = OutputPlugin | BuiltinPlugin;
+export type RolldownOutputPluginOption = MaybePromise<NullValue<RolldownOutputPlugin> | false | RolldownOutputPluginOption[]>;
 export {};

package/dist/types/plugin/minimal-plugin-context.d.ts

@@ -0,0 +1,15 @@
+import type { LoggingFunction, LogHandler, LogLevelOption, RollupError } from '../rollup';
+import type { Plugin } from '../plugin';
+export interface PluginContextMeta {
+    rollupVersion: string;
+    rolldownVersion: string;
+    watchMode: boolean;
+}
+export declare class MinimalPluginContext {
+    info: LoggingFunction;
+    warn: LoggingFunction;
+    debug: LoggingFunction;
+    meta: PluginContextMeta;
+    readonly error: (error: RollupError | string) => never;
+    constructor(onLog: LogHandler, logLevel: LogLevelOption, plugin: Plugin);
+}

package/dist/types/plugin/plugin-context-data.d.ts

@@ -1,14 +1,13 @@
 import { BindingPluginContext } from '../binding';
-import { ModuleInfo, ModuleOptions } from '..';
+import { ModuleOptions } from '..';
 import { PluginContextResolveOptions } from './plugin-context';
 export declare class PluginContextData {
-    modules: Map<string, ModuleInfo>;
-    moduleIds: Array<string> | null;
     moduleOptionMap: Map<string, ModuleOptions>;
     resolveOptionsMap: Map<number, PluginContextResolveOptions>;
+    loadModulePromiseMap: Map<string, Promise<void>>;
     updateModuleOption(id: string, option: ModuleOptions): void;
-    getModuleOption(id: string): ModuleOptions | undefined;
-    getModuleInfo(id: string, context: BindingPluginContext): ModuleInfo | null;
+    getModuleOption(id: string): ModuleOptions;
+    getModuleInfo(id: string, context: BindingPluginContext): import("..").ModuleInfo | null;
     getModuleIds(context: BindingPluginContext): ArrayIterator<string>;
     saveResolveOptions(options: PluginContextResolveOptions): number;
     getSavedResolveOptions(receipt: number): PluginContextResolveOptions | undefined;

package/dist/types/plugin/plugin-context.d.ts

@@ -1,11 +1,12 @@
 import type { BindingPluginContext } from '../binding';
-import type { NormalizedInputOptions } from '../options/normalized-input-options';
-import type { CustomPluginOptions, Plugin, ResolvedId } from './index';
-import { MinimalPluginContext } from '../log/logger';
+import type { CustomPluginOptions, ModuleOptions, Plugin, ResolvedId } from './index';
+import { MinimalPluginContext } from '../plugin/minimal-plugin-context';
 import { AssetSource } from '../utils/asset-source';
 import { ModuleInfo } from '../types/module-info';
 import { PluginContextData } from './plugin-context-data';
 import { SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF } from '../constants/plugin-context';
+import { PartialNull } from '../types/utils';
+import type { LogHandler, LogLevelOption } from '../rollup';
 export interface EmittedAsset {
     type: 'asset';
     name?: string;
@@ -22,6 +23,10 @@ export interface PrivatePluginContextResolveOptions extends PluginContextResolve
     [SYMBOL_FOR_RESOLVE_CALLER_THAT_SKIP_SELF]?: symbol;
 }
 export declare class PluginContext extends MinimalPluginContext {
+    readonly load: (options: {
+        id: string;
+        resolveDependencies?: boolean;
+    } & Partial<PartialNull<ModuleOptions>>) => Promise<ModuleInfo>;
     readonly resolve: (source: string, importer?: string, options?: PluginContextResolveOptions) => Promise<ResolvedId | null>;
     readonly emitFile: (file: EmittedAsset) => string;
     readonly getFileName: (referenceId: string) => string;
@@ -32,5 +37,5 @@ export declare class PluginContext extends MinimalPluginContext {
      * @deprecated This rollup API won't be supported by rolldown. Using this API will cause runtime error.
      */
     readonly parse: (input: string, options?: any) => any;
-    constructor(options: NormalizedInputOptions, context: BindingPluginContext, plugin: Plugin, data: PluginContextData);
+    constructor(context: BindingPluginContext, plugin: Plugin, data: PluginContextData, onLog: LogHandler, logLevel: LogLevelOption, currentLoadingModule?: string);
 }

package/dist/types/plugin/plugin-driver.d.ts

@@ -1,9 +1,8 @@
-import { Plugin, RolldownPluginRec } from './';
-import { NormalizedInputOptions } from '../options/normalized-input-options';
-import { InputOptions, OutputOptions } from '..';
+import { Plugin } from './';
+import { InputOptions, OutputOptions, RolldownPlugin } from '..';
 export declare class PluginDriver {
     callOptionsHook(inputOptions: InputOptions): Promise<InputOptions>;
-    callOutputOptionsHook(inputOptions: NormalizedInputOptions, outputOptions: OutputOptions): OutputOptions;
+    callOutputOptionsHook(rawPlugins: RolldownPlugin[], outputOptions: OutputOptions): OutputOptions;
 }
-export declare function getObjectPlugins(plugins: RolldownPluginRec[]): Plugin[];
+export declare function getObjectPlugins(plugins: RolldownPlugin[]): Plugin[];
 export declare function getSortedPlugins(hookName: 'options' | 'outputOptions' | 'onLog', plugins: readonly Plugin[]): Plugin[];

package/dist/types/plugin/transform-plugin-context.d.ts

@@ -1,13 +1,14 @@
 import type { BindingPluginContext, BindingTransformPluginContext } from '../binding';
-import type { RollupError } from '../rollup';
+import type { LogHandler, LogLevelOption, RollupError } from '../rollup';
 import { PluginContext } from './plugin-context';
 import { PluginContextData } from './plugin-context-data';
-import { NormalizedInputOptions } from '..';
 import type { Plugin } from './index';
+import { SourceMap } from '../types/rolldown-output';
 export declare class TransformPluginContext extends PluginContext {
     error: (error: RollupError | string, pos?: number | {
         column: number;
         line: number;
     }) => never;
-    constructor(options: NormalizedInputOptions, context: BindingPluginContext, plugin: Plugin, data: PluginContextData, inner: BindingTransformPluginContext, moduleId: string, moduleSource: string);
+    getCombinedSourcemap: () => SourceMap;
+    constructor(context: BindingPluginContext, plugin: Plugin, data: PluginContextData, inner: BindingTransformPluginContext, moduleId: string, moduleSource: string, onLog: LogHandler, LogLevelOption: LogLevelOption);
 }

package/dist/types/rollup-types.d.ts

@@ -1 +1 @@
-export type { OutputOptions, InputOptions, Plugin, OutputPlugin, OutputChunk, NormalizedInputOptions, OutputAsset, OutputBundle, SourceMapInput, } from './rollup';
+export type { OutputOptions, InputOptions, Plugin, OutputPlugin, OutputChunk, NormalizedInputOptions, OutputAsset, OutputBundle, SourceMapInput, RenderedChunk, } from './rollup';

package/dist/types/treeshake/index.d.ts

@@ -1,13 +1 @@
-export declare const TreeshakingOptionsSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
-    moduleSideEffects: import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodString]>;
-}, {
-    moduleSideEffects: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodString]>>;
-}>, "strict", import("zod").ZodTypeAny, {
-    moduleSideEffects?: string | boolean | undefined;
-}, {
-    moduleSideEffects?: string | boolean | undefined;
-}>;
-export interface TreeshakingOptions {
-    moduleSideEffects?: boolean | RegExp;
-}
 export * from './module-side-effects';

package/dist/types/treeshake/module-side-effects.d.ts

@@ -1,15 +1,115 @@
 import { z } from 'zod';
-export declare const HasModuleSideEffectsSchema: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodBoolean], z.ZodUnknown>, z.ZodBoolean>;
-export type HasModuleSideEffects = z.infer<typeof HasModuleSideEffectsSchema>;
 export type ModuleSideEffectsOption = z.infer<typeof ModuleSideEffectsOptionSchema>;
-export declare const ModuleSideEffectsOptionSchema: z.ZodUnion<[z.ZodBoolean, z.ZodString]>;
-export declare const NormalizedTreeshakingOptionsSchema: z.ZodObject<{
-    moduleSideEffects: z.ZodUnion<[z.ZodBoolean, z.ZodString]>;
-}, "strict", z.ZodTypeAny, {
-    moduleSideEffects: string | boolean;
+export declare const ModuleSideEffectsRuleSchema: z.ZodEffects<z.ZodObject<{
+    test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+    external: z.ZodOptional<z.ZodBoolean>;
+    sideEffects: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
 }, {
-    moduleSideEffects: string | boolean;
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
+}>, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
+}, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
 }>;
-export type NormalizedTreeshakingOptions = {
-    moduleSideEffects: string;
-};
+export declare const ModuleSideEffectsOptionSchema: z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEffects<z.ZodObject<{
+    test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+    external: z.ZodOptional<z.ZodBoolean>;
+    sideEffects: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
+}, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
+}>, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
+}, {
+    sideEffects: boolean;
+    external?: boolean | undefined;
+    test?: RegExp | undefined;
+}>, "many">]>, z.ZodLiteral<"no-external">]>;
+export declare const TreeshakingOptionsSchema: z.ZodUnion<[z.ZodObject<{
+    moduleSideEffects: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEffects<z.ZodObject<{
+        test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+        external: z.ZodOptional<z.ZodBoolean>;
+        sideEffects: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }>, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }>, "many">]>, z.ZodLiteral<"no-external">]>>;
+    annotations: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    moduleSideEffects: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEffects<z.ZodObject<{
+        test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+        external: z.ZodOptional<z.ZodBoolean>;
+        sideEffects: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }>, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }>, "many">]>, z.ZodLiteral<"no-external">]>>;
+    annotations: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    moduleSideEffects: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodBoolean, z.ZodArray<z.ZodEffects<z.ZodObject<{
+        test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+        external: z.ZodOptional<z.ZodBoolean>;
+        sideEffects: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }>, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }, {
+        sideEffects: boolean;
+        external?: boolean | undefined;
+        test?: RegExp | undefined;
+    }>, "many">]>, z.ZodLiteral<"no-external">]>>;
+    annotations: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodBoolean]>;
+export type TreeshakingOptions = z.infer<typeof TreeshakingOptionsSchema>;

package/dist/types/types/rolldown-output.d.ts

@@ -1,5 +1,5 @@
 import { AssetSource } from '../utils/asset-source';
-import type { RenderedModule } from './rendered-module';
+import type { RenderedChunk } from '../binding';
 export interface RolldownOutputAsset {
     type: 'asset';
     fileName: string;
@@ -15,6 +15,15 @@ export interface SourceMap {
     sourcesContent: string[];
     version: number;
 }
+export interface RolldownRenderedModule {
+    readonly code: string | null;
+    renderedLength: number;
+}
+export interface RolldownRenderedChunk extends Omit<RenderedChunk, 'modules'> {
+    modules: {
+        [id: string]: RolldownRenderedModule;
+    };
+}
 export interface RolldownOutputChunk {
     type: 'chunk';
     code: string;
@@ -23,7 +32,7 @@ export interface RolldownOutputChunk {
     exports: string[];
     fileName: string;
     modules: {
-        [id: string]: RenderedModule;
+        [id: string]: RolldownRenderedModule;
     };
     imports: string[];
     dynamicImports: string[];

package/dist/types/types/utils.d.ts

@@ -10,3 +10,4 @@ export type PartialNull<T> = {
 };
 export type MakeAsync<Function_> = Function_ extends (this: infer This, ...parameters: infer Arguments) => infer Return ? (this: This, ...parameters: Arguments) => Return | Promise<Return> : never;
 export type MaybeArray<T> = T | T[];
+export type StringOrRegExp = string | RegExp;

package/dist/types/utils/bindingify-input-options.d.ts

@@ -0,0 +1,7 @@
+import type { RolldownPlugin } from 'rolldown';
+import type { InputOptions } from '../options/input-options';
+import type { OutputOptions } from '../options/output-options';
+import type { BindingInputOptions } from '../binding';
+import { LogHandler } from '../rollup';
+import { LogLevelOption } from '../log/logging';
+export declare function bindingifyInputOptions(rawPlugins: RolldownPlugin[], inputOptions: InputOptions, outputOptions: OutputOptions, onLog: LogHandler, logLevel: LogLevelOption): BindingInputOptions;

package/dist/types/utils/bindingify-output-options.d.ts

@@ -0,0 +1,3 @@
+import type { BindingOutputOptions } from '../binding';
+import type { OutputOptions } from '../options/output-options';
+export declare function bindingifyOutputOptions(outputOptions: OutputOptions): BindingOutputOptions;

package/dist/types/utils/define-config.d.ts

@@ -1,2 +1,5 @@
+import type { RolldownOptions } from '../types/rolldown-options';
 import type { ConfigExport } from '../types/config-export';
+export declare function defineConfig(config: RolldownOptions): RolldownOptions;
+export declare function defineConfig(config: RolldownOptions[]): RolldownOptions[];
 export declare function defineConfig(config: ConfigExport): ConfigExport;

package/dist/types/utils/error.d.ts

@@ -0,0 +1 @@
+export declare function normalizeErrors(rawErrors: unknown[]): Error;

package/dist/types/utils/normalize-hook.d.ts

@@ -1,6 +1,6 @@
 import { AnyFn } from '../types/utils';
 import type { ObjectHook, ObjectHookMeta } from '../plugin';
-export declare function normalizeHook<Hook extends ObjectHook<AnyFn | string>>(hook: Hook): Hook extends ObjectHook<infer RawHook, infer CustomOptions> ? {
+export declare function normalizeHook<Hook extends ObjectHook<AnyFn | string>>(hook: Hook): Hook extends ObjectHook<infer RawHook, infer CustomOptions> ? Hook extends RawHook ? never : {
     handler: RawHook;
     options: CustomOptions;
     meta: ObjectHookMeta;

package/dist/types/utils/normalize-plugin-option.d.ts

@@ -1,8 +1,13 @@
-import type { OutputOptions, OutputPlugin } from '../rollup-types';
+import type { RolldownPlugin, RolldownOutputPlugin } from '../plugin';
 import type { InputOptions } from '../options/input-options';
-import type { RolldownPlugin } from '../plugin';
+import type { OutputOptions } from '../options/output-options';
+import { LogHandler } from '../rollup';
 export declare const normalizePluginOption: {
     (plugins: InputOptions['plugins']): Promise<RolldownPlugin[]>;
-    (plugins: OutputOptions['plugins']): Promise<OutputPlugin[]>;
+    (plugins: OutputOptions['plugins']): Promise<RolldownOutputPlugin[]>;
     (plugins: unknown): Promise<any[]>;
 };
+export declare function checkOutputPluginOption(plugins: RolldownOutputPlugin[], onLog: LogHandler): RolldownOutputPlugin[];
+export declare function normalizePlugins<T extends RolldownPlugin>(plugins: T[], anonymousPrefix: string): T[];
+export declare const ANONYMOUS_PLUGIN_PREFIX = "at position ";
+export declare const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = "at output position ";

package/dist/types/{options/utils.d.ts → utils/normalize-string-or-regex.d.ts}

@@ -1,2 +1,2 @@
-import { BindingStringOrRegex } from '../binding.d';
+import type { BindingStringOrRegex } from '../binding';
 export declare function normalizedStringOrRegex(pattern?: Array<string | RegExp> | (string | RegExp)): BindingStringOrRegex[] | undefined;

package/dist/types/utils/transform-rendered-chunk.d.ts

@@ -0,0 +1,4 @@
+import { RenderedChunk } from '../binding';
+import { RolldownRenderedChunk } from '../types/rolldown-output';
+export declare function transformRenderedChunk(chunk: RenderedChunk): RolldownRenderedChunk;
+export declare function transformChunkModules(modules: RenderedChunk['modules']): RolldownRenderedChunk['modules'];

package/dist/types/utils/transform-rendered-module.d.ts

@@ -0,0 +1,3 @@
+import { BindingRenderedModule } from '../binding';
+import { RolldownRenderedModule } from '../types/rolldown-output';
+export declare function transformToRenderedModule(bindingRenderedModule: BindingRenderedModule): RolldownRenderedModule;

package/dist/types/utils/transform-sourcemap.d.ts

@@ -1 +1,3 @@
+import { ExistingRawSourceMap, SourceMapInput } from '../types/sourcemap';
 export declare function isEmptySourcemapFiled(array: undefined | (string | null)[]): boolean;
+export declare function normalizeTransformHookSourcemap(id: string, originalCode: string, rawMap?: SourceMapInput): ExistingRawSourceMap | undefined;

package/dist/types/utils/transform-to-rollup-output.d.ts

@@ -2,6 +2,7 @@ import type { RolldownOutput } from '../types/rolldown-output';
 import type { OutputBundle } from '../types/output-bundle';
 import type { BindingOutputs, JsChangedOutputs } from '../binding';
 export declare function transformToRollupOutput(output: BindingOutputs, changed?: ChangedOutputs): RolldownOutput;
+export declare function handleOutputErrors(output: BindingOutputs): void;
 export declare function transformToOutputBundle(output: BindingOutputs, changed: ChangedOutputs): OutputBundle;
 export interface ChangedOutputs {
     updated: Set<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rolldown",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
   "homepage": "https://rolldown.rs/",
   "repository": {
@@ -44,7 +44,6 @@
       "require": "./dist/cjs/parallel-plugin.cjs",
       "import": "./dist/esm/parallel-plugin.mjs"
     },
-    "./watcher-worker": "./dist/shared/watcher-worker.js",
     "./package.json": "./package.json"
   },
   "imports": {
@@ -82,13 +81,22 @@
   "dependencies": {
     "zod": "^3.23.8"
   },
+  "peerDependencies": {
+    "@babel/runtime": ">=7"
+  },
+  "peerDependenciesMeta": {
+    "@babel/runtime": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@jridgewell/sourcemap-codec": "^1.5.0",
     "@napi-rs/cli": "^3.0.0-alpha.60",
     "@napi-rs/wasm-runtime": "^0.2.4",
+    "@types/fs-extra": "^11.0.4",
     "@types/lodash-es": "^4.17.12",
     "colorette": "^2.0.20",
     "consola": "^3.2.3",
-    "cross-env": "^7.0.3",
     "emnapi": "^1.2.0",
     "execa": "^9.2.0",
     "fs-extra": "^11.2.0",
@@ -98,28 +106,28 @@
     "remeda": "^2.10.0",
     "rollup": "^4.18.0",
     "signal-exit": "4.1.0",
+    "source-map": "^0.7.4",
+    "tsx": "^4.19.2",
     "type-fest": "^4.20.0",
     "unbuild": "^2.0.0",
-    "vite": "^5.2.13",
-    "vitest": "^2.0.0",
     "why-is-node-running": "^3.0.0",
     "zod-to-json-schema": "^3.23.2",
     "@rolldown/testing": "0.0.1",
-    "rolldown": "0.14.0"
+    "rolldown": "0.15.0"
   },
   "optionalDependencies": {
-    "@rolldown/binding-darwin-arm64": "0.14.0",
-    "@rolldown/binding-darwin-x64": "0.14.0",
-    "@rolldown/binding-linux-arm-gnueabihf": "0.14.0",
-    "@rolldown/binding-linux-arm64-musl": "0.14.0",
-    "@rolldown/binding-freebsd-x64": "0.14.0",
-    "@rolldown/binding-linux-arm64-gnu": "0.14.0",
-    "@rolldown/binding-linux-x64-musl": "0.14.0",
-    "@rolldown/binding-linux-x64-gnu": "0.14.0",
-    "@rolldown/binding-win32-arm64-msvc": "0.14.0",
-    "@rolldown/binding-win32-ia32-msvc": "0.14.0",
-    "@rolldown/binding-win32-x64-msvc": "0.14.0",
-    "@rolldown/binding-wasm32-wasi": "0.14.0"
+    "@rolldown/binding-darwin-arm64": "0.15.0",
+    "@rolldown/binding-freebsd-x64": "0.15.0",
+    "@rolldown/binding-linux-arm-gnueabihf": "0.15.0",
+    "@rolldown/binding-darwin-x64": "0.15.0",
+    "@rolldown/binding-linux-arm64-gnu": "0.15.0",
+    "@rolldown/binding-linux-arm64-musl": "0.15.0",
+    "@rolldown/binding-linux-x64-gnu": "0.15.0",
+    "@rolldown/binding-linux-x64-musl": "0.15.0",
+    "@rolldown/binding-wasm32-wasi": "0.15.0",
+    "@rolldown/binding-win32-arm64-msvc": "0.15.0",
+    "@rolldown/binding-win32-ia32-msvc": "0.15.0",
+    "@rolldown/binding-win32-x64-msvc": "0.15.0"
   },
   "scripts": {
     "# Scrips for binding #": "_",
@@ -130,15 +138,15 @@
     "build-binding:wasi:release": "pnpm build-binding --profile release-wasi --target wasm32-wasip1-threads",
     "# Scrips for node #": "_",
     "bak_build-node": "unbuild",
-    "build-node": "node ../../node_modules/npm-rolldown/bin/cli.js -c ./rolldown.config.mjs",
+    "build-node": "tsx ./build.ts",
     "build-types": "tsc -p ./tsconfig.dts.json",
     "build-types-check": "tsc -p ./tsconfig.check.json",
     "build-native:debug": "run-s build-binding build-types build-node build-types-check",
     "build-native:release": "run-s build-binding:release build-types build-node build-types-check",
-    "build-wasi:debug": "run-s build-binding:wasi build-node",
-    "build-wasi:release": "run-s build-binding:wasi:release build-node",
+    "build-wasi:debug": "run-s build-binding build-binding:wasi build-node",
+    "build-wasi:release": "run-s build-binding build-binding:wasi:release build-node",
     "# Scrips for checking #": "_",
-    "test": "cross-env RUST_BACKTRACE=1 ROLLDOWN_TEST=1 vitest run --reporter verbose --hideSkippedTests",
+    "test": "pnpm run --filter rolldown-tests go",
     "test:update": "vitest run -u",
     "type-check": "tsc"
   }