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

package/src/build/rolldown-plugin-bridge.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bundler plugin bridge.
+ *
+ * @remarks
+ * Translates an array of `EcoBuildPlugin` instances (the runtime-agnostic
+ * plugin contract used by Ecopages processors and integrations) into
+ * the bundler's native `Plugin` array. The bridge exposes the same
+ * three hooks (`onResolve`, `onLoad`, `module`) the `EcoBuildPlugin`
+ * contract uses, but maps them to the bundler's `resolveId`/`load`
+ * hooks.
+ *
+ * The shared `EcoBuildPlugin` contract stays the boundary between
+ * integrations and bundler backends.
+ *
+ * **Namespace handling.**
+ *
+ * The shared `EcoBuildPlugin` contract scopes `onResolve`/`onLoad`
+ * handlers with a `namespace` string. The bundler encodes namespaces
+ * into the module id (no separate field). The bridge prepends
+ * `<namespace>:` to the resolved id when the result includes a
+ * namespace, and matches `onLoad`/`onResolve` filters against that
+ * prefix. The bridge strips the prefix before forwarding the id back
+ * to the callback so plugin code keeps seeing the same `path` shape
+ * it did on the historical contract.
+ *
+ * **Plugin ordering is semantically significant.**
+ *
+ * The bundler's `resolveId` and `load` are "first" hooks: the first
+ * plugin that returns a non-null value wins. Because the bridge
+ * translates each `EcoBuildPlugin` into its own bundler plugin and
+ * preserves the array order, the position of each plugin in the
+ * `plugins` array determines its priority:
+ *
+ * - **Index 0** has the highest priority.
+ * - **Last index** has the lowest priority.
+ *
+ * When adding new integrations or processors, ensure security-critical
+ * plugins (e.g. `ecopages-client-graph-boundary`) are placed **before**
+ * general-purpose loaders in the array so they always get first refusal
+ * on every source file.
+ */
+import type { Plugin } from 'rolldown';
+import type { EcoBuildPlugin } from './build-types.js';
+/**
+ * Creates a Rolldown `Plugin` array that drives the supplied
+ * `EcoBuildPlugin` instances. Each `EcoBuildPlugin` becomes its own
+ * Rolldown plugin so that the order of registrations is preserved as
+ * plugin priority.
+ */
+export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string): Plugin[];

package/src/build/rolldown-plugin-bridge.js

