@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.27

package/src/route-renderer/page-loading/ecopages-virtual-imports.js

@@ -1,57 +0,0 @@
-import { readFileSync } from "node:fs";
-import { parseSync } from "oxc-parser";
-function extractEcopagesVirtualImports(file) {
-  let source;
-  try {
-    source = readFileSync(file, "utf-8");
-  } catch {
-    return [];
-  }
-  let result;
-  try {
-    result = parseSync(file, source, { sourceType: "module" });
-  } catch {
-    return [];
-  }
-  const found = /* @__PURE__ */ new Map();
-  for (const node of result.program.body ?? []) {
-    if (node.type !== "ImportDeclaration") continue;
-    if (node.importKind === "type") continue;
-    const specifier = node.source?.value ?? "";
-    if (!specifier.startsWith("ecopages:")) continue;
-    if (found.get(specifier) === null) {
-      continue;
-    }
-    const namedImports = [];
-    for (const spec of node.specifiers ?? []) {
-      if (spec.type === "ImportSpecifier") {
-        let importedName = spec.local?.name;
-        if (spec.imported?.type === "Identifier") {
-          importedName = spec.imported.name;
-        } else if (spec.imported?.type === "Literal") {
-          importedName = spec.imported.value;
-        }
-        namedImports.push(importedName);
-      }
-    }
-    if (namedImports.length === 0) {
-      found.set(specifier, null);
-      continue;
-    }
-    const existing = found.get(specifier);
-    if (!existing) {
-      found.set(specifier, new Set(namedImports));
-      continue;
-    }
-    for (const imported of namedImports) {
-      existing.add(imported);
-    }
-  }
-  return Array.from(found.entries()).map(([from, importsSet]) => ({
-    from,
-    imports: importsSet ? Array.from(importsSet) : void 0
-  }));
-}
-export {
-  extractEcopagesVirtualImports
-};

package/src/route-renderer/page-loading/lazy-entry-collection.d.ts

@@ -1,45 +0,0 @@
-import type { DependencyLazyTrigger, EcoComponentScriptEntry } from '../../types/public-types.js';
-import type { AssetDefinition } from '../../services/assets/asset-processing-service/index.js';
-type LazyScriptRef = {
-    lazyKey: string;
-    fallbackUrl?: string;
-};
-/**
- * Lazy scripts grouped by one trigger declaration.
- */
-export type LazyGroup = {
-    lazy: DependencyLazyTrigger;
-    scripts: LazyScriptRef[];
-};
-/**
- * Callback used to record one normalized lazy-script registration.
- */
-export type RegisterLazyScript = (input: {
-    lazy: DependencyLazyTrigger;
-    lazyKey: string;
-    fallbackUrl?: string;
-}) => void;
-type CollectLazyEntriesOptions = {
-    scriptEntries: Array<string | EcoComponentScriptEntry>;
-    componentFile: string;
-    componentDir: string;
-    integrationName: string;
-    dependencies: AssetDefinition[];
-    lazyDependencyKeys: Set<string>;
-    registerLazyScript: RegisterLazyScript;
-    resolveDependencyPath: (componentDir: string, pathUrl: string) => string;
-    resolveLazyScripts: (componentDir: string, scripts: string[]) => string;
-    createModuleScriptAttributes: (attributes?: Record<string, string>) => Record<string, string>;
-    createEcopagesJsxLazyEntryName: (integrationName: string, key: string) => string;
-    pushUniqueDependency: (keys: Set<string>, key: string, dependencies: AssetDefinition[], dependency: AssetDefinition) => boolean;
-    getLazyScriptMissingSrcMessage: () => string;
-    isEcopagesJsxIntegration: (integrationName: string) => boolean;
-};
-/**
- * Collects lazy script dependency entries and emits their hidden bundle inputs.
- *
- * This helper also reports the trigger-to-script relationship back to the caller so
- * later stages can build the lazy-trigger manifest without reparsing dependency config.
- */
-export declare function collectLazyScriptEntries(options: CollectLazyEntriesOptions): void;
-export {};

