@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.20

package/src/utils/parse-cli-args.js

@@ -7,6 +7,8 @@ function getEmbeddedRuntimeCommandOptions() {
     build: false,
     start: !isDevelopment,
     dev: isDevelopment,
+    force: false,
+    serveOnly: false,
     port: void 0,
     hostname: void 0,
     reactFastRefresh: void 0
@@ -25,6 +27,8 @@ function parseCliArgs(options = {}) {
       dev: { type: "boolean" },
       preview: { type: "boolean" },
       build: { type: "boolean" },
+      force: { type: "boolean" },
+      "serve-only": { type: "boolean" },
       port: { type: "string" },
       hostname: { type: "string" },
       "react-fast-refresh": { type: "boolean" }
@@ -48,6 +52,8 @@ function parseCliArgs(options = {}) {
     build: isBuildCommand,
     start: isStartCommand,
     dev: isDevCommand,
+    force: !!values.force,
+    serveOnly: !!values["serve-only"] || process.env.ECOPAGES_PREVIEW_SERVE_ONLY === "true",
     port: values.port ? Number(values.port) : void 0,
     hostname: values.hostname,
     reactFastRefresh: values["react-fast-refresh"]

package/src/utils/server-utils.module.d.ts

@@ -1,3 +1,4 @@
+import { hasKnownStaticExtension } from './static-file-extensions.js';
 /**
  * Get the content type of a file based on its extension.
  * @param file - The file name.
@@ -9,11 +10,11 @@ export declare const getContentType: (file: string) => string;
  * @param file - The file name or path.
  * @returns true if the extension is recognized.
  */
-export declare const hasKnownExtension: (file: string) => boolean;
+export { hasKnownStaticExtension } from './static-file-extensions.js';
 /**
  * A module for server utilities.
  */
 export declare const ServerUtils: {
     getContentType: (file: string) => string;
-    hasKnownExtension: (file: string) => boolean;
+    hasKnownStaticExtension: typeof hasKnownStaticExtension;
 };

package/src/utils/server-utils.module.js

@@ -1,3 +1,4 @@
+import { hasKnownStaticExtension } from "./static-file-extensions.js";
 const ContentTypeMap = /* @__PURE__ */ new Map([
   ["jpg", "image/jpeg"],
   ["jpeg", "image/jpeg"],
@@ -17,6 +18,7 @@ const ContentTypeMap = /* @__PURE__ */ new Map([
   ["ogv", "video/ogg"],
   ["mov", "video/quicktime"],
   ["txt", "text/plain"],
+  ["md", "text/markdown"],
   ["html", "text/html"],
   ["css", "text/css"],
   ["js", "text/javascript"],
@@ -41,16 +43,13 @@ const getContentType = (file) => {
   const extension = file.split(".").pop() || "txt";
   return ContentTypeMap.get(extension) || "text/plain";
 };
-const hasKnownExtension = (file) => {
-  const extension = file.split(".").pop();
-  return extension !== void 0 && ContentTypeMap.has(extension);
-};
+import { hasKnownStaticExtension as hasKnownStaticExtension2 } from "./static-file-extensions.js";
 const ServerUtils = {
   getContentType,
-  hasKnownExtension
+  hasKnownStaticExtension
 };
 export {
   ServerUtils,
   getContentType,
-  hasKnownExtension
+  hasKnownStaticExtension2 as hasKnownStaticExtension
 };

package/src/utils/static-file-extensions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Known static asset extensions served directly from disk.
+ *
+ * @remarks
+ * Keep this list aligned with server static-file handling and client routers
+ * that must bypass SPA navigation for same-origin asset links.
+ */
+export declare const STATIC_FILE_EXTENSIONS: Set<string>;
+/**
+ * Returns whether a path or filename ends with a known static asset extension.
+ */
+export declare function hasKnownStaticExtension(fileOrPath: string): boolean;

package/src/utils/static-file-extensions.js

@@ -0,0 +1,48 @@
+const STATIC_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "jpg",
+  "jpeg",
+  "png",
+  "gif",
+  "bmp",
+  "svg",
+  "tiff",
+  "webp",
+  "avif",
+  "ico",
+  "mp3",
+  "ogg",
+  "wav",
+  "mp4",
+  "webm",
+  "ogv",
+  "mov",
+  "txt",
+  "md",
+  "html",
+  "css",
+  "js",
+  "mjs",
+  "json",
+  "map",
+  "xml",
+  "webmanifest",
+  "wasm",
+  "csv",
+  "ttf",
+  "woff",
+  "woff2",
+  "otf",
+  "eot",
+  "gz",
+  "zip",
+  "pdf",
+  "doc"
+]);
+function hasKnownStaticExtension(fileOrPath) {
+  const extension = fileOrPath.split(".").pop();
+  return extension !== void 0 && STATIC_FILE_EXTENSIONS.has(extension);
+}
+export {
+  STATIC_FILE_EXTENSIONS,
+  hasKnownStaticExtension
+};

package/src/watchers/project-watcher-ignore.d.ts

@@ -0,0 +1,11 @@
+export type ProjectWatcherIgnorePaths = {
+    workDir: string;
+    distDir: string;
+};
+/**
+ * @remarks
+ * chokidar v4+ no longer treats glob strings in `ignored` as patterns. A path
+ * predicate keeps node_modules, VCS metadata, and scoped artifact dirs out of
+ * the watch tree without descending into symlinked monorepo node_modules.
+ */
+export declare function createProjectWatcherIgnorePredicate(absolutePaths: ProjectWatcherIgnorePaths): (watchedPath: string) => boolean;

package/src/watchers/project-watcher-ignore.js

@@ -0,0 +1,16 @@
+import path from "node:path";
+function createProjectWatcherIgnorePredicate(absolutePaths) {
+  const ignoredPrefixes = [absolutePaths.workDir, absolutePaths.distDir];
+  return (watchedPath) => {
+    const segments = watchedPath.split(path.sep);
+    if (segments.includes("node_modules") || segments.includes(".git")) {
+      return true;
+    }
+    return ignoredPrefixes.some(
+      (prefix) => watchedPath === prefix || watchedPath.startsWith(`${prefix}${path.sep}`)
+    );
+  };
+}
+export {
+  createProjectWatcherIgnorePredicate
+};

package/src/watchers/project-watcher.d.ts

@@ -13,6 +13,10 @@ export interface ProjectWatcherConfig {
     refreshRouterRoutesCallback: () => Promise<void>;
     hmrManager: IHmrManager;
     bridge: IClientBridge;
+    /** When true, the host dev server owns browser dev-client bootstrap. */
+    hostOwnsDevClient?: boolean;
+    /** Delay before a change event is processed; 0 disables debouncing. */
+    changeDebounceMs?: number;
 }
 /**
  * ProjectWatcher handles file system changes for hot module replacement (HMR).
@@ -42,11 +46,14 @@ export declare class ProjectWatcher {
     private refreshRouterRoutesCallback;
     private hmrManager;
     private bridge;
+    private readonly hostOwnsDevClient;
     private readonly invalidationService;
+    private readonly changeDebounceMs;
     private watcher;
     private lastHandledChange;
+    private pendingChangeTimers;
     private changeQueue;
-    constructor({ config, refreshRouterRoutesCallback, hmrManager, bridge }: ProjectWatcherConfig);
+    constructor({ config, refreshRouterRoutesCallback, hmrManager, bridge, hostOwnsDevClient, changeDebounceMs, }: ProjectWatcherConfig);
     /**
      * Uncaches modules in the source directory to ensure fresh imports.
      * This is necessary for hot module replacement to work correctly.
@@ -55,6 +62,7 @@ export declare class ProjectWatcher {
     private uncacheModules;
     private isRouteSourceFile;
     private isIncludeSourceFile;
+    private requestBrowserReload;
     /**
      * Handles public directory file changes by copying only the changed file.
      * @param filePath - Absolute path of the changed file
@@ -70,7 +78,7 @@ export declare class ProjectWatcher {
      * Follows 5-rule priority:
      * 0. Public directory match? -> copy file and reload
      * 1. additionalWatchPaths match? -> reload
-     * 2. Include template source? -> reload after processor notifications
+     * 2. Include template source? -> current-page refresh via HMR after processor notifications are deferred
      * 3. Processor-owned asset? -> processor already handled it via notification, skip HMR
      * 4. Otherwise -> HMR strategies
      *
@@ -84,6 +92,13 @@ export declare class ProjectWatcher {
      * @param event - The type of file system event
      */
     private handleFileChange;
+    private processFileChange;
+    /**
+     * Re-imports server modules before HMR broadcast so reload/refetch does not
+     * race stale in-memory imports or custom-element registry state.
+     */
+    private prewarmBeforeHmr;
+    private prewarmServerModuleImports;
     /**
      * Notifies all processors whose watch config matches the given file extension.
      * This is called before checking processor ownership so that dependency-only
@@ -133,4 +148,12 @@ export declare class ProjectWatcher {
      * rapid file changes efficiently.
      */
     createWatcherSubscription(): Promise<FSWatcher>;
+    /**
+     * Closes the active filesystem watcher subscription.
+     *
+     * @remarks
+     * Safe to call multiple times. Used when tearing down dev servers in tests
+     * and other short-lived Ecopages runtimes.
+     */
+    close(): Promise<void>;
 }

package/src/watchers/project-watcher.js

@@ -2,7 +2,12 @@ import path from "node:path";
 import chokidar, {} from "chokidar";
 import { fileSystem } from "@ecopages/file-system";
 import { appLogger } from "../global/app-logger.js";
-import { DevelopmentInvalidationService } from "../services/invalidation/development-invalidation.service.js";
+import {
+  DevelopmentInvalidationService
+} from "../services/invalidation/development-invalidation.service.js";
+import { isRegisteredScriptEntrypoint } from "../hmr/hmr-entrypoint-output.js";
+import { resolveInternalExecutionDir } from "../utils/resolve-work-dir.js";
+import { createProjectWatcherIgnorePredicate } from "./project-watcher-ignore.js";
 class ProjectWatcher {
   /**
    * Duplicate identical watcher events within this window are ignored.
@@ -16,19 +21,33 @@ class ProjectWatcher {
   refreshRouterRoutesCallback;
   hmrManager;
   bridge;
+  hostOwnsDevClient;
   invalidationService;
+  changeDebounceMs;
   watcher = null;
   lastHandledChange = /* @__PURE__ */ new Map();
+  pendingChangeTimers = /* @__PURE__ */ new Map();
   changeQueue = Promise.resolve();
-  constructor({ config, refreshRouterRoutesCallback, hmrManager, bridge }) {
+  constructor({
+    config,
+    refreshRouterRoutesCallback,
+    hmrManager,
+    bridge,
+    hostOwnsDevClient,
+    changeDebounceMs
+  }) {
     this.appConfig = config;
     this.refreshRouterRoutesCallback = refreshRouterRoutesCallback;
     this.hmrManager = hmrManager;
     this.bridge = bridge;
+    this.hostOwnsDevClient = hostOwnsDevClient === true;
+    const envDebounceMs = process.env.ECOPAGES_WATCH_CHANGE_DEBOUNCE_MS;
+    this.changeDebounceMs = changeDebounceMs ?? (envDebounceMs !== void 0 && envDebounceMs !== "" ? Number(envDebounceMs) : void 0) ?? ProjectWatcher.duplicateChangeWindowMs;
     this.invalidationService = new DevelopmentInvalidationService(config);
     this.triggerRouterRefresh = this.triggerRouterRefresh.bind(this);
     this.handleError = this.handleError.bind(this);
     this.handleFileChange = this.handleFileChange.bind(this);
+    this.processFileChange = this.processFileChange.bind(this);
   }
   /**
    * Uncaches modules in the source directory to ensure fresh imports.
@@ -51,6 +70,12 @@ class ProjectWatcher {
   isIncludeSourceFile(filePath) {
     return this.invalidationService.isIncludeSourceFile(filePath);
   }
+  requestBrowserReload() {
+    if (this.hostOwnsDevClient) {
+      return;
+    }
+    this.bridge.reload();
+  }
   /**
    * Handles public directory file changes by copying only the changed file.
    * @param filePath - Absolute path of the changed file
@@ -64,10 +89,10 @@ class ProjectWatcher {
         fileSystem.ensureDir(destDir);
         await fileSystem.copyFileAsync(filePath, destPath);
       }
-      this.bridge.reload();
+      this.requestBrowserReload();
     } catch (error) {
       appLogger.error(`Failed to copy public file: ${error instanceof Error ? error.message : String(error)}`);
-      this.bridge.reload();
+      this.requestBrowserReload();
     }
   }
   /**
@@ -77,13 +102,14 @@ class ProjectWatcher {
   enqueueChange(task) {
     const queuedTask = this.changeQueue.then(task, task);
     this.changeQueue = queuedTask.catch(() => void 0);
+    return queuedTask;
   }
   /**
    * Handles file changes by uncaching modules, refreshing routes, and delegating appropriately.
    * Follows 5-rule priority:
    * 0. Public directory match? -> copy file and reload
    * 1. additionalWatchPaths match? -> reload
-   * 2. Include template source? -> reload after processor notifications
+   * 2. Include template source? -> current-page refresh via HMR after processor notifications are deferred
    * 3. Processor-owned asset? -> processor already handled it via notification, skip HMR
    * 4. Otherwise -> HMR strategies
    *
@@ -96,8 +122,23 @@ class ProjectWatcher {
    * @param rawPath - Path of the changed file
    * @param event - The type of file system event
    */
-  async handleFileChange(rawPath, event = "change") {
+  handleFileChange(rawPath, event = "change") {
     const filePath = path.resolve(rawPath);
+    if (this.changeDebounceMs === 0) {
+      return this.enqueueChange(() => this.processFileChange(filePath, event));
+    }
+    const existing = this.pendingChangeTimers.get(filePath);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+      this.pendingChangeTimers.delete(filePath);
+      this.enqueueChange(() => this.processFileChange(filePath, event));
+    }, this.changeDebounceMs);
+    this.pendingChangeTimers.set(filePath, timer);
+    return Promise.resolve();
+  }
+  async processFileChange(filePath, event) {
     const now = Date.now();
     const lastHandledAt = this.lastHandledChange.get(filePath);
     if (lastHandledAt !== void 0 && now - lastHandledAt < ProjectWatcher.duplicateChangeWindowMs) {
@@ -111,21 +152,32 @@ class ProjectWatcher {
         return;
       }
       this.uncacheModules();
+      const resolvedFilePath = path.resolve(filePath);
+      const isRegisteredScriptEdit = isRegisteredScriptEntrypoint(
+        this.hmrManager.getWatchedFiles(),
+        resolvedFilePath
+      );
       if (plan.invalidateServerModules) {
         this.invalidationService.invalidateServerModules([filePath]);
+        if (isRegisteredScriptEdit) {
+          await this.invalidationService.notifyRegisteredScriptEntrypointChange(resolvedFilePath);
+        }
       }
       if (plan.refreshRoutes) {
         await this.refreshRouterRoutesCallback();
       }
-      if (plan.category === "additional-watch") {
-        this.bridge.reload();
+      if (plan.reloadBrowser) {
+        this.requestBrowserReload();
         return;
       }
-      await this.notifyProcessors(filePath, event);
-      if (plan.category === "include-source") {
-        this.bridge.reload();
+      const deferProcessorNotifications = plan.category === "include-source" || plan.category === "explicit-server-view" || isRegisteredScriptEdit;
+      if (deferProcessorNotifications && plan.delegateToHmr) {
+        await this.prewarmBeforeHmr(resolvedFilePath, plan, isRegisteredScriptEdit);
+        await this.hmrManager.handleFileChange(filePath);
+        void this.notifyProcessors(filePath, event);
         return;
       }
+      await this.notifyProcessors(filePath, event);
       if (plan.processorHandledAsset) {
         return;
       }
@@ -139,6 +191,46 @@ class ProjectWatcher {
       }
     }
   }
+  /**
+   * Re-imports server modules before HMR broadcast so reload/refetch does not
+   * race stale in-memory imports or custom-element registry state.
+   */
+  async prewarmBeforeHmr(filePath, plan, isRegisteredScriptEdit) {
+    if (isRegisteredScriptEdit) {
+      await this.prewarmServerModuleImports([filePath], { bypassCache: true, scope: "registered script" });
+      return;
+    }
+    if (plan.category !== "include-source" && plan.category !== "explicit-server-view") {
+      return;
+    }
+    const modulePaths = plan.category === "include-source" ? [this.appConfig.absolutePaths.htmlTemplatePath] : [path.resolve(filePath)];
+    await this.prewarmServerModuleImports(modulePaths, { scope: "server template" });
+  }
+  async prewarmServerModuleImports(modulePaths, options) {
+    const appModuleLoader = this.appConfig.runtime?.appModuleLoader;
+    if (!appModuleLoader) {
+      return;
+    }
+    const outdir = path.join(resolveInternalExecutionDir(this.appConfig), ".server-modules");
+    for (const modulePath of modulePaths) {
+      if (!modulePath) {
+        continue;
+      }
+      try {
+        await appModuleLoader.importModule({
+          filePath: modulePath,
+          rootDir: this.appConfig.rootDir,
+          outdir,
+          externalPackages: true,
+          bypassCache: options.bypassCache
+        });
+      } catch (error) {
+        appLogger.error(
+          `Failed to prewarm ${options.scope} ${modulePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   /**
    * Notifies all processors whose watch config matches the given file extension.
    * This is called before checking processor ownership so that dependency-only
@@ -231,36 +323,37 @@ class ProjectWatcher {
     if (this.watcher) {
       return this.watcher;
     }
-    const processorPaths = [];
+    const processorPaths = /* @__PURE__ */ new Set();
     for (const processor of this.appConfig.processors.values()) {
       const watchConfig = processor.getWatchConfig();
       if (!watchConfig) continue;
-      processorPaths.push(...watchConfig.paths);
+      for (const watchPath of watchConfig.paths) {
+        processorPaths.add(watchPath);
+      }
     }
     if (fileSystem.exists(this.appConfig.absolutePaths.includesDir)) {
-      processorPaths.push(this.appConfig.absolutePaths.includesDir);
+      processorPaths.add(this.appConfig.absolutePaths.includesDir);
     }
     if (fileSystem.exists(this.appConfig.absolutePaths.srcDir)) {
-      processorPaths.push(this.appConfig.absolutePaths.srcDir);
-    }
-    if (fileSystem.exists(this.appConfig.absolutePaths.pagesDir)) {
-      processorPaths.push(this.appConfig.absolutePaths.pagesDir);
+      processorPaths.add(this.appConfig.absolutePaths.srcDir);
     }
     if (fileSystem.exists(this.appConfig.absolutePaths.publicDir)) {
-      processorPaths.push(this.appConfig.absolutePaths.publicDir);
+      processorPaths.add(this.appConfig.absolutePaths.publicDir);
     }
-    if (this.appConfig.additionalWatchPaths.length) {
-      processorPaths.push(...this.appConfig.additionalWatchPaths);
+    for (const watchPath of this.appConfig.additionalWatchPaths) {
+      processorPaths.add(watchPath);
     }
-    this.watcher = chokidar.watch(processorPaths, {
+    const ignored = createProjectWatcherIgnorePredicate(this.appConfig.absolutePaths);
+    this.watcher = chokidar.watch(Array.from(processorPaths), {
       ignoreInitial: true,
       ignorePermissionErrors: true,
+      ignored,
       awaitWriteFinish: {
         stabilityThreshold: 50,
         pollInterval: 50
       }
     });
-    this.watcher.on("change", (p) => this.enqueueChange(() => this.handleFileChange(p, "change"))).on("add", (p) => this.enqueueChange(() => this.handleFileChange(p, "add"))).on("addDir", (p) => this.enqueueChange(() => this.triggerRouterRefresh(p))).on("unlink", (p) => this.enqueueChange(() => this.handleFileChange(p, "unlink"))).on("unlinkDir", (p) => this.enqueueChange(() => this.triggerRouterRefresh(p))).on("error", (error) => this.handleError(error));
+    this.watcher.on("change", (p) => this.handleFileChange(p, "change")).on("add", (p) => this.handleFileChange(p, "add")).on("addDir", (p) => this.enqueueChange(() => this.triggerRouterRefresh(p))).on("unlink", (p) => this.handleFileChange(p, "unlink")).on("unlinkDir", (p) => this.enqueueChange(() => this.triggerRouterRefresh(p))).on("error", (error) => this.handleError(error));
     for (const processor of this.appConfig.processors.values()) {
       const watchConfig = processor.getWatchConfig();
       if (watchConfig?.onError) {
@@ -269,6 +362,20 @@ class ProjectWatcher {
     }
     return this.watcher;
   }
+  /**
+   * Closes the active filesystem watcher subscription.
+   *
+   * @remarks
+   * Safe to call multiple times. Used when tearing down dev servers in tests
+   * and other short-lived Ecopages runtimes.
+   */
+  async close() {
+    if (!this.watcher) {
+      return;
+    }
+    await this.watcher.close();
+    this.watcher = null;
+  }
 }
 export {
   ProjectWatcher

package/src/build/rolldown-dev-build-adapter.d.ts

@@ -1,82 +0,0 @@
-/**
- * DevEngine-backed build adapter for cached incremental rebuilds.
- *
- * @remarks
- * Wraps Rolldown's experimental `DevEngine` to provide cached incremental
- * rebuilds. Unlike the standard `RolldownBuildAdapter` which creates a new
- * bundler for every build, this adapter keeps a `DevEngine` instance alive
- * and reuses the internal module graph, resolver cache, and transform cache
- * across builds.
- *
- * The adapter is designed for the HMR rebuild path where the same entrypoints
- * are rebuilt repeatedly with small changes. For one-off production builds,
- * use `RolldownBuildAdapter` instead.
- *
- * The first build creates the engine and runs it. Subsequent builds with the
- * same plugin/target/format triple reuse the cached engine and call
- * `triggerFullBuild()`. The cache key incorporates the context root, plugin
- * names, target, and format; when any of those change, the cached engine is
- * closed and a new one is created.
- *
- * Call `close()` to release the cached engine and free resources.
- *
- * @module
- */
-import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
-/**
- * Build adapter backed by Rolldown's DevEngine for cached incremental rebuilds.
- */
-export declare class RolldownDevBuildAdapter implements BuildAdapter {
-    /**
-     * `'rolldown-dev'` (not `'rolldown'`) so {@link getBuildAdapterOwnership}
-     * round-trips correctly and `createBuildAdapter({ ownership })` can
-     * re-select this class.
-     */
-    readonly ownership: "rolldown-dev";
-    private cachedEngine;
-    private engineInstanceCount;
-    private readonly pendingBuilds;
-    private readonly appRootRequireCache;
-    /**
-     * Stable key over the inputs that affect the engine configuration.
-     * Plugin order is intentionally not part of the key: two plugin
-     * sets with the same names are interchangeable for caching.
-     */
-    private getCacheKey;
-    /**
-     * Returns the cached engine, creating a new one when the cache
-     * key changes. On a cache miss the prior engine is closed and
-     * {@link engineInstanceCount} is incremented.
-     */
-    private getOrCreateEngine;
-    /**
-     * Triggers a build on the cached engine and returns the next
-     * `RolldownOutput` delivered to `onOutput`.
-     *
-     * First call after engine creation invokes `engine.run`; subsequent
-     * calls invoke `engine.triggerFullBuild` and reuse the cached
-     * module graph, resolver, and transform caches.
-     *
-     * If the trigger itself throws, the queued build is removed so
-     * the next `build()` does not consume a stale slot.
-     */
-    private runBuild;
-    /** Throws on error; see {@link build} for the no-throw variant. */
-    buildOrThrow(options: BuildOptions): Promise<BuildResult>;
-    build(options: BuildOptions): Promise<BuildResult>;
-    resolve(importPath: string, rootDir: string): string;
-    getTranspileOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
-    /**
-     * Closes the cached DevEngine and rejects any in-flight builds
-     * with `'DevBuildAdapter closed'`.
-     *
-     * @remarks
-     * Not on the {@link BuildAdapter} interface, so it is only
-     * reachable through the concrete class. The adapter is meant to
-     * live for the process lifetime; this is for explicit teardown.
-     */
-    close(): Promise<void>;
-    /** Test-only: number of engines created over the adapter's lifetime. */
-    getEngineInstanceCountForTests(): number;
-}
-export declare function createRolldownDevBuildAdapter(): RolldownDevBuildAdapter;