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

package/src/services/invalidation/development-invalidation.service.js

@@ -0,0 +1,190 @@
+import path from "node:path";
+import { getAppServerInvalidationState } from "../runtime-state/server-invalidation-state.service.js";
+class DevelopmentInvalidationService {
+  appConfig;
+  constructor(appConfig) {
+    this.appConfig = appConfig;
+  }
+  /**
+   * Returns the current app-owned server-module invalidation version.
+   */
+  getServerModuleInvalidationVersion() {
+    return getAppServerInvalidationState(this.appConfig).getServerInvalidationVersion();
+  }
+  /**
+   * Invalidates the app-owned server-module graph.
+   */
+  invalidateServerModules(changedFiles) {
+    getAppServerInvalidationState(this.appConfig).invalidateServerModules(changedFiles);
+    this.appConfig.runtime?.appModuleLoader?.invalidateDevelopmentGraph();
+  }
+  /**
+   * Resets runtime-owned graph state and invalidates server modules.
+   */
+  resetRuntimeState(changedFiles) {
+    const serverInvalidationState = getAppServerInvalidationState(this.appConfig);
+    serverInvalidationState.invalidateServerModules(changedFiles);
+    serverInvalidationState.reset();
+  }
+  /**
+   * Classifies one changed file into an explicit framework invalidation plan.
+   */
+  planFileChange(filePath) {
+    if (this.isPublicDirFile(filePath)) {
+      return {
+        category: "public-asset",
+        invalidateServerModules: false,
+        refreshRoutes: false,
+        reloadBrowser: true,
+        delegateToHmr: false,
+        processorHandledAsset: false
+      };
+    }
+    if (this.matchesAdditionalWatchPaths(filePath)) {
+      return {
+        category: "additional-watch",
+        invalidateServerModules: false,
+        refreshRoutes: false,
+        reloadBrowser: true,
+        delegateToHmr: false,
+        processorHandledAsset: false
+      };
+    }
+    if (this.isIncludeSourceFile(filePath)) {
+      return {
+        category: "include-source",
+        invalidateServerModules: true,
+        refreshRoutes: false,
+        reloadBrowser: true,
+        delegateToHmr: false,
+        processorHandledAsset: false
+      };
+    }
+    if (this.isRouteSourceFile(filePath)) {
+      return {
+        category: "route-source",
+        invalidateServerModules: true,
+        refreshRoutes: true,
+        reloadBrowser: false,
+        delegateToHmr: true,
+        processorHandledAsset: false
+      };
+    }
+    if (this.isProcessorOwnedAsset(filePath)) {
+      return {
+        category: "processor-owned-asset",
+        invalidateServerModules: false,
+        refreshRoutes: false,
+        reloadBrowser: false,
+        delegateToHmr: false,
+        processorHandledAsset: true
+      };
+    }
+    if (this.isServerModuleSourceFile(filePath)) {
+      return {
+        category: "server-source",
+        invalidateServerModules: true,
+        refreshRoutes: false,
+        reloadBrowser: false,
+        delegateToHmr: true,
+        processorHandledAsset: false
+      };
+    }
+    return {
+      category: "other",
+      invalidateServerModules: false,
+      refreshRoutes: false,
+      reloadBrowser: false,
+      delegateToHmr: true,
+      processorHandledAsset: false
+    };
+  }
+  /**
+   * Returns whether the file lives under the public directory.
+   */
+  isPublicDirFile(filePath) {
+    return path.resolve(filePath).startsWith(this.appConfig.absolutePaths.publicDir);
+  }
+  /**
+   * Returns whether the file matches `additionalWatchPaths`.
+   */
+  matchesAdditionalWatchPaths(filePath) {
+    const normalizedPath = path.resolve(filePath);
+    const patterns = this.appConfig.additionalWatchPaths;
+    if (!patterns.length) return false;
+    for (const pattern of patterns) {
+      if (pattern.includes("*")) {
+        const ext = pattern.replace(/\*\*?\/\*/, "");
+        if (normalizedPath.endsWith(ext)) return true;
+      } else if (normalizedPath.endsWith(pattern) || normalizedPath === path.resolve(pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns whether the file is a route source file.
+   */
+  isRouteSourceFile(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    if (!resolvedPath.startsWith(this.appConfig.absolutePaths.pagesDir)) {
+      return false;
+    }
+    if (this.appConfig.templatesExt.some((extension) => resolvedPath.endsWith(extension))) {
+      return true;
+    }
+    return /\.(?:[cm]?ts|[jt]sx?|mdx)$/u.test(resolvedPath);
+  }
+  /**
+   * Returns whether the file is an include/template source file.
+   */
+  isIncludeSourceFile(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    if (!resolvedPath.startsWith(this.appConfig.absolutePaths.includesDir)) {
+      return false;
+    }
+    if (this.appConfig.templatesExt.some((extension) => resolvedPath.endsWith(extension))) {
+      return true;
+    }
+    return /\.(?:[cm]?ts|[jt]sx?|mdx)$/u.test(resolvedPath);
+  }
+  /**
+   * Returns whether the file is a server-executed source module outside the
+   * special route/include buckets.
+   */
+  isServerModuleSourceFile(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    if (!resolvedPath.startsWith(this.appConfig.absolutePaths.srcDir)) {
+      return false;
+    }
+    if (this.appConfig.templatesExt.some((extension) => resolvedPath.endsWith(extension))) {
+      return true;
+    }
+    return /\.(?:[cm]?ts|[jt]sx?|mdx)$/u.test(resolvedPath);
+  }
+  /**
+   * Returns whether a processor owns the changed file as an asset input.
+   */
+  isProcessorOwnedAsset(filePath) {
+    for (const processor of this.appConfig.processors.values()) {
+      const capabilities = processor.getAssetCapabilities?.() ?? [];
+      if (capabilities.length > 0) {
+        const matchesConfiguredAsset = typeof processor.matchesFileFilter !== "function" || processor.matchesFileFilter(filePath);
+        if (matchesConfiguredAsset && capabilities.some((capability) => processor.canProcessAsset?.(capability.kind, filePath))) {
+          return true;
+        }
+        continue;
+      }
+      const watchConfig = processor.getWatchConfig();
+      if (!watchConfig) continue;
+      const { extensions = [] } = watchConfig;
+      if (extensions.length && extensions.some((ext) => filePath.endsWith(ext))) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+export {
+  DevelopmentInvalidationService
+};

package/src/services/module-loading/app-module-loader.service.d.ts

@@ -0,0 +1,7 @@
+import type { PageModuleBuildImportOptions } from './page-module-import.service.js';
+export type AppModuleLoaderOwner = 'app' | 'host';
+export interface AppModuleLoader {
+    readonly owner: AppModuleLoaderOwner;
+    importModule<T = unknown>(options: PageModuleBuildImportOptions): Promise<T>;
+    invalidateDevelopmentGraph(): void;
+}

package/src/services/module-loading/app-server-module-transpiler.service.d.ts

@@ -0,0 +1,24 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import { type AppModuleLoader } from './app-module-loader.service.js';
+import type { SourceModuleLoader } from './module-loading-types.js';
+import { ServerModuleTranspiler } from './server-module-transpiler.service.js';
+export declare function shouldAppUseHostModuleLoader(appConfig: EcoPagesAppConfig, filePath: string): boolean;
+export declare function getAppHostModuleLoader(appConfig: EcoPagesAppConfig): SourceModuleLoader | undefined;
+export declare function setAppHostModuleLoader(appConfig: EcoPagesAppConfig, hostModuleLoader?: SourceModuleLoader): void;
+export declare function createAppModuleLoader(appConfig: EcoPagesAppConfig): AppModuleLoader;
+export declare function getAppModuleLoader(appConfig: EcoPagesAppConfig): AppModuleLoader;
+export declare function setAppModuleLoader(appConfig: EcoPagesAppConfig, appModuleLoader: AppModuleLoader): void;
+/**
+ * Creates the shared app-scoped server-module transpiler for one runtime
+ * instance.
+ */
+export declare function createAppServerModuleTranspiler(appConfig: EcoPagesAppConfig): ServerModuleTranspiler;
+/**
+ * Returns the app-owned server-module transpiler, creating it lazily when the
+ * runtime first needs one.
+ */
+export declare function getAppServerModuleTranspiler(appConfig: EcoPagesAppConfig): ServerModuleTranspiler;
+/**
+ * Installs the server-module transpiler that should serve one app instance.
+ */
+export declare function setAppServerModuleTranspiler(appConfig: EcoPagesAppConfig, serverModuleTranspiler: ServerModuleTranspiler): void;

package/src/services/module-loading/app-server-module-transpiler.service.js

@@ -0,0 +1,130 @@
+import { getAppBuildExecutor, getAppServerBuildPlugins } from "../../build/build-adapter.js";
+import { createForeignJsxOverridePlugin } from "../../plugins/foreign-jsx-override-plugin.js";
+import path from "node:path";
+import { DevelopmentInvalidationService } from "../invalidation/development-invalidation.service.js";
+import {} from "./app-module-loader.service.js";
+import { PageModuleImportService } from "./page-module-import.service.js";
+import { supportsSourceModuleLoading } from "./source-module-support.js";
+import { ServerModuleTranspiler } from "./server-module-transpiler.service.js";
+function shouldAppUseHostModuleLoader(appConfig, filePath) {
+  if (appConfig.runtime?.hostModuleLoader) {
+    return supportsSourceModuleLoading(filePath);
+  }
+  const normalizedFilePath = path.normalize(filePath);
+  const frameworkOwnedDirectories = [
+    appConfig.absolutePaths.pagesDir,
+    appConfig.absolutePaths.includesDir,
+    appConfig.absolutePaths.layoutsDir,
+    appConfig.absolutePaths.componentsDir
+  ].map((directoryPath) => path.normalize(directoryPath));
+  const isFrameworkOwnedModule = frameworkOwnedDirectories.some((directoryPath) => {
+    return normalizedFilePath === directoryPath || normalizedFilePath.startsWith(`${directoryPath}${path.sep}`);
+  });
+  const isConfiguredTemplateModule = appConfig.templatesExt.some(
+    (extension) => normalizedFilePath.endsWith(extension)
+  );
+  return !(isFrameworkOwnedModule && isConfiguredTemplateModule);
+}
+function getAppHostModuleLoader(appConfig) {
+  return appConfig.runtime?.hostModuleLoader;
+}
+function getAppModuleLoaderOwner(appConfig) {
+  return getAppHostModuleLoader(appConfig) ? "host" : "app";
+}
+function setAppHostModuleLoader(appConfig, hostModuleLoader) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    hostModuleLoader
+  };
+}
+function getJsxOwnershipPlugins(appConfig) {
+  const jsxExtensions = (appConfig.integrations ?? []).filter((integration) => integration.jsxImportSource).flatMap(
+    (integration) => integration.extensions.filter((extension) => extension.endsWith(".tsx") || extension.endsWith(".jsx")).map((extension) => ({ integration, extension }))
+  ).sort((left, right) => right.extension.length - left.extension.length);
+  return jsxExtensions.map(
+    ({ integration, extension }) => createForeignJsxOverridePlugin({
+      hostJsxImportSource: integration.jsxImportSource,
+      foreignExtensions: [extension],
+      excludeExtensions: jsxExtensions.filter((candidate) => candidate.extension.length > extension.length).filter((candidate) => candidate.extension.endsWith(extension)).map((candidate) => candidate.extension),
+      name: `ecopages-jsx-ownership-${integration.name}-${extension.replace(/[^a-zA-Z0-9]+/g, "-")}`
+    })
+  );
+}
+function createAppModuleLoader(appConfig) {
+  const invalidationService = new DevelopmentInvalidationService(appConfig);
+  const pageModuleImportService = new PageModuleImportService({
+    canLoadSourceModuleFromHost: (filePath) => shouldAppUseHostModuleLoader(appConfig, filePath),
+    getHostModuleLoader: () => getAppHostModuleLoader(appConfig)
+  });
+  const appServerBuildPlugins = appConfig.runtime?.buildManifest ? getAppServerBuildPlugins(appConfig) : Array.from(appConfig.loaders?.values() ?? []);
+  const jsxOwnershipPlugins = getJsxOwnershipPlugins(appConfig);
+  const appModuleLoader = {
+    get owner() {
+      return getAppModuleLoaderOwner(appConfig);
+    },
+    pageModuleImportService,
+    async importModule(options) {
+      const invalidationVersion = options.invalidationVersion ?? invalidationService.getServerModuleInvalidationVersion();
+      const mergedPlugins = [...appServerBuildPlugins, ...jsxOwnershipPlugins, ...options.plugins ?? []];
+      return await pageModuleImportService.importModule({
+        ...options,
+        ...mergedPlugins.length > 0 ? { plugins: mergedPlugins } : {},
+        buildExecutor: options.buildExecutor ?? getAppBuildExecutor(appConfig),
+        invalidationVersion
+      });
+    },
+    invalidateDevelopmentGraph() {
+      pageModuleImportService.invalidateDevelopmentGraph();
+    }
+  };
+  return appModuleLoader;
+}
+function getAppModuleLoader(appConfig) {
+  const existingModuleLoader = appConfig.runtime?.appModuleLoader;
+  if (existingModuleLoader) {
+    return existingModuleLoader;
+  }
+  const appModuleLoader = createAppModuleLoader(appConfig);
+  setAppModuleLoader(appConfig, appModuleLoader);
+  return appModuleLoader;
+}
+function setAppModuleLoader(appConfig, appModuleLoader) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    appModuleLoader
+  };
+}
+function createAppServerModuleTranspiler(appConfig) {
+  const invalidationService = new DevelopmentInvalidationService(appConfig);
+  return new ServerModuleTranspiler({
+    rootDir: appConfig.rootDir,
+    invalidateModules: (changedFiles) => invalidationService.invalidateServerModules(changedFiles),
+    pageModuleImportService: getAppModuleLoader(appConfig)
+  });
+}
+function getAppServerModuleTranspiler(appConfig) {
+  const existingTranspiler = appConfig.runtime?.serverModuleTranspiler;
+  if (existingTranspiler) {
+    return existingTranspiler;
+  }
+  const serverModuleTranspiler = createAppServerModuleTranspiler(appConfig);
+  setAppServerModuleTranspiler(appConfig, serverModuleTranspiler);
+  return serverModuleTranspiler;
+}
+function setAppServerModuleTranspiler(appConfig, serverModuleTranspiler) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    serverModuleTranspiler
+  };
+}
+export {
+  createAppModuleLoader,
+  createAppServerModuleTranspiler,
+  getAppHostModuleLoader,
+  getAppModuleLoader,
+  getAppServerModuleTranspiler,
+  setAppHostModuleLoader,
+  setAppModuleLoader,
+  setAppServerModuleTranspiler,
+  shouldAppUseHostModuleLoader
+};

package/src/services/module-loading/host-module-loader-registry.d.ts

@@ -0,0 +1,4 @@
+import type { SourceModuleLoader } from './module-loading-types.js';
+export declare function setHostModuleLoader(loader: SourceModuleLoader): void;
+export declare function getHostModuleLoader(): SourceModuleLoader | undefined;
+export declare function clearHostModuleLoader(): void;

package/src/services/module-loading/host-module-loader-registry.js

@@ -0,0 +1,15 @@
+let hostModuleLoader;
+function setHostModuleLoader(loader) {
+  hostModuleLoader = loader;
+}
+function getHostModuleLoader() {
+  return hostModuleLoader;
+}
+function clearHostModuleLoader() {
+  hostModuleLoader = void 0;
+}
+export {
+  clearHostModuleLoader,
+  getHostModuleLoader,
+  setHostModuleLoader
+};

package/src/services/module-loading/{module-loading-types.ts → module-loading-types.d.ts}

@@ -1,3 +1,2 @@
 export type SourceModuleLoader = (id: string) => Promise<unknown>;
-
 export type SourceModuleLoaderFactory = () => SourceModuleLoader | undefined;

package/src/services/module-loading/page-module-import.service.d.ts

@@ -0,0 +1,95 @@
+import { build, type BuildExecutor, type BuildResult } from '../../build/build-adapter.js';
+import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { SourceModuleLoaderFactory } from './module-loading-types.js';
+interface PageModuleImportBaseOptions {
+    filePath: string;
+    bypassCache?: boolean;
+    cacheScope?: string;
+    invalidationVersion?: number;
+}
+/**
+ * Options for imports that must pass through the Ecopages build pipeline.
+ *
+ * @remarks
+ * Callers should use build mode for framework-owned page modules and any other
+ * source that relies on Ecopages build resolution before runtime execution.
+ */
+export interface PageModuleBuildImportOptions extends PageModuleImportBaseOptions {
+    rootDir: string;
+    outdir: string;
+    buildExecutor?: BuildExecutor;
+    splitting?: boolean;
+    externalPackages?: boolean;
+    jsx?: {
+        development?: boolean;
+        factory?: string;
+        fragment?: string;
+        importSource?: string;
+        runtime?: 'classic' | 'automatic';
+        sideEffects?: boolean;
+    };
+    plugins?: EcoBuildPlugin[];
+    transpileErrorMessage?: (details: string) => string;
+    noOutputMessage?: (filePath: string) => string;
+}
+/**
+ * Minimal runtime dependencies required to load page modules.
+ *
+ * @remarks
+ * This service owns cache and runtime import policy. Hashing and build
+ * execution are injected so tests can provide explicit fakes without module
+ * interception.
+ */
+export interface PageModuleImportDependencies {
+    hashFile(filePath: string): string;
+    buildModule(options: Parameters<typeof build>[0], buildExecutor?: BuildExecutor): Promise<BuildResult>;
+    canLoadSourceModuleFromHost(filePath: string): boolean;
+    getHostModuleLoader: SourceModuleLoaderFactory;
+}
+/**
+ * Loads page-like modules through the Ecopages build pipeline.
+ *
+ * This service centralizes the shared build-first import strategy used by route
+ * scanning, page data loading, and request-time page inspection. In Node
+ * development it can still delegate compatible source imports to the active
+ * host loader, but the public contract remains one transpile-targeted module
+ * loading path.
+ *
+ * Keeping this logic in one place prevents subtle drift in cache-busting,
+ * transpilation settings, and error semantics across the different callers.
+ */
+export declare class PageModuleImportService {
+    private readonly dependencies;
+    private readonly importCache;
+    private developmentInvalidationVersion;
+    constructor(dependencies?: Partial<PageModuleImportDependencies>);
+    /**
+     * Clears the shared import cache used by framework-owned page-module loads.
+     */
+    clearImportCache(): void;
+    /**
+     * Invalidates all previously imported modules in development by clearing the
+     * import cache and incrementing the invalidation version included in cache keys.
+     *
+     * This forces all modules to be reloaded on the next import, even if their
+     * source content hasn't changed. This is necessary to ensure that changes to
+     * non-content aspects of modules (e.g. dependencies, transpilation output)
+     * are picked up during development.
+     */
+    invalidateDevelopmentGraph(): void;
+    /**
+     * Imports a page-like module from source.
+     *
+     * The caller controls the output directory and error wording so different
+     * subsystems can reuse the same loading mechanism while preserving their
+     * current diagnostics. Module identities stay stable for unchanged files and
+     * roll forward automatically when the source hash changes during watch mode.
+     *
+     * @typeParam T Expected module shape.
+     * @param options Runtime-specific import settings.
+     * @returns The loaded module.
+     */
+    importModule<T = unknown>(options: PageModuleBuildImportOptions): Promise<T>;
+    private loadModule;
+}
+export {};

package/src/services/module-loading/page-module-import.service.js

@@ -0,0 +1,193 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fileSystem } from "@ecopages/file-system";
+import { build } from "../../build/build-adapter.js";
+import { normalizeNodeRuntimeBuildOutputFile } from "../../build/runtime-build-output-normalizer.js";
+import { supportsSourceModuleLoading } from "./source-module-support.js";
+class PageModuleImportService {
+  dependencies;
+  importCache = /* @__PURE__ */ new Map();
+  developmentInvalidationVersion = 0;
+  constructor(dependencies) {
+    this.dependencies = {
+      hashFile: dependencies?.hashFile ?? ((filePath) => fileSystem.hash(filePath)),
+      buildModule: dependencies?.buildModule ?? ((options, buildExecutor) => build(options, buildExecutor)),
+      canLoadSourceModuleFromHost: dependencies?.canLoadSourceModuleFromHost ?? supportsSourceModuleLoading,
+      getHostModuleLoader: dependencies?.getHostModuleLoader ?? (() => void 0)
+    };
+  }
+  /**
+   * Clears the shared import cache used by framework-owned page-module loads.
+   */
+  clearImportCache() {
+    this.importCache.clear();
+  }
+  /**
+   * Invalidates all previously imported modules in development by clearing the
+   * import cache and incrementing the invalidation version included in cache keys.
+   *
+   * This forces all modules to be reloaded on the next import, even if their
+   * source content hasn't changed. This is necessary to ensure that changes to
+   * non-content aspects of modules (e.g. dependencies, transpilation output)
+   * are picked up during development.
+   */
+  invalidateDevelopmentGraph() {
+    this.clearImportCache();
+    this.developmentInvalidationVersion += 1;
+  }
+  /**
+   * Imports a page-like module from source.
+   *
+   * The caller controls the output directory and error wording so different
+   * subsystems can reuse the same loading mechanism while preserving their
+   * current diagnostics. Module identities stay stable for unchanged files and
+   * roll forward automatically when the source hash changes during watch mode.
+   *
+   * @typeParam T Expected module shape.
+   * @param options Runtime-specific import settings.
+   * @returns The loaded module.
+   */
+  async importModule(options) {
+    const { filePath } = options;
+    const invalidationVersion = options.invalidationVersion ?? this.developmentInvalidationVersion;
+    const { externalPackages, splitting } = options;
+    const fileHash = this.dependencies.hashFile(filePath);
+    const hostModuleLoader = typeof Bun === "undefined" && process.env.NODE_ENV === "development" && this.dependencies.canLoadSourceModuleFromHost(filePath) ? this.dependencies.getHostModuleLoader() : void 0;
+    if (hostModuleLoader) {
+      const sourceModuleUrl = createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, options.cacheScope);
+      return await hostModuleLoader(sourceModuleUrl.href);
+    }
+    if (options.bypassCache) {
+      this.developmentInvalidationVersion += 1;
+      return await this.loadModule({
+        ...options,
+        invalidationVersion: this.developmentInvalidationVersion,
+        fileHash
+      });
+    }
+    const runtime = typeof Bun !== "undefined" ? "bun" : "node-build";
+    const cacheKey = [
+      runtime,
+      filePath,
+      options.rootDir,
+      splitting ?? "default",
+      externalPackages ?? "default",
+      options.cacheScope ?? "default",
+      createJsxCacheKey(options.jsx),
+      createPluginCacheKey(options.plugins),
+      fileHash,
+      invalidationVersion
+    ].join("::");
+    const cachedModule = this.importCache.get(cacheKey);
+    if (cachedModule) {
+      return await cachedModule;
+    }
+    const importPromise = this.loadModule({
+      ...options,
+      fileHash
+    });
+    this.importCache.set(cacheKey, importPromise);
+    try {
+      return await importPromise;
+    } catch (error) {
+      this.importCache.delete(cacheKey);
+      throw error;
+    }
+  }
+  async loadModule(options) {
+    const { filePath, invalidationVersion = this.developmentInvalidationVersion, cacheScope, fileHash } = options;
+    const {
+      rootDir,
+      outdir,
+      splitting,
+      externalPackages,
+      transpileErrorMessage = (details) => `Error transpiling page module: ${details}`,
+      noOutputMessage = (targetFilePath) => `No transpiled output generated for page module: ${targetFilePath}`
+    } = options;
+    const fileBaseName = path.basename(filePath, path.extname(filePath));
+    const cacheScopeSuffix = cacheScope ? `-${sanitizeCacheScope(cacheScope)}` : "";
+    const invalidationSuffix = shouldVersionBuildOutputPath(invalidationVersion) ? `-v${invalidationVersion}` : "";
+    const outputFileName = `${fileBaseName}-${fileHash}${cacheScopeSuffix}${invalidationSuffix}.mjs`;
+    const outputNamingTemplate = `${fileBaseName}-${fileHash}${cacheScopeSuffix}${invalidationSuffix}.[ext]`;
+    const buildResult = await this.dependencies.buildModule(
+      {
+        entrypoints: [filePath],
+        root: rootDir,
+        outdir,
+        target: "es2022",
+        format: "esm",
+        sourcemap: "none",
+        splitting: splitting ?? true,
+        minify: false,
+        naming: outputNamingTemplate,
+        externalPackages: true,
+        jsx: options.jsx,
+        plugins: options.plugins,
+        ...externalPackages !== void 0 ? { externalPackages } : {}
+      },
+      options.buildExecutor
+    );
+    if (!buildResult.success) {
+      const details = buildResult.logs.map((log) => log.message).join(" | ");
+      throw new Error(transpileErrorMessage(details));
+    }
+    const preferredOutputPath = path.join(outdir, outputFileName);
+    const compiledOutput = buildResult.outputs.find((output) => output.path === preferredOutputPath)?.path ?? buildResult.outputs.find((output) => /\.(?:[cm]?js)$/u.test(output.path))?.path;
+    if (!compiledOutput) {
+      throw new Error(noOutputMessage(filePath));
+    }
+    normalizeNodeRuntimeBuildOutputFile(compiledOutput, rootDir);
+    const compiledOutputUrl = pathToFileURL(compiledOutput);
+    if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
+      compiledOutputUrl.searchParams.set(
+        "update",
+        [fileHash, invalidationVersion, cacheScope ? sanitizeCacheScope(cacheScope) : void 0].filter((value) => value !== void 0).join("-")
+      );
+    }
+    return await import(
+      /* @vite-ignore */
+      compiledOutputUrl.href
+    );
+  }
+}
+function createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, cacheScope) {
+  const moduleUrl = pathToFileURL(filePath);
+  if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
+    moduleUrl.searchParams.set(
+      "update",
+      [fileHash, invalidationVersion, cacheScope ? sanitizeCacheScope(cacheScope) : void 0].filter((value) => value !== void 0).join("-")
+    );
+  }
+  return moduleUrl;
+}
+function shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope) {
+  return process.env.NODE_ENV === "development" || invalidationVersion > 0 || !!cacheScope;
+}
+function shouldVersionBuildOutputPath(invalidationVersion) {
+  return typeof Bun !== "undefined" && invalidationVersion > 0;
+}
+function sanitizeCacheScope(cacheScope) {
+  return cacheScope.replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function createJsxCacheKey(jsx) {
+  if (!jsx) {
+    return "jsx:default";
+  }
+  return JSON.stringify({
+    development: jsx.development ?? false,
+    factory: jsx.factory ?? null,
+    fragment: jsx.fragment ?? null,
+    importSource: jsx.importSource ?? null,
+    runtime: jsx.runtime ?? null,
+    sideEffects: jsx.sideEffects ?? null
+  });
+}
+function createPluginCacheKey(plugins) {
+  if (!plugins || plugins.length === 0) {
+    return "plugins:default";
+  }
+  return `plugins:${plugins.map((plugin) => plugin.name).join(",")}`;
+}
+export {
+  PageModuleImportService
+};