package/src/route-renderer/page-loading/lazy-entry-collection.js

@@ -1,105 +0,0 @@
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { rapidhash } from "../../utils/hash.js";
-import { getLazyTriggerKey } from "./lazy-trigger-planning.js";
-function isDependencyEntryObject(entry) {
-  return typeof entry === "object" && entry !== null;
-}
-function getDependencyEntrySrcOrThrow(entry, errorMessage) {
-  if (!entry.src) {
-    throw new Error(errorMessage);
-  }
-  return entry.src;
-}
-function collectLazyScriptEntries(options) {
-  const {
-    scriptEntries,
-    componentFile,
-    componentDir,
-    integrationName,
-    dependencies,
-    lazyDependencyKeys,
-    registerLazyScript,
-    resolveDependencyPath,
-    resolveLazyScripts,
-    createModuleScriptAttributes,
-    createEcopagesJsxLazyEntryName,
-    pushUniqueDependency,
-    getLazyScriptMissingSrcMessage,
-    isEcopagesJsxIntegration
-  } = options;
-  for (const [index, scriptEntry] of scriptEntries.entries()) {
-    if (!isDependencyEntryObject(scriptEntry) || !scriptEntry.lazy) {
-      continue;
-    }
-    const lazy = scriptEntry.lazy;
-    const content = scriptEntry.content;
-    const src = scriptEntry.src;
-    const attributes = scriptEntry.attributes;
-    if (content) {
-      const lazyKey2 = `lazy:${rapidhash(`${componentFile}:entry:${index}:${content}`).toString(16)}`;
-      const depKey2 = `lazy:entry:content:${getLazyTriggerKey(lazy)}:${content}:${JSON.stringify(attributes ?? {})}`;
-      pushUniqueDependency(
-        lazyDependencyKeys,
-        depKey2,
-        dependencies,
-        AssetFactory.createContentScript({
-          position: "head",
-          content,
-          excludeFromHtml: true,
-          attributes: {
-            ...createModuleScriptAttributes(attributes),
-            "data-eco-lazy-key": lazyKey2
-          }
-        })
-      );
-      registerLazyScript({
-        lazy,
-        lazyKey: lazyKey2
-      });
-      continue;
-    }
-    const script = src ?? getDependencyEntrySrcOrThrow(scriptEntry, getLazyScriptMissingSrcMessage());
-    const resolvedPath = resolveDependencyPath(componentDir, script);
-    const fallbackUrl = resolveLazyScripts(componentDir, [script]).split(",")[0] ?? "";
-    const lazyKey = `lazy:${rapidhash(`${resolvedPath}:${getLazyTriggerKey(lazy)}`).toString(16)}`;
-    const lazyEntryName = createEcopagesJsxLazyEntryName(
-      integrationName,
-      `${resolvedPath}:${getLazyTriggerKey(lazy)}`
-    );
-    const depKey = `lazy:entry:file:${getLazyTriggerKey(lazy)}:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-    pushUniqueDependency(
-      lazyDependencyKeys,
-      depKey,
-      dependencies,
-      isEcopagesJsxIntegration(integrationName) ? AssetFactory.createContentScript({
-        name: lazyEntryName,
-        position: "head",
-        content: `import ${JSON.stringify(resolvedPath)};`,
-        excludeFromHtml: true,
-        bundleOptions: {
-          splitting: false
-        },
-        attributes: {
-          ...createModuleScriptAttributes(attributes),
-          "data-eco-lazy-key": lazyKey
-        }
-      }) : AssetFactory.createFileScript({
-        filepath: resolvedPath,
-        position: "head",
-        excludeFromHtml: true,
-        attributes: {
-          ...createModuleScriptAttributes(attributes),
-          "data-eco-lazy-key": lazyKey
-        }
-      })
-    );
-    registerLazyScript({
-      lazy,
-      lazyKey,
-      fallbackUrl
-    });
-  }
-}
-export {
-  collectLazyScriptEntries
-};

package/src/route-renderer/page-loading/lazy-trigger-planning.d.ts

@@ -1,19 +0,0 @@
-import type { DependencyLazyTrigger, EcoComponent, ResolvedLazyTrigger } from '../../types/public-types.js';
-/**
- * Lazy scripts already normalized onto one trigger and concrete script URL set.
- */
-export type ResolvedLazyGroup = {
-    lazy: DependencyLazyTrigger;
-    scripts: string[];
-};
-/**
- * Creates a stable grouping key for a lazy trigger declaration.
- */
-export declare function getLazyTriggerKey(lazy: DependencyLazyTrigger): string;
-/**
- * Derives the public lazy-trigger manifest attached to a component config.
- *
- * The generated `triggerId` is stable for the same component file and set of
- * resolved script URLs, independent of declaration order.
- */
-export declare function buildResolvedLazyTriggers(config: NonNullable<EcoComponent['config']>, groups: ResolvedLazyGroup[]): ResolvedLazyTrigger[];

package/src/route-renderer/page-loading/lazy-trigger-planning.js

@@ -1,40 +0,0 @@
-import { rapidhash } from "../../utils/hash.js";
-function getLazyTriggerKey(lazy) {
-  if ("on:idle" in lazy) {
-    return "on:idle";
-  }
-  if ("on:interaction" in lazy) {
-    return `on:interaction:${lazy["on:interaction"]}`;
-  }
-  if ("on:visible" in lazy) {
-    const value = lazy["on:visible"];
-    return `on:visible:${value === true ? "true" : value}`;
-  }
-  return JSON.stringify(lazy);
-}
-function buildResolvedLazyTriggers(config, groups) {
-  if (groups.length === 0) return [];
-  const componentFile = config.__eco?.file ?? "";
-  const sortedUrls = groups.flatMap((group) => group.scripts).sort().join(",");
-  const triggerId = `eco-trigger-${rapidhash(`${componentFile}:${sortedUrls}`).toString(16)}`;
-  const rules = groups.map((group) => {
-    const { scripts, lazy } = group;
-    if ("on:idle" in lazy) {
-      return { "on:idle": { scripts } };
-    }
-    if ("on:interaction" in lazy) {
-      return { "on:interaction": { value: lazy["on:interaction"], scripts } };
-    }
-    if ("on:visible" in lazy) {
-      const visibleSelector = lazy["on:visible"];
-      if (visibleSelector === true) return { "on:visible": { scripts } };
-      return { "on:visible": { value: String(visibleSelector), scripts } };
-    }
-    throw new Error(`Unknown lazy trigger kind: ${JSON.stringify(lazy)}`);
-  });
-  return [{ triggerId, rules }];
-}
-export {
-  buildResolvedLazyTriggers,
-  getLazyTriggerKey
-};

package/src/route-renderer/page-loading/module-declaration-aggregation.d.ts

@@ -1,5 +0,0 @@
-import type { EcopagesVirtualImport } from './ecopages-virtual-imports.js';
-/**
- * Combines explicit config module declarations with auto-detected `ecopages:` imports.
- */
-export declare function collectModuleDeclarations(modulesMap: Map<string, Set<string> | null>, declaredModules: unknown, autoVirtualImports: EcopagesVirtualImport[]): void;

package/src/route-renderer/page-loading/module-declaration-aggregation.js

@@ -1,33 +0,0 @@
-import { normalizeModuleDeclarations } from "../../eco/module-dependencies.js";
-function getDeclaredModules(value) {
-  if (!Array.isArray(value)) {
-    return void 0;
-  }
-  return value.every((entry) => typeof entry === "string") ? value : void 0;
-}
-function mergeModuleDeclaration(modulesMap, declaration) {
-  const existing = modulesMap.get(declaration.from);
-  if (!declaration.imports || declaration.imports.length === 0) {
-    modulesMap.set(declaration.from, null);
-    return;
-  }
-  if (existing === null) {
-    return;
-  }
-  const merged = existing ?? /* @__PURE__ */ new Set();
-  for (const imported of declaration.imports) {
-    merged.add(imported);
-  }
-  modulesMap.set(declaration.from, merged);
-}
-function collectModuleDeclarations(modulesMap, declaredModules, autoVirtualImports) {
-  for (const declaration of normalizeModuleDeclarations(getDeclaredModules(declaredModules))) {
-    mergeModuleDeclaration(modulesMap, declaration);
-  }
-  for (const declaration of autoVirtualImports) {
-    mergeModuleDeclaration(modulesMap, declaration);
-  }
-}
-export {
-  collectModuleDeclarations
-};

package/src/route-renderer/page-loading/module-declaration-scripts.d.ts

@@ -1,3 +0,0 @@
-export declare function createModuleScriptName(from: string, imports: string[] | undefined): string;
-export declare function createNamedImportModuleSource(from: string, imports: string[]): string;
-export declare function createNamespaceImportModuleSource(from: string): string;

package/src/route-renderer/page-loading/module-declaration-scripts.js

@@ -1,18 +0,0 @@
-import { rapidhash } from "../../utils/hash.js";
-function createModuleScriptName(from, imports) {
-  const normalizedImports = imports ? [...imports].sort().join(",") : "*";
-  const hash = rapidhash(`${from}|${normalizedImports}`).toString(16);
-  return `module-${hash}`;
-}
-function createNamedImportModuleSource(from, imports) {
-  const namedImports = [...new Set(imports)].sort().join(", ");
-  return `export { ${namedImports} } from '${from}';`;
-}
-function createNamespaceImportModuleSource(from) {
-  return `export * from '${from}';`;
-}
-export {
-  createModuleScriptName,
-  createNamedImportModuleSource,
-  createNamespaceImportModuleSource
-};

package/src/route-renderer/page-loading/page-dependency-bundling.d.ts

@@ -1,13 +0,0 @@
-import type { AssetDefinition } from '../../services/assets/asset-processing-service/index.js';
-/**
- * Returns whether the current integration should collapse eligible page assets into
- * page-owned bundle entries.
- */
-export declare function shouldBundlePageDependencies(integrationName: string): boolean;
-/**
- * Rewrites eligible flat dependency declarations into page-owned stylesheet and script bundles.
- *
- * Only assets with the default attribute shape and without explicit packaging roles are
- * collapsed so integration-specific or lazy behavior keeps its existing ownership model.
- */
-export declare function createUnifiedPageDependencies(dependencies: AssetDefinition[], integrationName: string): AssetDefinition[];

package/src/route-renderer/page-loading/page-dependency-bundling.js

@@ -1,115 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { rapidhash } from "../../utils/hash.js";
-function hasOnlyExpectedAttributes(attributes, expected) {
-  const keys = Object.keys(attributes ?? {});
-  const expectedKeys = Object.keys(expected);
-  if (keys.length !== expectedKeys.length) {
-    return false;
-  }
-  return expectedKeys.every((key) => attributes?.[key] === expected[key]);
-}
-function isSafeBundledStylesheetReference(reference) {
-  return reference.startsWith("/") || reference.startsWith("data:") || reference.startsWith("http://") || reference.startsWith("https://") || reference.startsWith("#");
-}
-function normalizeCssReferenceToken(token) {
-  return token.trim().replace(/^['"]|['"]$/g, "");
-}
-function isSafeBundledStylesheetContent(content) {
-  for (const match of content.matchAll(/@import\s+(?:url\()?['"]?([^'"\)\s]+)['"]?\)?/g)) {
-    const reference = normalizeCssReferenceToken(match[1] ?? "");
-    if (reference && !isSafeBundledStylesheetReference(reference)) {
-      return false;
-    }
-  }
-  for (const match of content.matchAll(/url\(([^)]+)\)/g)) {
-    const reference = normalizeCssReferenceToken(match[1] ?? "");
-    if (reference && !isSafeBundledStylesheetReference(reference)) {
-      return false;
-    }
-  }
-  return true;
-}
-function isBundleableFileStylesheetAsset(dependency) {
-  return dependency.kind === "stylesheet" && dependency.source === "file";
-}
-function isBundleableFileScriptAsset(dependency) {
-  return dependency.kind === "script" && dependency.source === "file";
-}
-function shouldBundlePageDependencies(integrationName) {
-  return integrationName === "react" || integrationName === "ecopages-jsx";
-}
-function createUnifiedPageDependencies(dependencies, integrationName) {
-  if (!shouldBundlePageDependencies(integrationName)) {
-    return dependencies;
-  }
-  const bundleableStyles = dependencies.filter((dependency) => {
-    if (dependency.kind !== "stylesheet" || dependency.inline || dependency.position === "body") {
-      return false;
-    }
-    if (dependency.packageRole || !hasOnlyExpectedAttributes(dependency.attributes, { rel: "stylesheet" })) {
-      return false;
-    }
-    if (dependency.source === "content") {
-      return isSafeBundledStylesheetContent(dependency.content);
-    }
-    if (!existsSync(dependency.filepath)) {
-      return false;
-    }
-    return isSafeBundledStylesheetContent(readFileSync(dependency.filepath, "utf8"));
-  }).filter(isBundleableFileStylesheetAsset);
-  const bundleableScripts = dependencies.filter((dependency) => {
-    return dependency.kind === "script" && dependency.source === "file" && !dependency.inline && !dependency.excludeFromHtml && dependency.position !== "body" && !dependency.packageRole && dependency.bundle !== false && hasOnlyExpectedAttributes(dependency.attributes, { type: "module", defer: "" }) && existsSync(dependency.filepath);
-  }).filter(isBundleableFileScriptAsset);
-  const bundledStylesheet = bundleableStyles.length > 1 ? AssetFactory.createContentStylesheet({
-    content: bundleableStyles.map((dependency) => readFileSync(dependency.filepath, "utf8")).join("\n"),
-    position: "head",
-    attributes: { rel: "stylesheet" },
-    packageRole: "page-style"
-  }) : void 0;
-  const bundleableStyleFilepaths = new Set(bundleableStyles.map((dependency) => dependency.filepath));
-  const pageScriptImports = [...new Set(bundleableScripts.map((dependency) => dependency.filepath))];
-  const bundleableScriptFilepaths = new Set(pageScriptImports);
-  const shouldBundlePageScript = pageScriptImports.length > 0 && bundleableScripts.length > 1;
-  const bundledScript = shouldBundlePageScript ? AssetFactory.createContentScript({
-    name: `${integrationName}-page-${rapidhash(pageScriptImports.join("|")).toString(16)}`,
-    content: pageScriptImports.map((filepath) => `import ${JSON.stringify(filepath)};`).join("\n"),
-    position: "head",
-    attributes: { type: "module", defer: "" },
-    packageRole: "page-script"
-  }) : void 0;
-  if (!bundledStylesheet && !bundledScript) {
-    return dependencies;
-  }
-  const unifiedDependencies = [];
-  let insertedStylesheet = false;
-  let insertedScript = false;
-  for (const dependency of dependencies) {
-    if (bundledStylesheet && dependency.kind === "stylesheet" && dependency.source === "file" && bundleableStyleFilepaths.has(dependency.filepath)) {
-      if (!insertedStylesheet) {
-        unifiedDependencies.push(bundledStylesheet);
-        insertedStylesheet = true;
-      }
-      continue;
-    }
-    if (bundledScript && dependency.kind === "script" && dependency.source === "file" && bundleableScriptFilepaths.has(dependency.filepath)) {
-      if (!insertedScript) {
-        unifiedDependencies.push(bundledScript);
-        insertedScript = true;
-      }
-      continue;
-    }
-    unifiedDependencies.push(dependency);
-  }
-  if (bundledScript && !insertedScript) {
-    unifiedDependencies.push(bundledScript);
-  }
-  if (bundledStylesheet && !insertedStylesheet) {
-    unifiedDependencies.push(bundledStylesheet);
-  }
-  return unifiedDependencies;
-}
-export {
-  createUnifiedPageDependencies,
-  shouldBundlePageDependencies
-};

package/src/route-renderer/page-loading/page-module-loader.d.ts

@@ -1,90 +0,0 @@
-import type { EcoPageFile, GetMetadata, GetMetadataContext, GetStaticProps, PageMetadataProps, RouteRendererOptions, EcoPageComponent } from '../../types/public-types.js';
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-/**
- * Loads route page modules and normalizes their data hooks for rendering.
- *
- * @remarks
- * This service keeps the render pipeline from depending directly on raw module
- * imports. It owns the shared server-module transpiler setup, the precedence
- * rules between component statics and module exports, and the normalization of
- * page props and metadata into one renderer-facing shape.
- */
-export declare class PageModuleLoaderService {
-    private appModuleLoader;
-    private appConfig;
-    private runtimeOrigin;
-    /**
-     * Creates the page-module loader for one app/runtime instance.
-     *
-     * @param appConfig Finalized app config that owns build and invalidation state.
-     * @param runtimeOrigin Runtime origin exposed to page data hooks.
-     */
-    constructor(appConfig: EcoPagesAppConfig, runtimeOrigin: string);
-    /**
-     * Imports one page module through the shared server-side module loading path.
-     *
-     * @remarks
-     * The underlying transpiler keeps Bun and Node aligned on one framework-owned
-     * loading contract even though the runtime-specific execution transport differs.
-     */
-    importPageFile(file: string, options?: {
-        bypassCache?: boolean;
-        cacheScope?: string;
-    }): Promise<EcoPageFile>;
-    /**
-     * Executes the page's static-props hook with Ecopages runtime context.
-     *
-     * @remarks
-     * Pages without a static-props hook still return a normalized empty props
-     * object so downstream render preparation does not branch on hook presence.
-     */
-    getStaticPropsForPage(options: {
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        params?: RouteRendererOptions['params'];
-    }): Promise<{
-        props: Record<string, unknown>;
-        metadata?: PageMetadataProps;
-    }>;
-    /**
-     * Builds the final page metadata object for one render request.
-     *
-     * @remarks
-     * App-level default metadata forms the baseline, then page-level metadata is
-     * overlaid so route-specific fields win without dropping global defaults.
-     */
-    getMetadataPropsForPage(options: {
-        getMetadata: GetMetadata | undefined;
-        context: GetMetadataContext;
-    }): Promise<PageMetadataProps>;
-    /**
-     * Loads a page module and normalizes integration-facing exports.
-     * When both component static methods and module exports exist, component statics win.
-     */
-    resolvePageModule(options: {
-        file: string;
-        importPageFileFn?: (file: string) => Promise<EcoPageFile>;
-    }): Promise<{
-        Page: EcoPageFile['default'] | EcoPageComponent<any>;
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-        integrationSpecificProps: Record<string, unknown>;
-    }>;
-    /**
-     * Resolves the page data needed by the render pipeline.
-     *
-     * @remarks
-     * Static props are resolved first because page metadata may depend on those
-     * props. This preserves the same ordering whether data hooks are declared as
-     * component statics or module exports.
-     */
-    resolvePageData(options: {
-        pageModule: {
-            getStaticProps?: GetStaticProps<Record<string, unknown>>;
-            getMetadata?: GetMetadata;
-        };
-        routeOptions: RouteRendererOptions;
-    }): Promise<{
-        props: Record<string, unknown>;
-        metadata: PageMetadataProps;
-    }>;
-}

package/src/route-renderer/page-loading/page-module-loader.js

@@ -1,127 +0,0 @@
-import { invariant } from "../../utils/invariant.js";
-import { getAppModuleLoader } from "../../services/module-loading/app-server-module-transpiler.service.js";
-import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
-class PageModuleLoaderService {
-  appModuleLoader;
-  appConfig;
-  runtimeOrigin;
-  /**
-   * Creates the page-module loader for one app/runtime instance.
-   *
-   * @param appConfig Finalized app config that owns build and invalidation state.
-   * @param runtimeOrigin Runtime origin exposed to page data hooks.
-   */
-  constructor(appConfig, runtimeOrigin) {
-    this.appConfig = appConfig;
-    this.runtimeOrigin = runtimeOrigin;
-    this.appModuleLoader = getAppModuleLoader(appConfig);
-  }
-  /**
-   * Imports one page module through the shared server-side module loading path.
-   *
-   * @remarks
-   * The underlying transpiler keeps Bun and Node aligned on one framework-owned
-   * loading contract even though the runtime-specific execution transport differs.
-   */
-  async importPageFile(file, options) {
-    try {
-      return await this.appModuleLoader.importModule({
-        filePath: file,
-        rootDir: this.appConfig.rootDir,
-        outdir: `${resolveInternalExecutionDir(this.appConfig)}/.server-modules`,
-        bypassCache: options?.bypassCache,
-        cacheScope: options?.cacheScope,
-        transpileErrorMessage: (details) => `Error transpiling page file: ${details}`,
-        noOutputMessage: (targetFilePath) => `No transpiled output generated for page: ${targetFilePath}`
-      });
-    } catch (error) {
-      invariant(false, `Error importing page file: ${error}`);
-    }
-  }
-  /**
-   * Executes the page's static-props hook with Ecopages runtime context.
-   *
-   * @remarks
-   * Pages without a static-props hook still return a normalized empty props
-   * object so downstream render preparation does not branch on hook presence.
-   */
-  async getStaticPropsForPage(options) {
-    const { getStaticProps, params } = options;
-    return getStaticProps ? await getStaticProps({
-      pathname: { params: params ?? {} },
-      appConfig: this.appConfig,
-      runtimeOrigin: this.runtimeOrigin
-    }).then((data) => data).catch((err) => {
-      throw new Error(`Error fetching static props: ${err.message}`);
-    }) : {
-      props: {},
-      metadata: void 0
-    };
-  }
-  /**
-   * Builds the final page metadata object for one render request.
-   *
-   * @remarks
-   * App-level default metadata forms the baseline, then page-level metadata is
-   * overlaid so route-specific fields win without dropping global defaults.
-   */
-  async getMetadataPropsForPage(options) {
-    const { getMetadata, context } = options;
-    let metadata = this.appConfig.defaultMetadata;
-    if (getMetadata) {
-      const dynamicMetadata = await getMetadata({
-        params: context.params,
-        query: context.query,
-        props: context.props,
-        appConfig: this.appConfig
-      });
-      metadata = { ...metadata, ...dynamicMetadata };
-    }
-    return metadata;
-  }
-  /**
-   * Loads a page module and normalizes integration-facing exports.
-   * When both component static methods and module exports exist, component statics win.
-   */
-  async resolvePageModule(options) {
-    const module = await (options.importPageFileFn ?? ((file) => this.importPageFile(file)))(options.file);
-    const {
-      default: Page,
-      getStaticProps: moduleGetStaticProps,
-      getMetadata: moduleGetMetadata,
-      ...integrationSpecificProps
-    } = module;
-    return {
-      Page,
-      getStaticProps: Page.staticProps ?? moduleGetStaticProps,
-      getMetadata: Page.metadata ?? moduleGetMetadata,
-      integrationSpecificProps
-    };
-  }
-  /**
-   * Resolves the page data needed by the render pipeline.
-   *
-   * @remarks
-   * Static props are resolved first because page metadata may depend on those
-   * props. This preserves the same ordering whether data hooks are declared as
-   * component statics or module exports.
-   */
-  async resolvePageData(options) {
-    const { props } = await this.getStaticPropsForPage({
-      getStaticProps: options.pageModule.getStaticProps,
-      params: options.routeOptions.params
-    });
-    const metadata = await this.getMetadataPropsForPage({
-      getMetadata: options.pageModule.getMetadata,
-      context: {
-        props,
-        params: options.routeOptions.params ?? {},
-        query: options.routeOptions.query ?? {}
-      }
-    });
-    return { props, metadata };
-  }
-}
-export {
-  PageModuleLoaderService
-};