@ecopages/core 0.2.0-beta.3 → 0.2.0-beta.30

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/ownership-graph/component-graph-collectors.d.ts

@@ -0,0 +1,10 @@
+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;
+export declare function collectEagerSsrLazyScriptDefinitions(components: (EcoComponent | Partial<EcoComponent>)[]): AssetDefinition[];
+export declare function collectUsedIntegrationDependenciesFromGraph(appConfig: EcoPagesAppConfig, components: (EcoComponent | Partial<EcoComponent>)[], currentIntegrationName: string): ProcessedAsset[];
+export declare function buildEagerSsrLazyAssetsFromGraph(assetProcessingService: AssetProcessingService, components: (EcoComponent | Partial<EcoComponent>)[], currentIntegrationName: string): Promise<ProcessedAsset[]>;

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

@@ -0,0 +1,143 @@
+import path from "node:path";
+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 }));
+}
+function collectIntegrationNamesFromGraph(components, currentIntegrationName) {
+  const integrationNames = /* @__PURE__ */ new Set();
+  walkComponentGraph({
+    roots: toGraphRoots(components),
+    currentIntegrationName,
+    onComponent: ({ component }) => {
+      const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
+      if (integrationName) {
+        integrationNames.add(integrationName);
+      }
+    }
+  });
+  return integrationNames;
+}
+function collectResolvedLazyTriggersFromGraph(components, currentIntegrationName) {
+  const triggers = [];
+  walkComponentGraph({
+    roots: toGraphRoots(components),
+    currentIntegrationName,
+    onComponent: ({ component }) => {
+      const ownTriggers = component.config?._resolvedLazyTriggers;
+      if (ownTriggers?.length) {
+        triggers.push(...ownTriggers);
+      }
+    }
+  });
+  return triggers;
+}
+function hasForeignChildDescendantsInGraph(component, currentIntegrationName) {
+  let foundForeign = false;
+  walkComponentGraph({
+    roots: [{ component }],
+    currentIntegrationName,
+    onComponent: ({ component: currentComponent }) => {
+      if (foundForeign) {
+        return false;
+      }
+      const integrationName = currentComponent.config?.integration ?? currentComponent.config?.__eco?.integration;
+      if (integrationName && integrationName !== currentIntegrationName) {
+        foundForeign = true;
+        return false;
+      }
+    }
+  });
+  return foundForeign;
+}
+function collectEagerSsrLazyScriptDefinitions(components) {
+  const dependencies = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  const normalizeAttributes = (attributes) => ({
+    type: "module",
+    defer: "",
+    ...attributes ?? {}
+  });
+  walkComponentGraph({
+    roots: toGraphRoots(components),
+    currentIntegrationName: "",
+    visitLayout: true,
+    onConfig: (config) => {
+      const componentFile = config?.__eco?.file;
+      if (!componentFile) {
+        return;
+      }
+      const componentDir = path.dirname(componentFile);
+      for (const script of config.dependencies?.scripts ?? []) {
+        if (typeof script === "string" || !script.lazy || script.ssr !== true) {
+          continue;
+        }
+        const attributes = normalizeAttributes(script.attributes);
+        if (script.content) {
+          const key2 = `content:${script.content}:${JSON.stringify(attributes)}`;
+          if (seenKeys.has(key2)) {
+            continue;
+          }
+          seenKeys.add(key2);
+          dependencies.push(
+            AssetFactory.createContentScript({
+              position: "head",
+              content: script.content,
+              attributes,
+              packageRole: "dynamic-chunk"
+            })
+          );
+          continue;
+        }
+        if (!script.src) {
+          continue;
+        }
+        const resolvedPath = path.resolve(componentDir, script.src);
+        const key = `file:${resolvedPath}:${JSON.stringify(attributes)}`;
+        if (seenKeys.has(key)) {
+          continue;
+        }
+        seenKeys.add(key);
+        dependencies.push(
+          AssetFactory.createFileScript({
+            filepath: resolvedPath,
+            position: "head",
+            attributes,
+            packageRole: "dynamic-chunk"
+          })
+        );
+      }
+    }
+  });
+  return dependencies;
+}
+function collectUsedIntegrationDependenciesFromGraph(appConfig, components, currentIntegrationName) {
+  const integrationNames = collectIntegrationNamesFromGraph(components, currentIntegrationName);
+  const dependencies = [];
+  for (const integrationName of integrationNames) {
+    if (integrationName === currentIntegrationName) {
+      continue;
+    }
+    const integrationPlugin = appConfig.integrations.find((integration) => integration.name === integrationName);
+    if (!integrationPlugin || typeof integrationPlugin.getResolvedIntegrationDependencies !== "function") {
+      continue;
+    }
+    dependencies.push(...integrationPlugin.getResolvedIntegrationDependencies());
+  }
+  return dependencies;
+}
+async function buildEagerSsrLazyAssetsFromGraph(assetProcessingService, components, currentIntegrationName) {
+  const dependencies = collectEagerSsrLazyScriptDefinitions(components);
+  if (dependencies.length === 0) {
+    return [];
+  }
+  return assetProcessingService.processDependencies(dependencies, `${currentIntegrationName}:ssr-lazy`);
+}
+export {
+  buildEagerSsrLazyAssetsFromGraph,
+  collectEagerSsrLazyScriptDefinitions,
+  collectIntegrationNamesFromGraph,
+  collectResolvedLazyTriggersFromGraph,
+  collectUsedIntegrationDependenciesFromGraph,
+  hasForeignChildDescendantsInGraph
+};

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

