@ecopages/core 0.2.0-alpha.53 → 0.2.0-alpha.55

package/src/build/serialized-build-executor.d.ts

@@ -0,0 +1,64 @@
+import type { BuildExecutor, BuildOptions, BuildResult } from './build-adapter.js';
+/**
+ * FIFO-serialized build executor wrapper.
+ *
+ * @remarks
+ * Wraps any `BuildExecutor` and ensures that no two builds run
+ * concurrently. The next build waits for the previous one to finish
+ * (success or failure) before starting.
+ *
+ * This is a bundler-agnostic primitive. It is unaware of bundler
+ * lifecycle events and exists purely to enforce one build at a time.
+ * Use it from the dev watch pipeline, the static preview path, or any
+ * caller that issues builds concurrently.
+ */
+/**
+ * FIFO-serialized wrapper around a {@link BuildExecutor}.
+ *
+ * Every `build()` call enqueues onto the wrapper's internal queue. A
+ * build only starts after the previous build's promise has settled.
+ */
+export declare class SerializedBuildExecutor implements BuildExecutor {
+    private readonly inner;
+    private tail;
+    constructor(inner: BuildExecutor);
+    /**
+     * Run a build through the serialized queue. The returned promise
+     * resolves with the inner executor's `BuildResult`. A rejected
+     * inner build does not block the queue — the next caller can
+     * proceed.
+     */
+    build(options: BuildOptions): Promise<BuildResult>;
+    /**
+     * Run an arbitrary async operation through the serialized queue.
+     *
+     * Use this when the work is not a `build()` call against a wrapped
+     * executor (e.g. when composing with a coordinator that needs to
+     * inject recovery around the inner call). The returned promise
+     * resolves with the operation's result. A rejected operation does
+     * not block the queue.
+     */
+    run<T>(operation: () => Promise<T>): Promise<T>;
+    /**
+     * Returns the wrapped executor. Tests use this to assert the
+     * delegation chain.
+     */
+    unwrap(): BuildExecutor;
+    /**
+     * Reset the queue to an empty state. Tests use this to recover
+     * from a poisoned tail.
+     */
+    resetForTests(): void;
+    /**
+     * Overrides the internal queue tail for fault-recovery tests. The
+     * supplied promise is awaited before the next enqueued operation
+     * starts.
+     */
+    setBuildQueueForTests(queue: Promise<unknown>): void;
+    /**
+     * Returns the current internal queue tail for fault-recovery
+     * tests. Tests await this to assert that recovery has cleared a
+     * wedged queue.
+     */
+    getBuildQueueForTests(): Promise<unknown>;
+}

package/src/build/serialized-build-executor.js

@@ -0,0 +1,63 @@
+class SerializedBuildExecutor {
+  inner;
+  tail = Promise.resolve();
+  constructor(inner) {
+    this.inner = inner;
+  }
+  /**
+   * Run a build through the serialized queue. The returned promise
+   * resolves with the inner executor's `BuildResult`. A rejected
+   * inner build does not block the queue — the next caller can
+   * proceed.
+   */
+  build(options) {
+    return this.run(() => this.inner.build(options));
+  }
+  /**
+   * Run an arbitrary async operation through the serialized queue.
+   *
+   * Use this when the work is not a `build()` call against a wrapped
+   * executor (e.g. when composing with a coordinator that needs to
+   * inject recovery around the inner call). The returned promise
+   * resolves with the operation's result. A rejected operation does
+   * not block the queue.
+   */
+  run(operation) {
+    const next = this.tail.catch(() => void 0).then(() => operation());
+    this.tail = next.catch(() => void 0);
+    return next;
+  }
+  /**
+   * Returns the wrapped executor. Tests use this to assert the
+   * delegation chain.
+   */
+  unwrap() {
+    return this.inner;
+  }
+  /**
+   * Reset the queue to an empty state. Tests use this to recover
+   * from a poisoned tail.
+   */
+  resetForTests() {
+    this.tail = Promise.resolve();
+  }
+  /**
+   * Overrides the internal queue tail for fault-recovery tests. The
+   * supplied promise is awaited before the next enqueued operation
+   * starts.
+   */
+  setBuildQueueForTests(queue) {
+    this.tail = queue;
+  }
+  /**
+   * Returns the current internal queue tail for fault-recovery
+   * tests. Tests await this to assert that recovery has cleared a
+   * wedged queue.
+   */
+  getBuildQueueForTests() {
+    return this.tail;
+  }
+}
+export {
+  SerializedBuildExecutor
+};