@@ -0,0 +1,194 @@
+import path from "node:path";
+import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
+const NAMESPACE_SEPARATOR = ":";
+function joinNamespace(namespace, value) {
+  return namespace ? `${namespace}${NAMESPACE_SEPARATOR}${value}` : value;
+}
+function splitNamespace(id) {
+  const separatorIndex = id.indexOf(NAMESPACE_SEPARATOR);
+  if (separatorIndex <= 0) {
+    return { namespace: void 0, path: id };
+  }
+  return {
+    namespace: id.slice(0, separatorIndex),
+    path: id.slice(separatorIndex + 1)
+  };
+}
+function inferRolldownModuleTypeFromPath(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  switch (extension) {
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    case ".json":
+      return "json";
+    case ".css":
+      return "css";
+    default:
+      return "js";
+  }
+}
+function normalizeRolldownModuleType(loader) {
+  switch (loader) {
+    case "js":
+    case "jsx":
+    case "ts":
+    case "tsx":
+    case "json":
+    case "css":
+    case "text":
+    case "base64":
+    case "dataurl":
+    case "binary":
+    case "empty":
+      return loader;
+    case "global-css":
+    case "local-css":
+      return "css";
+    case "file":
+    case "copy":
+      return "asset";
+    default:
+      return void 0;
+  }
+}
+function convertLoadResultToModuleSource(result) {
+  if (result.loader === "object" && result.exports && typeof result.exports === "object") {
+    return Object.entries(result.exports).map(
+      ([key, value]) => key === "default" ? `export default ${JSON.stringify(value)};` : `export const ${key} = ${JSON.stringify(value)};`
+    ).join("\n");
+  }
+  return void 0;
+}
+function buildIdFilter(filter, namespace) {
+  if (!namespace) {
+    return filter;
+  }
+  return new RegExp(`^${escapeRegExp(namespace)}${NAMESPACE_SEPARATOR}${filter.source.slice(1)}`);
+}
+function resolvePluginPath(value, importer, contextRoot) {
+  if (path.isAbsolute(value)) {
+    return value;
+  }
+  if (value.startsWith(".") || value.startsWith("..")) {
+    const baseDir = importer ? path.dirname(importer) : contextRoot;
+    return path.resolve(baseDir, value);
+  }
+  return value;
+}
+function convertPluginOnLoadResult(args, result) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const candidate = result;
+  const { path: sourcePath } = splitNamespace(args.id);
+  const sourceFromExports = convertLoadResultToModuleSource(candidate);
+  if (sourceFromExports) {
+    const description = {
+      code: sourceFromExports,
+      moduleType: "js"
+    };
+    return description;
+  }
+  if (typeof candidate.contents === "string" || candidate.contents instanceof Uint8Array) {
+    const code = typeof candidate.contents === "string" ? candidate.contents : new TextDecoder().decode(candidate.contents);
+    const description = {
+      code,
+      moduleType: normalizeRolldownModuleType(candidate.loader) ?? inferRolldownModuleTypeFromPath(sourcePath)
+    };
+    return description;
+  }
+  return void 0;
+}
+function convertPluginOnResolveResult(result, importer, contextRoot) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const candidate = result;
+  if (typeof candidate.path !== "string" && typeof candidate.namespace !== "string") {
+    if (typeof candidate.external !== "boolean") {
+      return void 0;
+    }
+  }
+  const partial = { id: "" };
+  if (typeof candidate.path === "string") {
+    partial.id = joinNamespace(candidate.namespace, resolvePluginPath(candidate.path, importer, contextRoot));
+  } else if (typeof candidate.namespace === "string") {
+    partial.id = joinNamespace(candidate.namespace, "");
+  }
+  if (typeof candidate.external === "boolean") {
+    partial.external = candidate.external;
+  }
+  return partial;
+}
+function wrapEcoPlugin(ecoPlugin, contextRoot, moduleCounter) {
+  const resolveRegistrations = [];
+  const loadRegistrations = [];
+  const registerResolve = (filter, callback) => {
+    resolveRegistrations.push({ filter, callback });
+  };
+  const registerLoad = (filter, callback) => {
+    loadRegistrations.push({ filter, callback });
+  };
+  return {
+    name: `ecopages-plugin-bridge:${ecoPlugin.name}`,
+    buildStart: async () => {
+      const bridge = {
+        onResolve: (options, callback) => {
+          registerResolve(buildIdFilter(options.filter, options.namespace), callback);
+        },
+        onLoad: (options, callback) => {
+          registerLoad(buildIdFilter(options.filter, options.namespace), callback);
+        },
+        module: (specifier, callback) => {
+          const namespace = `ecopages-module-${moduleCounter.value}`;
+          moduleCounter.value += 1;
+          const filter = new RegExp(`^${escapeRegExp(specifier)}$`);
+          registerResolve(filter, async () => ({
+            path: joinNamespace(namespace, specifier)
+          }));
+          registerLoad(buildIdFilter(/.*/, namespace), async () => callback());
+        }
+      };
+      await ecoPlugin.setup(bridge);
+    },
+    resolveId: async (source, importer, _extraOptions) => {
+      for (const { filter, callback } of resolveRegistrations) {
+        if (!filter.test(source)) {
+          continue;
+        }
+        const { namespace, path: sourcePath } = splitNamespace(source);
+        const result = await callback({ path: sourcePath, importer, namespace });
+        const converted = convertPluginOnResolveResult(result, importer, contextRoot);
+        if (converted !== void 0) {
+          return converted;
+        }
+      }
+      return void 0;
+    },
+    load: async (id) => {
+      for (const { filter, callback } of loadRegistrations) {
+        if (!filter.test(id)) {
+          continue;
+        }
+        const { namespace, path: sourcePath } = splitNamespace(id);
+        const result = await callback({ path: sourcePath, namespace });
+        const converted = convertPluginOnLoadResult({ id }, result);
+        if (converted !== void 0) {
+          return converted;
+        }
+      }
+      return void 0;
+    }
+  };
+}
+function createRolldownPluginBridge(plugins, contextRoot) {
+  const moduleCounter = { value: 0 };
+  return plugins.map((ecoPlugin) => wrapEcoPlugin(ecoPlugin, contextRoot, moduleCounter));
+}
+export {
+  createRolldownPluginBridge
+};

package/src/build/{runtime-build-executor.ts → runtime-build-executor.d.ts}

@@ -1,14 +1,5 @@
-import type { EcoPagesAppConfig } from '../types/internal-types.ts';
-import {
-	getAppBuildAdapter,
-	getAppBuildExecutor,
-	getAppServerBuildPlugins,
-	setAppBuildExecutor,
-	withBuildExecutorPlugins,
-	type BuildExecutor,
-} from './build-adapter.ts';
-import { SerializedBuildExecutor } from './serialized-build-executor.ts';
-
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+import { type BuildExecutor } from './build-adapter.js';
 /**
  * Installs the app-owned runtime build executor for one app instance.
  *
@@ -27,11 +18,4 @@ import { SerializedBuildExecutor } from './serialized-build-executor.ts';
  *   app-owned adapter) and writes the wrapped executor back.
  * @returns The installed {@link BuildExecutor}.
  */
-export function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor {
-	const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
-	const buildExecutor = new SerializedBuildExecutor(
-		withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig)),
-	);
-	setAppBuildExecutor(appConfig, buildExecutor);
-	return buildExecutor;
-}
+export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

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

@@ -0,0 +1,19 @@
+import {
+  getAppBuildAdapter,
+  getAppBuildExecutor,
+  getAppServerBuildPlugins,
+  setAppBuildExecutor,
+  withBuildExecutorPlugins
+} from "./build-adapter.js";
+import { SerializedBuildExecutor } from "./serialized-build-executor.js";
+function installAppRuntimeBuildExecutor(appConfig) {
+  const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
+  const buildExecutor = new SerializedBuildExecutor(
+    withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig))
+  );
+  setAppBuildExecutor(appConfig, buildExecutor);
+  return buildExecutor;
+}
+export {
+  installAppRuntimeBuildExecutor
+};