@@ -0,0 +1,34 @@
+import type { EcoComponent, OwnershipPlanNodeSource } from '../../../types/public-types.js';
+export type DeclaredOwnershipRoot = {
+    component: EcoComponent;
+    source: Extract<OwnershipPlanNodeSource, 'page' | 'layout' | 'html-template'>;
+};
+export type DeclaredOwnershipNodeInput = {
+    component: EcoComponent;
+    source: Exclude<OwnershipPlanNodeSource, 'route'>;
+    parentIntegrationName: string;
+    integrationName: string;
+    componentId: string;
+    isForeignToParent: boolean;
+};
+export type ComponentGraphRoot = {
+    component: EcoComponent | Partial<EcoComponent>;
+    source?: Exclude<OwnershipPlanNodeSource, 'route'>;
+};
+export type ComponentGraphWalkInput = {
+    component: EcoComponent;
+    parentIntegrationName: string;
+    source?: Exclude<OwnershipPlanNodeSource, 'route'>;
+};
+export declare function walkComponentGraph(input: {
+    roots: ComponentGraphRoot[];
+    currentIntegrationName: string;
+    visitLayout?: boolean;
+    onComponent?: (node: ComponentGraphWalkInput) => void | boolean;
+    onConfig?: (config: EcoComponent['config']) => void;
+}): void;
+export declare function mapComponentGraph<T>(input: {
+    roots: DeclaredOwnershipRoot[];
+    currentIntegrationName: string;
+    mapNode: (node: DeclaredOwnershipNodeInput, children: T[]) => T;
+}): T[];

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