package/src/build/server-side-css-shim-plugin.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Server-side CSS shim plugin for the bundler adapter.
+ *
+ * @remarks
+ * Page modules imported by the server (so the framework can read
+ * `getStaticProps` / `staticPaths` / page metadata) commonly have
+ * `import './style.css'` at the top. The bundler does not bundle
+ * CSS, and the server only needs the JS exports — the CSS itself
+ * is delivered to the browser via the page's `dependencies.stylesheets`
+ * declarations. This plugin:
+ *
+ * - Resolves `.css` imports to the absolute on-disk path.
+ * - Loads them and returns an empty ESM module with
+ *   `moduleSideEffects: true` so the bundler keeps the import in
+ *   the dependency graph without trying to bundle the bytes.
+ *
+ * The plugin is added by the adapter on every server-side build.
+ * Browser-side builds that want real CSS bundling should keep using
+ * a dedicated CSS pipeline (e.g. the postcss processor's output)
+ * and continue to declare stylesheets in `dependencies.stylesheets`
+ * — the shim is intentionally inert for those flows.
+ */
+type RolldownPluginLike = {
+    name: string;
+    resolveId: (source: string, importer: string | undefined) => Promise<string | null> | string | null;
+    load: (id: string) => Promise<{
+        code: string;
+        moduleType: 'js';
+        moduleSideEffects: boolean;
+    } | null> | {
+        code: string;
+        moduleType: 'js';
+        moduleSideEffects: boolean;
+    } | null;
+};
+/**
+ * Builds a Rolldown plugin that turns `.css` imports into no-op ESM
+ * modules while preserving the dependency graph.
+ */
+export declare function createServerSideCssShimPlugin(): RolldownPluginLike;
+export {};

package/src/build/server-side-css-shim-plugin.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+const CSS_PATH = /\.css$/u;
+const CSS_QUERY = "?ecopages-css-shim";
+function stripShimQuery(id) {
+  const queryIndex = id.indexOf("?");
+  return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
+function createServerSideCssShimPlugin() {
+  return {
+    name: "ecopages:server-side-css-shim",
+    async resolveId(source, importer) {
+      if (!CSS_PATH.test(source)) {
+        return null;
+      }
+      const resolved = importer ? path.resolve(path.dirname(importer), source) : path.resolve(source);
+      return existsSync(resolved) ? `${resolved}${CSS_QUERY}` : null;
+    },
+    async load(id) {
+      if (!id.endsWith(CSS_QUERY)) {
+        return null;
+      }
+      const realPath = stripShimQuery(id);
+      readFileSync(realPath, "utf-8");
+      return {
+        code: 'export default "";',
+        moduleType: "js",
+        moduleSideEffects: true
+      };
+    }
+  };
+}
+export {
+  createServerSideCssShimPlugin
+};

package/src/cache/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Public cache exports for the bundler plugin chain.
+ *
+ * @module @ecopages/core/cache
+ */
+export { ModuleParseCache, moduleParseCache, cachedParseSync, type ModuleParseOptions } from './module-parse-cache.js';

package/src/cache/index.js

@@ -0,0 +1,6 @@
+import { ModuleParseCache, moduleParseCache, cachedParseSync } from "./module-parse-cache.js";
+export {
+  ModuleParseCache,
+  cachedParseSync,
+  moduleParseCache
+};

package/src/cache/module-parse-cache.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Process-wide parse cache for `oxc-parser.parseSync`.
+ *
+ * @remarks
+ * Several build plugins (eco-component-meta, client-graph-boundary,
+ * browser-runtime) each call `parseSync` on the same source file with
+ * overlapping options. This cache memoizes the parse result keyed by
+ * `(absolute path, source, options)`. When the source is unchanged,
+ * subsequent calls return the cached result without re-parsing.
+ *
+ * The cache is LRU-bounded (10 000 entries) and key-stable across a
+ * single HMR session. It is **content-hashed** rather than
+ * mtime-hashed so that `touch`/`utimes` does not invalidate a
+ * still-valid parse.
+ */
+import { type ParseResult, type ParserOptions } from 'oxc-parser';
+export type ModuleParseOptions = ParserOptions & {
+    /**
+     * Optional parser language override. If omitted, derived from the file
+     * extension at lookup time. Set this explicitly if your caller already
+     * computed the language (avoids re-deriving inside the cache).
+     */
+    lang?: ParserOptions['lang'];
+};
+/**
+ * LRU-bounded module parse cache.
+ *
+ * Single instance shared across the process. Constructed lazily; use
+ * {@link moduleParseCache} for the default shared instance.
+ */
+export declare class ModuleParseCache {
+    private readonly entries;
+    private readonly maxEntries;
+    private hits;
+    private misses;
+    constructor(maxEntries?: number);
+    /**
+     * Parse `source` for `filePath`, memoizing by (filePath, source, options).
+     *
+     * @returns the {@link ParseResult} from `oxc-parser.parseSync`.
+     */
+    getOrParse(filePath: string, source: string, options?: ModuleParseOptions): ParseResult;
+    /** Clear all cached entries. Useful in tests and on full-rebuild signals. */
+    clear(): void;
+    /** Current cache size (for observability). */
+    get size(): number;
+    /** Cumulative hit/miss counters (for observability). */
+    stats(): {
+        hits: number;
+        misses: number;
+        size: number;
+        hitRate: number;
+    };
+}
+/**
+ * Default shared cache. Use this from plugin code so the cache is
+ * amortized across plugins and build invocations.
+ */
+export declare const moduleParseCache: ModuleParseCache;
+/**
+ * Drop-in replacement for `oxc-parser.parseSync` that uses the shared
+ * {@link moduleParseCache}. Use everywhere we currently call `parseSync`
+ * on user/source files during a build.
+ */
+export declare function cachedParseSync(filePath: string, source: string, options?: ModuleParseOptions): ParseResult;

package/src/cache/module-parse-cache.js

@@ -0,0 +1,75 @@
+import { parseSync } from "oxc-parser";
+import { rapidhash } from "../utils/hash.js";
+const DEFAULT_MAX_ENTRIES = 1e4;
+class ModuleParseCache {
+  entries = /* @__PURE__ */ new Map();
+  maxEntries;
+  hits = 0;
+  misses = 0;
+  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+    if (maxEntries <= 0) {
+      throw new Error(`ModuleParseCache: maxEntries must be > 0, got ${maxEntries}`);
+    }
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * Parse `source` for `filePath`, memoizing by (filePath, source, options).
+   *
+   * @returns the {@link ParseResult} from `oxc-parser.parseSync`.
+   */
+  getOrParse(filePath, source, options = {}) {
+    const hash = rapidhash(source);
+    const key = makeKey(filePath, hash, options);
+    const existing = this.entries.get(key);
+    if (existing && existing.hash === hash) {
+      this.hits += 1;
+      this.entries.delete(key);
+      this.entries.set(key, existing);
+      return existing.result;
+    }
+    this.misses += 1;
+    const result = parseSync(filePath, source, options);
+    this.entries.set(key, { hash, result });
+    if (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.entries.delete(oldestKey);
+      }
+    }
+    return result;
+  }
+  /** Clear all cached entries. Useful in tests and on full-rebuild signals. */
+  clear() {
+    this.entries.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /** Current cache size (for observability). */
+  get size() {
+    return this.entries.size;
+  }
+  /** Cumulative hit/miss counters (for observability). */
+  stats() {
+    const total = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.entries.size,
+      hitRate: total === 0 ? 0 : this.hits / total
+    };
+  }
+}
+const moduleParseCache = new ModuleParseCache();
+function cachedParseSync(filePath, source, options = {}) {
+  return moduleParseCache.getOrParse(filePath, source, options);
+}
+function makeKey(filePath, sourceHash, options) {
+  const lang = options.lang ?? "";
+  const sourceType = options.sourceType ?? "";
+  return `${filePath} ${sourceHash.toString(36)} ${lang} ${sourceType}`;
+}
+export {
+  ModuleParseCache,
+  cachedParseSync,
+  moduleParseCache
+};

package/src/config/README.md

@@ -27,7 +27,7 @@ It is responsible for:
 - `ConfigBuilder.build()` decides ordering, validates compatibility, and seals build ownership for the finalized app config.
 - Runtime startup reuses finalized config/build state; it should not recompute manifest ownership.
 
-Bun-native is the default ownership path. Vite-host ownership is explicit and should be selected during config construction when a host-driven compatibility flow must avoid silently falling back to Bun build execution.
+App-owned is the default ownership path. Host-owned is explicit and should be selected during config construction when a host-driven compatibility flow must avoid silently falling back to app build execution.
 
 ## Output
 

package/src/config/config-builder.d.ts

@@ -66,9 +66,9 @@ export declare class ConfigBuilder {
      * Sets which runtime path owns build execution for the finalized app config.
      *
      * @remarks
-     * Bun-native remains the default. Vite-host ownership should be selected only
-     * for host-driven compatibility flows where core must not silently fall back to
-     * Bun build execution.
+     * The app-owned build path is the default. The host-owned path should be
+     * selected only for host-driven compatibility flows where core must not
+     * silently fall back to app build execution.
      */
     setBuildOwnership(buildOwnership: BuildOwnership): this;
     /**

package/src/config/config-builder.js

@@ -8,12 +8,10 @@ import {
 import {
   collectConfiguredAppBuildManifestContributions,
   createBuildAdapter,
-  getAppServerBuildPlugins,
   setAppBuildAdapter,
   setAppBuildExecutor,
   updateAppBuildManifest
 } from "../build/build-adapter.js";
-import { createAppBuildExecutor } from "../build/dev-build-coordinator.js";
 import { GHTML_PLUGIN_NAME } from "../integrations/ghtml/ghtml.constants.js";
 import { ghtmlPlugin } from "../integrations/ghtml/ghtml.plugin.js";
 import { createEcoComponentMetaPlugin } from "../plugins/eco-component-meta-plugin.js";
@@ -41,7 +39,7 @@ const CONFIG_BUILDER_ERRORS = {
   invalidRuntimeVersion: (kind, name, version) => `Cannot validate ${kind} "${name}" runtimeCapability.minRuntimeVersion "${version}" because it is not a dot-separated numeric version`
 };
 class ConfigBuilder {
-  buildOwnership = "bun-native";
+  buildOwnership = "rolldown";
   config = {
     baseUrl: "",
     rootDir: ".",
@@ -110,9 +108,9 @@ class ConfigBuilder {
    * Sets which runtime path owns build execution for the finalized app config.
    *
    * @remarks
-   * Bun-native remains the default. Vite-host ownership should be selected only
-   * for host-driven compatibility flows where core must not silently fall back to
-   * Bun build execution.
+   * The app-owned build path is the default. The host-owned path should be
+   * selected only for host-driven compatibility flows where core must not
+   * silently fall back to app build execution.
    */
   setBuildOwnership(buildOwnership) {
     this.buildOwnership = buildOwnership;
@@ -581,14 +579,7 @@ class ConfigBuilder {
     updateAppBuildManifest(this.config, await collectConfiguredAppBuildManifestContributions(this.config));
     setAppServerInvalidationState(this.config, new CounterServerInvalidationState());
     setAppEntrypointDependencyGraph(this.config, new NoopEntrypointDependencyGraph());
-    setAppBuildExecutor(
-      this.config,
-      createAppBuildExecutor({
-        development: false,
-        adapter: buildAdapter,
-        getPlugins: () => getAppServerBuildPlugins(this.config)
-      })
-    );
+    setAppBuildExecutor(this.config, buildAdapter);
     return this.config;
   }
 }

package/src/eco/eco.types.d.ts

@@ -136,11 +136,8 @@ interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsB
 /**
  * Options for creating a page with eco.page()
  *
- * Supports two patterns:
- * 1. **Consolidated API** (recommended): Define staticPaths, staticProps, and metadata inline
- * 2. **Separate exports** (legacy): Export getStaticPaths, getStaticProps, getMetadata separately
- *
- * When using `middleware`, `cache` must be set to `'dynamic'` because middleware
+ * Define staticPaths, staticProps, and metadata inline. When using
+ * `middleware`, `cache` must be set to `'dynamic'` because middleware
  * runs on every request and caching would bypass middleware effects.
  *
  * @template T - The props type for the page

package/src/hmr/strategies/js-hmr-strategy.d.ts

@@ -111,13 +111,13 @@ export declare class JsHmrStrategy extends HmrStrategy {
      * @remarks
      * If runtime-specific dependency graph hooks are unavailable, this strategy
      * falls back to rebuilding all watched entrypoints.
-     * When multiple entrypoints are impacted they are bundled in a single esbuild
+     * When multiple entrypoints are impacted they are bundled in a single
      * invocation to share AST parsing and chunk deduplication.
      * @returns Action to broadcast update events
      */
     process(filePath: string): Promise<HmrAction>;
     /**
-     * Bundles one or more entrypoints in a single esbuild invocation.
+     * Bundles one or more entrypoints in a single build invocation.
      * Uses the source directory as the output base so that the directory structure
      * is preserved under the HMR dist folder.
      */

package/src/hmr/strategies/js-hmr-strategy.js

@@ -46,7 +46,7 @@ class JsHmrStrategy extends HmrStrategy {
    * @remarks
    * If runtime-specific dependency graph hooks are unavailable, this strategy
    * falls back to rebuilding all watched entrypoints.
-   * When multiple entrypoints are impacted they are bundled in a single esbuild
+   * When multiple entrypoints are impacted they are bundled in a single
    * invocation to share AST parsing and chunk deduplication.
    * @returns Action to broadcast update events
    */
@@ -114,7 +114,7 @@ class JsHmrStrategy extends HmrStrategy {
     return { type: "none" };
   }
   /**
-   * Bundles one or more entrypoints in a single esbuild invocation.
+   * Bundles one or more entrypoints in a single build invocation.
    * Uses the source directory as the output base so that the directory structure
    * is preserved under the HMR dist folder.
    */

package/src/plugins/alias-resolver-cache.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Per-plugin cache for `@/...` alias resolution.
+ *
+ * @remarks
+ * The `ecopages-alias-resolver` plugin resolves project aliases like
+ * `@/components/Button` to concrete file paths under the app's `srcDir`.
+ * Each resolution can trigger up to 22 `existsSync` calls and (when
+ * the resolved path is a barrel) a `readFileSync` to detect
+ * `export * from './...'` forwarding.
+ *
+ * This cache memoizes the result keyed by `(srcDir, specifier)`. It is
+ * process-local and not currently invalidated by the file watcher —
+ * `srcDir` contents are assumed to be stable for the lifetime of the
+ * process.
+ */
+export declare class AliasResolverCache {
+    private readonly entries;
+    private readonly maxEntries;
+    private hits;
+    private misses;
+    constructor(maxEntries?: number);
+    /**
+     * Look up a previously-computed resolution for `(srcDir, specifier)`.
+     *
+     * Returns `{ hit: true, resolved }` on cache hit (resolved may be
+     * `undefined` for an unresolvable specifier), or `{ hit: false }` on
+     * miss. The caller is responsible for re-running the resolver and
+     * calling `set` to store the new entry.
+     */
+    get(srcDir: string, specifier: string): {
+        hit: true;
+        resolved: string | undefined;
+    } | {
+        hit: false;
+    };
+    /**
+     * Store a resolution result.
+     *
+     * Pass `undefined` for `resolved` to memoize the negative case
+     * (specifier did not resolve) and avoid repeating the FS walk on
+     * every `@/...` import.
+     */
+    set(srcDir: string, specifier: string, resolved: string | undefined): void;
+    /**
+     * Drop all entries whose `srcDir` is under `rootDir`. Use this from
+     * the file watcher when files are added or removed under the app's
+     * source tree.
+     *
+     * Path comparison is path-aware (handles both POSIX `/` and
+     * Windows `\` separators) via `path.relative` so cached entries
+     * normalized on one platform still match the watcher's `rootDir`
+     * on another. Without this, a Windows build that sees
+     * `entry.srcDir === 'C:\app\src'` would miss
+     * `entry.srcDir.startsWith('C:/app/src/')` and leave stale entries.
+     */
+    invalidateUnder(rootDir: string): number;
+    /** Clear all entries. */
+    clear(): void;
+    /** Current cache size. */
+    get size(): number;
+    /** Hit/miss counters for observability. */
+    stats(): {
+        hits: number;
+        misses: number;
+        size: number;
+        hitRate: number;
+    };
+}

package/src/plugins/alias-resolver-cache.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+const DEFAULT_MAX_ENTRIES = 2e3;
+class AliasResolverCache {
+  entries = /* @__PURE__ */ new Map();
+  maxEntries;
+  hits = 0;
+  misses = 0;
+  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+    if (maxEntries <= 0) {
+      throw new Error(`AliasResolverCache: maxEntries must be > 0, got ${maxEntries}`);
+    }
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * Look up a previously-computed resolution for `(srcDir, specifier)`.
+   *
+   * Returns `{ hit: true, resolved }` on cache hit (resolved may be
+   * `undefined` for an unresolvable specifier), or `{ hit: false }` on
+   * miss. The caller is responsible for re-running the resolver and
+   * calling `set` to store the new entry.
+   */
+  get(srcDir, specifier) {
+    const key = makeKey(srcDir, specifier);
+    const existing = this.entries.get(key);
+    if (existing) {
+      this.hits += 1;
+      this.entries.delete(key);
+      this.entries.set(key, existing);
+      return { hit: true, resolved: existing.resolved };
+    }
+    this.misses += 1;
+    return { hit: false };
+  }
+  /**
+   * Store a resolution result.
+   *
+   * Pass `undefined` for `resolved` to memoize the negative case
+   * (specifier did not resolve) and avoid repeating the FS walk on
+   * every `@/...` import.
+   */
+  set(srcDir, specifier, resolved) {
+    const key = makeKey(srcDir, specifier);
+    this.entries.set(key, { srcDir, resolved });
+    if (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.entries.delete(oldestKey);
+      }
+    }
+  }
+  /**
+   * Drop all entries whose `srcDir` is under `rootDir`. Use this from
+   * the file watcher when files are added or removed under the app's
+   * source tree.
+   *
+   * Path comparison is path-aware (handles both POSIX `/` and
+   * Windows `\` separators) via `path.relative` so cached entries
+   * normalized on one platform still match the watcher's `rootDir`
+   * on another. Without this, a Windows build that sees
+   * `entry.srcDir === 'C:\app\src'` would miss
+   * `entry.srcDir.startsWith('C:/app/src/')` and leave stale entries.
+   */
+  invalidateUnder(rootDir) {
+    const normalizedRoot = path.resolve(rootDir);
+    let removed = 0;
+    for (const [key, entry] of this.entries) {
+      if (isUnderDirectory(path.resolve(entry.srcDir), normalizedRoot)) {
+        this.entries.delete(key);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  /** Clear all entries. */
+  clear() {
+    this.entries.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /** Current cache size. */
+  get size() {
+    return this.entries.size;
+  }
+  /** Hit/miss counters for observability. */
+  stats() {
+    const total = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.entries.size,
+      hitRate: total === 0 ? 0 : this.hits / total
+    };
+  }
+}
+function makeKey(srcDir, specifier) {
+  return `${srcDir} ${specifier}`;
+}
+function isUnderDirectory(candidate, parent) {
+  if (candidate === parent) return true;
+  const rel = path.relative(parent, candidate);
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return false;
+  return true;
+}
+export {
+  AliasResolverCache
+};

package/src/plugins/alias-resolver-plugin.d.ts

@@ -1,3 +1,6 @@
 import type { EcoBuildPlugin } from '../build/build-types.js';
+import { AliasResolverCache } from './alias-resolver-cache.js';
 export declare function resolveAppSourceAliasPath(srcDir: string, specifier: string): string | undefined;
-export declare function createAliasResolverPlugin(srcDir: string): EcoBuildPlugin;
+export declare function createAliasResolverPlugin(srcDir: string, options?: {
+    cache?: AliasResolverCache;
+}): EcoBuildPlugin;