@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.41

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

@@ -1,137 +1,180 @@
-import { existsSync, readFileSync } from "node:fs";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { rapidhash } from "../../utils/hash.js";
+import { existsSync, readFileSync } from 'node:fs';
+import { AssetFactory } from '../../services/assets/asset-processing-service/index.js';
+import { rapidhash } from '../../utils/hash.js';
+/**
+ * Returns `true` when the asset attributes match the exact shape required for
+ * safe page-owned bundling.
+ */
 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]);
+    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("#");
+    return (reference.startsWith('/') ||
+        reference.startsWith('data:') ||
+        reference.startsWith('http://') ||
+        reference.startsWith('https://') ||
+        reference.startsWith('#'));
 }
+/**
+ * Normalizes CSS URL tokens before safety checks so quoted and unquoted forms are treated equally.
+ */
 function normalizeCssReferenceToken(token) {
-  return token.trim().replace(/^['"]|['"]$/g, "");
+    return token.trim().replace(/^['"]|['"]$/g, '');
 }
+/**
+ * Rejects stylesheet content that contains relative references which would stop
+ * working once multiple files are collapsed into one page-owned bundle.
+ */
 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(/@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;
+    for (const match of content.matchAll(/url\(([^)]+)\)/g)) {
+        const reference = normalizeCssReferenceToken(match[1] ?? '');
+        if (reference && !isSafeBundledStylesheetReference(reference)) {
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 }
 function isBundleableFileStylesheetAsset(dependency) {
-  return dependency.kind === "stylesheet" && dependency.source === "file";
+    return dependency.kind === 'stylesheet' && dependency.source === 'file';
 }
 function isBundleableFileScriptAsset(dependency) {
-  return dependency.kind === "script" && dependency.source === "file";
+    return dependency.kind === 'script' && dependency.source === 'file';
 }
-function shouldBundlePageDependencies(integrationName) {
-  return integrationName === "react" || integrationName === "ecopages-jsx";
+/**
+ * Returns whether the current integration should collapse eligible page assets into
+ * page-owned bundle entries.
+ */
+export function shouldBundlePageDependencies(integrationName) {
+    return integrationName === 'react' || integrationName === 'ecopages-jsx';
 }
 function createPageDependencyPackagingPlan(dependencies, integrationName) {
-  const shouldBundleDependencies = process.env.NODE_ENV === "production";
-  const bundleableStyles = dependencies.filter((dependency) => {
-    if (!shouldBundleDependencies) {
-      return false;
-    }
-    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) => {
-    if (!shouldBundleDependencies) {
-      return false;
+    const shouldBundleDependencies = process.env.NODE_ENV === 'production';
+    const bundleableStyles = dependencies
+        .filter((dependency) => {
+        if (!shouldBundleDependencies) {
+            return false;
+        }
+        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) => {
+        if (!shouldBundleDependencies) {
+            return false;
+        }
+        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',
+            bundledSourceFilepaths: bundleableStyles.map((dependency) => dependency.filepath),
+        })
+        : undefined;
+    const pageScriptImports = [...new Set(bundleableScripts.map((dependency) => dependency.filepath))];
+    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',
+            bundledSourceFilepaths: pageScriptImports,
+        })
+        : undefined;
+    if (!bundledStylesheet && !bundledScript) {
+        return undefined;
     }
-    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",
-    bundledSourceFilepaths: bundleableStyles.map((dependency) => dependency.filepath)
-  }) : void 0;
-  const pageScriptImports = [...new Set(bundleableScripts.map((dependency) => dependency.filepath))];
-  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",
-    bundledSourceFilepaths: pageScriptImports
-  }) : void 0;
-  if (!bundledStylesheet && !bundledScript) {
-    return void 0;
-  }
-  return {
-    bundledStylesheet,
-    bundledScript,
-    bundleableStyleFilepaths: new Set(bundleableStyles.map((dependency) => dependency.filepath)),
-    bundleableScriptFilepaths: new Set(pageScriptImports)
-  };
+    return {
+        bundledStylesheet,
+        bundledScript,
+        bundleableStyleFilepaths: new Set(bundleableStyles.map((dependency) => dependency.filepath)),
+        bundleableScriptFilepaths: new Set(pageScriptImports),
+    };
 }
 function applyPageDependencyPackagingPlan(dependencies, plan) {
-  const unifiedDependencies = [];
-  let insertedStylesheet = false;
-  let insertedScript = false;
-  for (const dependency of dependencies) {
-    if (plan.bundledStylesheet && dependency.kind === "stylesheet" && dependency.source === "file" && plan.bundleableStyleFilepaths.has(dependency.filepath)) {
-      if (!insertedStylesheet) {
-        unifiedDependencies.push(plan.bundledStylesheet);
-        insertedStylesheet = true;
-      }
-      continue;
+    const unifiedDependencies = [];
+    let insertedStylesheet = false;
+    let insertedScript = false;
+    for (const dependency of dependencies) {
+        if (plan.bundledStylesheet &&
+            dependency.kind === 'stylesheet' &&
+            dependency.source === 'file' &&
+            plan.bundleableStyleFilepaths.has(dependency.filepath)) {
+            if (!insertedStylesheet) {
+                unifiedDependencies.push(plan.bundledStylesheet);
+                insertedStylesheet = true;
+            }
+            continue;
+        }
+        if (plan.bundledScript &&
+            dependency.kind === 'script' &&
+            dependency.source === 'file' &&
+            plan.bundleableScriptFilepaths.has(dependency.filepath)) {
+            if (!insertedScript) {
+                unifiedDependencies.push(plan.bundledScript);
+                insertedScript = true;
+            }
+            continue;
+        }
+        unifiedDependencies.push(dependency);
     }
-    if (plan.bundledScript && dependency.kind === "script" && dependency.source === "file" && plan.bundleableScriptFilepaths.has(dependency.filepath)) {
-      if (!insertedScript) {
+    if (plan.bundledScript && !insertedScript) {
         unifiedDependencies.push(plan.bundledScript);
-        insertedScript = true;
-      }
-      continue;
     }
-    unifiedDependencies.push(dependency);
-  }
-  if (plan.bundledScript && !insertedScript) {
-    unifiedDependencies.push(plan.bundledScript);
-  }
-  if (plan.bundledStylesheet && !insertedStylesheet) {
-    unifiedDependencies.push(plan.bundledStylesheet);
-  }
-  return unifiedDependencies;
+    if (plan.bundledStylesheet && !insertedStylesheet) {
+        unifiedDependencies.push(plan.bundledStylesheet);
+    }
+    return unifiedDependencies;
 }
-function packagePageDependencies(dependencies, integrationName) {
-  if (!shouldBundlePageDependencies(integrationName)) {
-    return dependencies;
-  }
-  const plan = createPageDependencyPackagingPlan(dependencies, integrationName);
-  if (!plan) {
-    return dependencies;
-  }
-  return applyPageDependencyPackagingPlan(dependencies, plan);
+/**
+ * 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 function packagePageDependencies(dependencies, integrationName) {
+    if (!shouldBundlePageDependencies(integrationName)) {
+        return dependencies;
+    }
+    const plan = createPageDependencyPackagingPlan(dependencies, integrationName);
+    if (!plan) {
+        return dependencies;
+    }
+    return applyPageDependencyPackagingPlan(dependencies, plan);
 }
-export {
-  packagePageDependencies,
-  shouldBundlePageDependencies
-};

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

@@ -29,7 +29,6 @@ export declare class PageModuleLoaderService {
      */
     importPageFile(file: string, options?: {
         bypassCache?: boolean;
-        cacheScope?: string;
     }): Promise<EcoPageFile>;
     /**
      * Executes the page's static-props hook with Ecopages runtime context.
@@ -62,8 +61,10 @@ export declare class PageModuleLoaderService {
      */
     resolvePageModule(options: {
         file: string;
+        pageModule?: EcoPageFile;
         importPageFileFn?: (file: string) => Promise<EcoPageFile>;
     }): Promise<{
+        module: EcoPageFile;
         Page: EcoPageFile['default'] | EcoPageComponent<any>;
         getStaticProps?: GetStaticProps<Record<string, unknown>>;
         getMetadata?: GetMetadata;

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

@@ -1,127 +1,139 @@
-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}`);
+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';
+import { HttpError } from '../../errors/http-error.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 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);
     }
-  }
-  /**
-   * 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 };
+    /**
+     * 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,
+                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) => {
+                if (HttpError.isHttpError(err) || err instanceof Response) {
+                    throw err;
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`Error fetching static props: ${message}`, { cause: err });
+            })
+            : {
+                props: {},
+                metadata: undefined,
+            };
+    }
+    /**
+     * 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 = options.pageModule ??
+            (await (options.importPageFileFn ?? ((file) => this.importPageFile(file)))(options.file));
+        const { default: Page, getStaticProps: moduleGetStaticProps, getMetadata: moduleGetMetadata, ...integrationSpecificProps } = module;
+        return {
+            module,
+            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 };
     }
-    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
-};

package/src/route-renderer/page-loading/resolved-page-dependencies.d.ts

@@ -0,0 +1,12 @@
+import type { EcoComponent, PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../../types/public-types.js';
+import { collectFileScopedDependencyComponents } from './file-scoped-dependency-components.js';
+export type ResolvedPageDependencies = {
+    ownerFile: string;
+    components: ReadonlyArray<EcoComponent | Partial<EcoComponent>>;
+    contribution?: PageBrowserGraphContribution;
+};
+export type ResolvePageDependenciesContribution = (dependencies: Parameters<typeof collectFileScopedDependencyComponents>[0]['dependencies'], ownerFile: string, components: ReadonlyArray<EcoComponent | Partial<EcoComponent>>) => Promise<PageBrowserGraphContribution | undefined>;
+/**
+ * Resolves `eco.page().dependencies()` once for one graph contribution context.
+ */
+export declare function resolvePageDependenciesFromContext(context: PageBrowserGraphContributionContext, integrationName: string, materializeContribution: ResolvePageDependenciesContribution): Promise<ResolvedPageDependencies | undefined>;

package/src/route-renderer/page-loading/resolved-page-dependencies.js

@@ -0,0 +1,38 @@
+import { collectFileScopedDependencyComponents, splitPageDependenciesResult, } from './file-scoped-dependency-components.js';
+/**
+ * Resolves `eco.page().dependencies()` once for one graph contribution context.
+ */
+export async function resolvePageDependenciesFromContext(context, integrationName, materializeContribution) {
+    const pageComponent = context.pageModule.default;
+    const resolveDependencies = pageComponent.resolveDependencies;
+    if (!resolveDependencies) {
+        return undefined;
+    }
+    const dependenciesResult = await resolveDependencies({
+        props: (context.props ?? {}),
+        params: context.params,
+        query: context.query,
+    });
+    if (!dependenciesResult) {
+        return undefined;
+    }
+    const { dependencies, ownerFile } = splitPageDependenciesResult(dependenciesResult);
+    const resolvedOwnerFile = ownerFile ?? context.file;
+    const components = collectFileScopedDependencyComponents({
+        ownerFile: resolvedOwnerFile,
+        integrationName,
+        dependencies,
+    });
+    if (components.length === 0) {
+        return {
+            ownerFile: resolvedOwnerFile,
+            components,
+        };
+    }
+    const contribution = await materializeContribution(dependencies, resolvedOwnerFile, components);
+    return {
+        ownerFile: resolvedOwnerFile,
+        components,
+        contribution,
+    };
+}