@@ -0,0 +1,96 @@
+function walkComponentGraph(input) {
+  const seenComponents = /* @__PURE__ */ new Set();
+  const seenConfigs = /* @__PURE__ */ new Set();
+  const visitComponent = (component, parentIntegrationName, source) => {
+    if (!component) {
+      return;
+    }
+    const ecoComponent = component;
+    if (seenComponents.has(ecoComponent)) {
+      return;
+    }
+    seenComponents.add(ecoComponent);
+    const integrationName = ecoComponent.config?.integration ?? ecoComponent.config?.__eco?.integration ?? parentIntegrationName;
+    if (input.onConfig && ecoComponent.config && !seenConfigs.has(ecoComponent.config)) {
+      seenConfigs.add(ecoComponent.config);
+      input.onConfig(ecoComponent.config);
+    }
+    if (input.onComponent) {
+      const shouldContinue = input.onComponent({
+        component: ecoComponent,
+        parentIntegrationName,
+        source
+      });
+      if (shouldContinue === false) {
+        return;
+      }
+    }
+    if (input.visitLayout) {
+      for (const layout of ecoComponent.config?.layouts ?? []) {
+        if (layout?.config) {
+          visitConfig(layout.config, integrationName);
+        }
+      }
+    }
+    for (const child of ecoComponent.config?.dependencies?.components ?? []) {
+      visitComponent(child, integrationName, "dependency");
+    }
+  };
+  const visitConfig = (config, parentIntegrationName) => {
+    if (!config || seenConfigs.has(config)) {
+      return;
+    }
+    seenConfigs.add(config);
+    if (input.onConfig) {
+      input.onConfig(config);
+    }
+    if (input.visitLayout) {
+      for (const layout of config.layouts ?? []) {
+        if (layout?.config) {
+          visitConfig(layout.config, parentIntegrationName);
+        }
+      }
+    }
+    for (const child of config.dependencies?.components ?? []) {
+      visitComponent(child, parentIntegrationName, "dependency");
+    }
+  };
+  for (const root of input.roots) {
+    visitComponent(root.component, input.currentIntegrationName, root.source);
+  }
+}
+function mapComponentGraph(input) {
+  let nextSyntheticId = 0;
+  const mapComponent = (component, source, parentIntegrationName, lineage) => {
+    const integrationName = component.config?.integration ?? component.config?.__eco?.integration ?? parentIntegrationName;
+    const componentMeta = component.config?.__eco;
+    const isForeignToParent = integrationName !== parentIntegrationName;
+    const componentId = componentMeta?.id ?? componentMeta?.file ?? `${source}:${nextSyntheticId += 1}`;
+    const nextLineage = new Set(lineage);
+    nextLineage.add(component);
+    const children = (component.config?.dependencies?.components ?? []).flatMap((child) => {
+      if (!child || nextLineage.has(child)) {
+        return [];
+      }
+      return [mapComponent(child, "dependency", integrationName, nextLineage)];
+    });
+    return input.mapNode(
+      {
+        component,
+        source,
+        parentIntegrationName,
+        integrationName,
+        componentId,
+        isForeignToParent
+      },
+      children
+    );
+  };
+  return input.roots.map(
+    ({ component, source }) => mapComponent(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
+  );
+}
+export {
+  mapComponentGraph,
+  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<{
@@ -24,6 +24,11 @@ export declare class OwnershipValidationService {
      * Validates foreign ownership edges reachable from the supplied route roots.
      */
     validate(input: OwnershipValidationInput): OwnershipValidationError[];
+    private assertDeclaredComponentDependencies;
     private isRegisteredIntegration;
 }
+/**
+ * Throws when declared ownership validation collected one or more errors.
+ */
+export declare function throwIfOwnershipInvalid(validationErrors: OwnershipValidationError[]): void;
 export {};

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

@@ -1,4 +1,5 @@
-import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
+import { assertEcoDeclaredComponent } from "../../../eco/eco-declared-component.js";
+import { mapComponentGraph, walkComponentGraph } from "./component-graph.js";
 class OwnershipValidationService {
   appConfig;
   /**
@@ -11,7 +12,8 @@ class OwnershipValidationService {
    * Validates foreign ownership edges reachable from the supplied route roots.
    */
   validate(input) {
-    return mapDeclaredOwnershipGraph({
+    this.assertDeclaredComponentDependencies(input);
+    return mapComponentGraph({
       roots: input.roots,
       currentIntegrationName: input.currentIntegrationName,
       mapNode: ({ component, integrationName, componentId, isForeignToParent }, children) => {
@@ -20,6 +22,9 @@ class OwnershipValidationService {
         if (!isForeignToParent) {
           return errors;
         }
+        if (integrationName === "html") {
+          return errors;
+        }
         if (!componentMeta) {
           errors.push({
             code: "MISSING_COMPONENT_METADATA",
@@ -41,6 +46,21 @@ class OwnershipValidationService {
       }
     }).flat();
   }
+  assertDeclaredComponentDependencies(input) {
+    walkComponentGraph({
+      roots: input.roots,
+      currentIntegrationName: input.currentIntegrationName,
+      onComponent: ({ component }) => {
+        const parentFile = component.config?.__eco?.file;
+        for (const child of component.config?.dependencies?.components ?? []) {
+          if (!child) {
+            continue;
+          }
+          assertEcoDeclaredComponent(child, { parentComponentFile: parentFile });
+        }
+      }
+    });
+  }
   isRegisteredIntegration(integrationName, currentIntegrationName) {
     if (integrationName === currentIntegrationName) {
       return true;
@@ -48,6 +68,13 @@ class OwnershipValidationService {
     return this.appConfig.integrations.some((integration) => integration.name === integrationName);
   }
 }
+function throwIfOwnershipInvalid(validationErrors) {
+  if (validationErrors.length === 0) {
+    return;
+  }
+  throw new Error(validationErrors.map((error) => error.message).join("\n"));
+}
 export {
-  OwnershipValidationService
+  OwnershipValidationService,
+  throwIfOwnershipInvalid
 };

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

@@ -0,0 +1,7 @@
+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.
+ */
+export declare function buildGlobalInjectorAssets(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, triggers: ResolvedLazyTrigger[], currentIntegrationName: string): Promise<ProcessedAsset[]>;

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

@@ -0,0 +1,32 @@
+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";
+async function buildGlobalInjectorAssets(appConfig, assetProcessingService, triggers, currentIntegrationName) {
+  const appProjectDir = appConfig.rootDir ?? appConfig.absolutePaths?.projectDir ?? process.cwd();
+  const appPackageRequire = createRequire(path.join(appProjectDir, "package.json"));
+  const corePackageEntryPath = appPackageRequire.resolve("@ecopages/core");
+  const globalInjectorImportPath = createRequire(corePackageEntryPath).resolve("@ecopages/scripts-injector/global");
+  const mapScript = AssetFactory.createInlineContentScript({
+    position: "head",
+    name: "ecopages-global-injector-map",
+    content: buildGlobalInjectorMapScript(triggers),
+    attributes: { type: "ecopages/global-injector-map" },
+    packageRole: "keep-separate",
+    bundle: false
+  });
+  const bootstrapInlineScript = AssetFactory.createInlineContentScript({
+    position: "head",
+    name: "ecopages-global-injector-bootstrap",
+    content: buildGlobalInjectorBootstrapContent(globalInjectorImportPath),
+    attributes: { type: "module" },
+    packageRole: "keep-separate",
+    bundle: true
+  });
+  return assetProcessingService.processDependencies([mapScript, bootstrapInlineScript], currentIntegrationName);
+}
+export {
+  buildGlobalInjectorAssets
+};

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

@@ -0,0 +1,9 @@
+import type { EcoPageFile, PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../../../types/public-types.js';
+/**
+ * Loads a page module once and collects declarative browser-graph requirements.
+ *
+ * @remarks
+ * Shared by route orchestration prep and the integration route-render adapter so
+ * page imports are not duplicated when both paths need the same contribution.
+ */
+export declare function loadPageBrowserGraphContribution(routeFile: string, importPageFile: (file: string) => Promise<EcoPageFile>, collectContribution: (context: PageBrowserGraphContributionContext) => Promise<PageBrowserGraphContribution | undefined>): Promise<PageBrowserGraphContribution | undefined>;