package/src/build/runtime-build-output-normalizer.d.ts

@@ -0,0 +1,3 @@
+export declare function isDeclaredAppPackageImport(specifier: string, rootDir: string): boolean;
+export declare function normalizeNodeRuntimeBuildOutputFile(filePath: string, rootDir: string): void;
+export declare function normalizeNodeRuntimeBuildOutputs(outputPaths: string[], rootDir: string): void;

package/src/build/runtime-build-output-normalizer.js

@@ -0,0 +1,111 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+const appDeclaredPackageCache = /* @__PURE__ */ new Map();
+function tryResolveRuntimeImport(specifier, resolver) {
+  try {
+    return resolver.resolve(specifier);
+  } catch {
+    return void 0;
+  }
+}
+function isBareRuntimeImport(specifier) {
+  return !specifier.startsWith(".") && !path.isAbsolute(specifier) && !specifier.startsWith("/") && !specifier.startsWith("node:") && !specifier.startsWith("@/") && !specifier.startsWith("~/") && !specifier.startsWith("#") && !specifier.includes(":");
+}
+function getPackageNameFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    return specifier.split("/").slice(0, 2).join("/");
+  }
+  return specifier.split("/")[0] ?? specifier;
+}
+function getDeclaredAppPackages(rootDir) {
+  const cacheKey = path.resolve(rootDir);
+  const cached = appDeclaredPackageCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const packageJsonPath = path.resolve(rootDir, "package.json");
+  const declaredPackages = /* @__PURE__ */ new Set();
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const entries = packageJson[field];
+      if (!entries || typeof entries !== "object") {
+        continue;
+      }
+      for (const packageName of Object.keys(entries)) {
+        declaredPackages.add(packageName);
+      }
+    }
+  } catch {
+    appDeclaredPackageCache.set(cacheKey, declaredPackages);
+    return declaredPackages;
+  }
+  appDeclaredPackageCache.set(cacheKey, declaredPackages);
+  return declaredPackages;
+}
+function isDeclaredAppPackageImport(specifier, rootDir) {
+  return getDeclaredAppPackages(rootDir).has(getPackageNameFromSpecifier(specifier));
+}
+function rewriteRuntimeImportSpecifier(specifier, quote, rootDir) {
+  if (!isBareRuntimeImport(specifier)) {
+    return void 0;
+  }
+  if (isDeclaredAppPackageImport(specifier, rootDir)) {
+    return void 0;
+  }
+  const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
+  if (!resolvedPath || !/\.(?:[cm]?[jt]s|tsx|jsx)$/u.test(resolvedPath)) {
+    return void 0;
+  }
+  return `${quote}${pathToFileURL(resolvedPath).href}${quote}`;
+}
+function rewriteRuntimeBuildOutputImports(code, rootDir) {
+  const rewriteSpecifier = (prefix, quote, specifier) => {
+    const rewrittenSpecifier = rewriteRuntimeImportSpecifier(specifier, quote, rootDir);
+    return `${prefix}${rewrittenSpecifier ?? `${quote}${specifier}${quote}`}`;
+  };
+  const withResolvedPackages = code.replace(
+    /(\bfrom\s+)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s+)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s*\(\s*)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  );
+  return withResolvedPackages.replace(
+    /(['"])(@oxc-project\/runtime\/(?:helpers(?:\/esm)?\/[^'"\\]+))\1/g,
+    (match, quote, specifier) => {
+      const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
+      return resolvedPath ? `${quote}${pathToFileURL(resolvedPath).href}${quote}` : match;
+    }
+  );
+}
+function normalizeNodeRuntimeBuildOutputFile(filePath, rootDir) {
+  if (!/\.(?:[cm]?js)$/u.test(filePath)) {
+    return;
+  }
+  const fileSystem = corePackageRequire("node:fs");
+  if (!fileSystem.existsSync(filePath)) {
+    return;
+  }
+  const code = fileSystem.readFileSync(filePath, "utf-8");
+  const rewritten = rewriteRuntimeBuildOutputImports(code, rootDir);
+  if (rewritten !== code) {
+    fileSystem.writeFileSync(filePath, rewritten);
+  }
+}
+function normalizeNodeRuntimeBuildOutputs(outputPaths, rootDir) {
+  for (const outputPath of outputPaths) {
+    normalizeNodeRuntimeBuildOutputFile(outputPath, rootDir);
+  }
+}
+export {
+  isDeclaredAppPackageImport,
+  normalizeNodeRuntimeBuildOutputFile,
+  normalizeNodeRuntimeBuildOutputs
+};

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.ts → index.d.ts}

@@ -3,4 +3,4 @@
  *
  * @module @ecopages/core/cache
  */
-export { ModuleParseCache, moduleParseCache, cachedParseSync, type ModuleParseOptions } from './module-parse-cache.ts';
+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
+};