@ecopages/core 0.2.0-beta.26 → 0.2.0-beta.28

package/src/route-renderer/orchestration/integration-renderer.test-fixtures.d.ts

@@ -0,0 +1,75 @@
+import { IntegrationRenderer, type HtmlDocumentContribution, type RenderToResponseContext } from './integration-renderer.js';
+import { getComponentRenderContext, type ForeignChildRuntime } from './foreign-child/component-render-context.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { ComponentRenderInput, ComponentRenderResult, EcoPagesElement, IntegrationRendererRenderOptions, EcoPageFile, RouteRendererBody, RouteRendererOptions, EcoComponent, HtmlTemplateProps } from '../../types/public-types.js';
+import type { PagePackageResult } from '../../types/public-types.js';
+export declare function createUnresolvedMarkerArtifact(nodeId: string, componentRef: string, propsRef: string): string;
+export declare function createMockIntegrationPlugin(plugin: {
+    name: string;
+} & Record<string, unknown>): EcoPagesAppConfig['integrations'][number];
+export declare const testAppConfig: EcoPagesAppConfig;
+export declare const testAssetService: AssetProcessingService;
+/**
+ * Concrete implementation with ed file loading for testing purposes.
+ */
+export declare class TestIntegrationRenderer extends IntegrationRenderer<EcoPagesElement> {
+    name: string;
+    ForeignChildRuntimeCreationCount: number;
+    ForeignChildRenderCount: number;
+    UseFailFastForeignChildRuntime: boolean;
+    PageModule: EcoPageFile | null;
+    HtmlTemplate: EcoComponent<HtmlTemplateProps> | null;
+    RenderedBody: RouteRendererBody;
+    RenderBodyFactory: ((context: ReturnType<typeof getComponentRenderContext>) => RouteRendererBody | Promise<RouteRendererBody>) | null;
+    MockComponentRenderResult: ComponentRenderResult | null;
+    ImportedFiles: string[];
+    HtmlContributions: HtmlDocumentContribution[];
+    render(_options: IntegrationRendererRenderOptions<EcoPagesElement>): Promise<RouteRendererBody>;
+    renderComponent(_input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    renderToResponse<P>(view: EcoComponent<P>, props: P, ctx: RenderToResponseContext): Promise<Response>;
+    protected importPageFile(_file: string): Promise<EcoPageFile>;
+    protected getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
+    protected resolveDependencies(_components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
+    testPrepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<EcoPagesElement>>;
+    testShouldDelegateForeignChild(input: {
+        currentIntegration: string;
+        targetIntegration?: string;
+    }): boolean;
+    testHasForeignChildDescendants(component: EcoComponent): boolean;
+    testGetHtmlTemplate(): Promise<import("../../index.browser.js").EcoFunctionComponent<HtmlTemplateProps<EcoPagesElement>, any>>;
+    testBaseGetHtmlTemplate(): Promise<import("../../index.browser.js").EcoFunctionComponent<HtmlTemplateProps<EcoPagesElement>, any>>;
+    testGetRendererBootstrapDependencies(partial?: boolean): ProcessedAsset[];
+    testFinalizeDocumentShellHtml(options: {
+        html: string;
+        partial?: boolean;
+        htmlContributions?: HtmlDocumentContribution[];
+    }): Promise<string>;
+    testTransformRouteResponse(response: Response, htmlContributions?: HtmlDocumentContribution[], pagePackage?: PagePackageResult): Promise<RouteRendererBody>;
+    appendTestProcessedDependencies(assets: ProcessedAsset[]): ProcessedAsset[];
+    setTestPagePackage(pagePackage: PagePackageResult): void;
+    getTestPagePackage(): PagePackageResult | undefined;
+    getTestProcessedDependencies(): ProcessedAsset[];
+    testRenderPartialViewResponse<P>(input: {
+        view: EcoComponent<P>;
+        props: P;
+        ctx?: RenderToResponseContext;
+        renderInline?: () => Promise<BodyInit>;
+        transformHtml?: (html: string) => string;
+    }): Promise<Response>;
+    testRenderViewWithDocumentShell<P>(input: {
+        view: EcoComponent<P>;
+        props: P;
+        ctx?: RenderToResponseContext;
+        layout?: EcoComponent;
+    }): Promise<Response>;
+    testRenderForeignSubtree(input: ComponentRenderInput): Promise<import("../../index.browser.js").ForeignSubtreeRenderPayload>;
+    protected createForeignChildRuntime(options: {
+        renderInput: ComponentRenderInput;
+        rendererCache: Map<string, IntegrationRenderer<any>>;
+    }): ForeignChildRuntime;
+    protected getHtmlDocumentContributions(_options?: {
+        partial?: boolean;
+    }): HtmlDocumentContribution[] | undefined;
+}

package/src/route-renderer/orchestration/integration-renderer.test-fixtures.js

@@ -0,0 +1,177 @@
+import { vi } from "vitest";
+import { resolveInnermostPageLayout } from "./document-shell/layout-shell-props.service.js";
+import { finalizeDocumentShellHtml } from "./document-shell/document-shell-render.service.js";
+import {
+  IntegrationRenderer
+} from "./integration-renderer.js";
+import { getComponentRenderContext } from "./foreign-child/component-render-context.js";
+import { toForeignSubtreeRenderPayload } from "./foreign-child/foreign-subtree-execution.service.js";
+function createUnresolvedMarkerArtifact(nodeId, componentRef, propsRef) {
+  return `<eco-marker data-eco-node-id="${nodeId}" data-eco-component-ref="${componentRef}" data-eco-props-ref="${propsRef}"></eco-marker>`;
+}
+function createMockIntegrationPlugin(plugin) {
+  return {
+    setConfig: vi.fn(),
+    setRuntimeOrigin: vi.fn(),
+    setup: vi.fn(async () => {
+    }),
+    ...plugin
+  };
+}
+const testAppConfig = {
+  absolutePaths: {
+    pagesDir: "/app/pages",
+    htmlTemplatePath: "/app/index.ghtml.ts"
+  },
+  integrations: [],
+  defaultMetadata: {
+    title: "Default Title",
+    description: "Default Description"
+  },
+  srcDir: "/app"
+};
+const testAssetService = {
+  processDependencies: vi.fn(() => Promise.resolve([]))
+};
+class TestIntegrationRenderer extends IntegrationRenderer {
+  name = "test-renderer";
+  ForeignChildRuntimeCreationCount = 0;
+  ForeignChildRenderCount = 0;
+  UseFailFastForeignChildRuntime = false;
+  PageModule = null;
+  HtmlTemplate = null;
+  RenderedBody = "<html><body>Test Page</body></html>";
+  RenderBodyFactory = null;
+  MockComponentRenderResult = null;
+  ImportedFiles = [];
+  HtmlContributions = [];
+  async render(_options) {
+    if (this.RenderBodyFactory) {
+      return await this.RenderBodyFactory(getComponentRenderContext());
+    }
+    return this.RenderedBody;
+  }
+  async renderComponent(_input) {
+    if (this.MockComponentRenderResult) {
+      return this.MockComponentRenderResult;
+    }
+    return super.renderComponent(_input);
+  }
+  async renderComponentWithForeignChildren(input) {
+    this.ForeignChildRenderCount += 1;
+    return await super.renderComponentWithForeignChildren(input);
+  }
+  async renderToResponse(view, props, ctx) {
+    const viewFn = view;
+    const content = viewFn(props);
+    let body;
+    if (ctx.partial) {
+      body = content;
+    } else {
+      const Layout = resolveInnermostPageLayout(view.config?.layouts);
+      const children = Layout ? Layout({ children: content }) : content;
+      body = `<!DOCTYPE html><html><body>${children}</body></html>`;
+    }
+    const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
+    if (ctx.headers) {
+      for (const [key, value] of Object.entries(ctx.headers)) {
+        headers.set(key, value);
+      }
+    }
+    return new Response(body, {
+      status: ctx.status ?? 200,
+      headers
+    });
+  }
+  async importPageFile(_file) {
+    this.ImportedFiles.push(_file);
+    if (!this.PageModule) throw new Error("Mock page module not set");
+    return this.PageModule;
+  }
+  async getHtmlTemplate() {
+    if (!this.HtmlTemplate) throw new Error("Mock HTML template not set");
+    return this.HtmlTemplate;
+  }
+  async resolveDependencies(_components) {
+    return [];
+  }
+  async testPrepareRenderOptions(options) {
+    return this.prepareRenderOptions(options);
+  }
+  testShouldDelegateForeignChild(input) {
+    return this.foreignSubtreeExecutionService.shouldDelegateForeignChild(input);
+  }
+  testHasForeignChildDescendants(component) {
+    return this.hasForeignChildDescendants(component);
+  }
+  async testGetHtmlTemplate() {
+    return this.getHtmlTemplate();
+  }
+  async testBaseGetHtmlTemplate() {
+    return super.getHtmlTemplate();
+  }
+  testGetRendererBootstrapDependencies(partial = false) {
+    return this.getRendererBootstrapDependencies(partial);
+  }
+  async testFinalizeDocumentShellHtml(options) {
+    this.appendProcessedDependencies(this.getRendererBootstrapDependencies(options.partial));
+    return finalizeDocumentShellHtml(this.htmlTransformer, {
+      html: options.html,
+      partial: options.partial,
+      htmlContributions: options.htmlContributions ?? this.getHtmlDocumentContributions({ partial: options.partial ?? false })
+    });
+  }
+  async testTransformRouteResponse(response, htmlContributions, pagePackage) {
+    const adapter = this.createRouteRenderOrchestratorAdapter();
+    return adapter.transformRouteResponse(response, htmlContributions, pagePackage);
+  }
+  appendTestProcessedDependencies(assets) {
+    return this.appendProcessedDependencies(assets);
+  }
+  setTestPagePackage(pagePackage) {
+    this.htmlTransformer.setPagePackage(pagePackage);
+  }
+  getTestPagePackage() {
+    return this.htmlTransformer.getPagePackage();
+  }
+  getTestProcessedDependencies() {
+    return this.htmlTransformer.getProcessedDependencies();
+  }
+  async testRenderPartialViewResponse(input) {
+    return this.renderPartialViewResponse({
+      view: input.view,
+      props: input.props,
+      ctx: input.ctx ?? { partial: true },
+      renderInline: input.renderInline,
+      transformHtml: input.transformHtml
+    });
+  }
+  async testRenderViewWithDocumentShell(input) {
+    return this.renderViewWithDocumentShell({
+      view: input.view,
+      props: input.props,
+      ctx: input.ctx ?? {},
+      layout: input.layout
+    });
+  }
+  async testRenderForeignSubtree(input) {
+    return toForeignSubtreeRenderPayload(await this.renderComponentWithForeignChildren(input));
+  }
+  createForeignChildRuntime(options) {
+    this.ForeignChildRuntimeCreationCount += 1;
+    if (this.UseFailFastForeignChildRuntime) {
+      return this.createFailFastForeignChildRuntime();
+    }
+    return super.createForeignChildRuntime(options);
+  }
+  getHtmlDocumentContributions(_options) {
+    return this.HtmlContributions;
+  }
+}
+export {
+  TestIntegrationRenderer,
+  createMockIntegrationPlugin,
+  createUnresolvedMarkerArtifact,
+  testAppConfig,
+  testAssetService
+};

package/src/route-renderer/orchestration/{component-graph-collectors.d.ts → ownership-graph/component-graph-collectors.d.ts}

@@ -1,7 +1,7 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { EcoComponent, ResolvedLazyTrigger } from '../../types/public-types.js';
-import type { AssetDefinition } from '../../services/assets/asset-processing-service/index.js';
-import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { EcoComponent, ResolvedLazyTrigger } from '../../../types/public-types.js';
+import type { AssetDefinition } from '../../../services/assets/asset-processing-service/index.js';
+import type { AssetProcessingService, ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
 export declare function collectIntegrationNamesFromGraph(components: (EcoComponent | Partial<EcoComponent>)[], currentIntegrationName: string): Set<string>;
 export declare function collectResolvedLazyTriggersFromGraph(components: (EcoComponent | Partial<EcoComponent>)[], currentIntegrationName: string): ResolvedLazyTrigger[];
 export declare function hasForeignChildDescendantsInGraph(component: EcoComponent, currentIntegrationName: string): boolean;

package/src/route-renderer/orchestration/{component-graph-collectors.js → ownership-graph/component-graph-collectors.js}

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
+import { AssetFactory } from "../../../services/assets/asset-processing-service/index.js";
 import { walkComponentGraph } from "./component-graph.js";
 function toGraphRoots(components) {
   return components.filter(Boolean).map((component) => ({ component }));

package/src/route-renderer/orchestration/{component-graph.d.ts → ownership-graph/component-graph.d.ts}

@@ -1,4 +1,4 @@
-import type { EcoComponent, OwnershipPlanNodeSource } from '../../types/public-types.js';
+import type { EcoComponent, OwnershipPlanNodeSource } from '../../../types/public-types.js';
 export type DeclaredOwnershipRoot = {
     component: EcoComponent;
     source: Extract<OwnershipPlanNodeSource, 'page' | 'layout' | 'html-template'>;
@@ -32,5 +32,3 @@ export declare function mapComponentGraph<T>(input: {
     currentIntegrationName: string;
     mapNode: (node: DeclaredOwnershipNodeInput, children: T[]) => T;
 }): T[];
-/** @deprecated Use `mapComponentGraph` from `component-graph.ts`. */
-export declare const mapDeclaredOwnershipGraph: typeof mapComponentGraph;

package/src/route-renderer/orchestration/{component-graph.js → ownership-graph/component-graph.js}

@@ -90,9 +90,7 @@ function mapComponentGraph(input) {
     ({ component, source }) => mapComponent(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
   );
 }
-const mapDeclaredOwnershipGraph = mapComponentGraph;
 export {
   mapComponentGraph,
-  mapDeclaredOwnershipGraph,
   walkComponentGraph
 };

package/src/route-renderer/orchestration/{ownership-validation.service.d.ts → ownership-graph/ownership-validation.service.d.ts}

@@ -1,5 +1,5 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { OwnershipPlanNodeSource, OwnershipValidationError, EcoComponent } from '../../types/public-types.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { OwnershipPlanNodeSource, OwnershipValidationError, EcoComponent } from '../../../types/public-types.js';
 type OwnershipValidationInput = {
     currentIntegrationName: string;
     roots: Array<{

package/src/route-renderer/orchestration/{ownership-validation.service.js → ownership-graph/ownership-validation.service.js}

@@ -1,6 +1,5 @@
-import { assertEcoDeclaredComponent } from "../../eco/eco-declared-component.js";
-import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
-import { walkComponentGraph } from "./component-graph.js";
+import { assertEcoDeclaredComponent } from "../../../eco/eco-declared-component.js";
+import { mapComponentGraph, walkComponentGraph } from "./component-graph.js";
 class OwnershipValidationService {
   appConfig;
   /**
@@ -14,7 +13,7 @@ class OwnershipValidationService {
    */
   validate(input) {
     this.assertDeclaredComponentDependencies(input);
-    return mapDeclaredOwnershipGraph({
+    return mapComponentGraph({
       roots: input.roots,
       currentIntegrationName: input.currentIntegrationName,
       mapNode: ({ component, integrationName, componentId, isForeignToParent }, children) => {

package/src/route-renderer/orchestration/{global-injector-assets.service.d.ts → page-browser-graph/global-injector-assets.service.d.ts}

@@ -1,6 +1,6 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { ResolvedLazyTrigger } from '../../types/public-types.js';
-import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { ResolvedLazyTrigger } from '../../../types/public-types.js';
+import { type AssetProcessingService, type ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
 /**
  * Builds processed global-injector map and bootstrap assets for resolved lazy triggers.
  */

package/src/route-renderer/orchestration/{global-injector-assets.service.js → page-browser-graph/global-injector-assets.service.js}

@@ -2,8 +2,8 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import {
   AssetFactory
-} from "../../services/assets/asset-processing-service/index.js";
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
+} from "../../../services/assets/asset-processing-service/index.js";
+import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../../eco/global-injector-map.js";
 async function buildGlobalInjectorAssets(appConfig, assetProcessingService, triggers, currentIntegrationName) {
   const appProjectDir = appConfig.rootDir ?? appConfig.absolutePaths?.projectDir ?? process.cwd();
   const appPackageRequire = createRequire(path.join(appProjectDir, "package.json"));

package/src/route-renderer/orchestration/{page-browser-graph-contribution.loader.d.ts → page-browser-graph/page-browser-graph-contribution.loader.d.ts}

@@ -1,4 +1,4 @@
-import type { EcoPageFile, PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../../types/public-types.js';
+import type { EcoPageFile, PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../../../types/public-types.js';
 /**
  * Loads a page module once and collects declarative browser-graph requirements.
  *

package/src/route-renderer/orchestration/page-browser-graph/page-browser-graph-merge.utils.d.ts

@@ -0,0 +1,12 @@
+import { type ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
+import type { PageBrowserGraphResult, PagePackageResult } from '../../../types/public-types.js';
+/**
+ * Merges a page browser graph into an existing page package (or processed dependencies).
+ *
+ * Deduplicates entry/chunk assets against the existing package and rebuilds the
+ * package so downstream HTML finalization sees one canonical graph.
+ */
+export declare function mergePageBrowserGraph(currentPagePackage: PagePackageResult | undefined, processedDependencies: ProcessedAsset[], pageBrowserGraph: PageBrowserGraphResult): {
+    pagePackage: PagePackageResult;
+    mergedGraph: PageBrowserGraphResult;
+};

package/src/route-renderer/orchestration/page-browser-graph/page-browser-graph-merge.utils.js

@@ -0,0 +1,29 @@
+import { createPagePackage } from "../../../services/assets/asset-processing-service/index.js";
+import { buildProcessedAssetDedupeKey, dedupeProcessedAssets } from "./processed-asset-dedupe.js";
+function mergePageBrowserGraph(currentPagePackage, processedDependencies, pageBrowserGraph) {
+  const mergedGraph = currentPagePackage?.pageBrowserGraph ? {
+    entryAssets: dedupeProcessedAssets([
+      ...currentPagePackage.pageBrowserGraph.entryAssets,
+      ...pageBrowserGraph.entryAssets
+    ]),
+    chunkAssets: dedupeProcessedAssets([
+      ...currentPagePackage.pageBrowserGraph.chunkAssets,
+      ...pageBrowserGraph.chunkAssets
+    ])
+  } : pageBrowserGraph;
+  const pageBrowserGraphAssetKeys = new Set(
+    [...mergedGraph.entryAssets, ...mergedGraph.chunkAssets].map((asset) => buildProcessedAssetDedupeKey(asset))
+  );
+  const baseAssets = currentPagePackage ? currentPagePackage.assets.filter(
+    (asset) => !pageBrowserGraphAssetKeys.has(buildProcessedAssetDedupeKey(asset))
+  ) : processedDependencies;
+  return {
+    pagePackage: createPagePackage(dedupeProcessedAssets(baseAssets), {
+      pageBrowserGraph: mergedGraph
+    }),
+    mergedGraph
+  };
+}
+export {
+  mergePageBrowserGraph
+};

package/src/route-renderer/orchestration/page-browser-graph/page-browser-graph-session.d.ts

@@ -0,0 +1,106 @@
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { PageBrowserGraphContribution, PageBrowserGraphResult } from '../../../types/public-types.js';
+import type { ProcessedAsset } from '../../../services/assets/asset-processing-service/assets.types.js';
+export type GraphPolicy = 'development' | 'production';
+export type GraphKey = {
+    integrationName: string;
+    routeFile: string;
+    entryFingerprint: string;
+    policy: GraphPolicy;
+};
+export type GraphRecord = {
+    key: GraphKey;
+    result: PageBrowserGraphResult;
+    dependencyPaths: ReadonlySet<string>;
+    committedAt: number;
+    generation: number;
+};
+export type GraphBuildResult = {
+    result: PageBrowserGraphResult;
+    dependencyPaths: ReadonlySet<string>;
+};
+type GroupedGraphRecord = {
+    assetsByRoute: Map<string, ProcessedAsset[]>;
+    dependencyPaths: ReadonlySet<string>;
+    generation: number;
+};
+export type GroupedGraphBuildOutcome = GroupedGraphRecord | {
+    skipCache: true;
+    assetsByRoute: Map<string, ProcessedAsset[]>;
+    dependencyPaths: ReadonlySet<string>;
+};
+export type AffectedGraphIdentity = {
+    integrationName: string;
+    routeFile: string;
+    policy: GraphPolicy;
+    entryFingerprint: string;
+};
+/**
+ * Reverse index from dependency paths to graph cache keys.
+ */
+export declare class GraphDependencyIndex {
+    private readonly dependencyToGraphKeys;
+    bindRecord(record: GraphRecord): void;
+    unbindRecord(record: GraphRecord): void;
+    bindGroupedRecord(integrationName: string, record: GroupedGraphRecord): void;
+    unbindGroupedRecord(integrationName: string, record: GroupedGraphRecord): void;
+    getAffectedKeys(filePath: string): Set<string>;
+    resetForTests(): void;
+    private addDependencyBinding;
+    private removeDependencyBinding;
+}
+/**
+ * Session-local Page Browser Graph cache with precise dependency invalidation.
+ */
+export declare class SessionPageBrowserGraphCache {
+    private readonly records;
+    private readonly inFlight;
+    private readonly groupedRecords;
+    private readonly groupedInFlight;
+    private readonly dependencyIndex;
+    private readonly graphGenerations;
+    private readonly groupedGenerations;
+    private buildCount;
+    getGraphByRoute(integrationName: string, routeFile: string, policy: GraphPolicy): PageBrowserGraphResult | undefined;
+    getBuildCount(): number;
+    getAffectedGraphIdentities(filePath: string): AffectedGraphIdentity[];
+    resolveGraph(key: GraphKey, build: () => Promise<GraphBuildResult | undefined>): Promise<PageBrowserGraphResult | undefined>;
+    resolveGroupedGraph(integrationName: string, build: () => Promise<GroupedGraphBuildOutcome | undefined>): Promise<Map<string, ProcessedAsset[]>>;
+    peekGroupedGraph(integrationName: string): Map<string, ProcessedAsset[]> | undefined;
+    invalidateByFilePath(filePath: string): number;
+    invalidateRoute(integrationName: string, routeFile: string): void;
+    invalidateByRouteFile(routeFile: string): void;
+    resetForTests(): void;
+    exportRecords(policy: GraphPolicy): GraphRecord[];
+    clearPolicyRecords(policy: GraphPolicy): void;
+    private pruneStaleRouteRecords;
+    private bumpGraphGeneration;
+    private bumpGroupedGeneration;
+    private invalidateSerializedGraphKey;
+    private invalidateGroupedRecord;
+    private runGraphBuild;
+    private runGroupedBuild;
+    private canCommitGraphBuild;
+    private canCommitGroupedBuild;
+}
+/**
+ * Returns the session graph cache for one app instance.
+ */
+export declare function getAppPageBrowserGraphSession(appConfig: EcoPagesAppConfig): SessionPageBrowserGraphCache;
+/**
+ * Invalidates graph records that depend on the changed file path.
+ */
+export declare function invalidatePageBrowserGraphSession(appConfig: EcoPagesAppConfig, filePath: string): number;
+/**
+ * Returns graph identities affected by a source file change.
+ */
+export declare function getAffectedPageBrowserGraphIdentities(appConfig: EcoPagesAppConfig, filePath: string): AffectedGraphIdentity[];
+/**
+ * Builds a stable fingerprint from declared browser-entry dependencies and assets.
+ */
+export declare function createPageBrowserGraphEntryFingerprint(contribution: PageBrowserGraphContribution): string;
+/**
+ * Collects dependency paths used for graph invalidation.
+ */
+export declare function collectPageBrowserGraphDependencyPaths(routeFile: string, contribution: PageBrowserGraphContribution, processedAssets: ProcessedAsset[]): ReadonlySet<string>;
+export {};