@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.20

package/src/plugins/jsx-import-source.utils.d.ts

@@ -0,0 +1,8 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+export declare function createJsxImportSourcePragma(jsxImportSource: string): string;
+export declare function prependJsxImportSourceIfMissing(code: string, jsxImportSource: string | undefined): string;
+export declare function isJsxSourceExtension(extension: string): boolean;
+export declare function filterJsxSourceExtensions(extensions: string[]): string[];
+export declare function collectJsxExtensions(integrations: NonNullable<EcoPagesAppConfig['integrations']>, options?: {
+    excludeIntegrationName?: string;
+}): string[];

package/src/plugins/jsx-import-source.utils.js

@@ -0,0 +1,26 @@
+function createJsxImportSourcePragma(jsxImportSource) {
+  return `/** @jsxImportSource ${jsxImportSource} */
+`;
+}
+function prependJsxImportSourceIfMissing(code, jsxImportSource) {
+  if (!jsxImportSource || code.includes("@jsxImportSource")) {
+    return code;
+  }
+  return createJsxImportSourcePragma(jsxImportSource) + code;
+}
+function isJsxSourceExtension(extension) {
+  return extension.endsWith(".tsx") || extension.endsWith(".jsx");
+}
+function filterJsxSourceExtensions(extensions) {
+  return extensions.filter(isJsxSourceExtension);
+}
+function collectJsxExtensions(integrations, options) {
+  return integrations.filter((integration) => integration.jsxImportSource).filter((integration) => integration.name !== options?.excludeIntegrationName).flatMap((integration) => filterJsxSourceExtensions(integration.extensions));
+}
+export {
+  collectJsxExtensions,
+  createJsxImportSourcePragma,
+  filterJsxSourceExtensions,
+  isJsxSourceExtension,
+  prependJsxImportSourceIfMissing
+};

package/src/plugins/processor.d.ts

@@ -1,6 +1,5 @@
 import type { EcoBuildPlugin } from '../build/build-types.js';
 import type { EcoPagesAppConfig, IClientBridge } from '../types/internal-types.js';
-import type { AssetDefinition } from '../services/assets/asset-processing-service/assets.types.js';
 import type { RuntimeCapabilityDeclaration } from './runtime-capability.js';
 export type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from './runtime-capability.js';
 export type { EcoBuildLoader, EcoBuildOnLoadArgs, EcoBuildOnLoadResult, EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin, EcoBuildPluginBuilder, } from '../build/build-types.js';
@@ -59,7 +58,6 @@ export interface ProcessorContext {
  */
 export declare abstract class Processor<TOptions = Record<string, unknown>> {
     readonly name: string;
-    protected dependencies: AssetDefinition[];
     protected context?: ProcessorContext;
     protected options?: TOptions;
     protected watchConfig?: ProcessorWatchConfig;
@@ -80,14 +78,31 @@ export declare abstract class Processor<TOptions = Record<string, unknown>> {
      * warming or watcher registration should stay in `setup()`.
      */
     prepareBuildContributions(): Promise<void>;
+    /**
+     * Reports whether this processor's build inputs changed since the last
+     * incremental static build.
+     *
+     * @remarks
+     * No shipped processor overrides this today. Integrations and processors can
+     * opt in when they own build inputs that should invalidate incremental static
+     * exports without a full rebuild.
+     */
+    didChange(): boolean;
     abstract setup(): Promise<void>;
-    abstract teardown(): Promise<void>;
     abstract process(input: unknown, filePath?: string): Promise<unknown>;
+    /**
+     * Releases runtime resources owned by the processor.
+     *
+     * @remarks
+     * Core does not call this hook today. Override only when a processor owns
+     * watchers, compiler handles, or other resources that outlive individual
+     * requests.
+     */
+    teardown(): Promise<void>;
     protected getCachePath(key: string): string;
     protected readCache<T>(key: string): Promise<T | null>;
     protected writeCache<T>(key: string, data: T): Promise<void>;
     getWatchConfig(): ProcessorWatchConfig | undefined;
-    getDependencies(): AssetDefinition[];
     getName(): string;
     getAssetCapabilities(): ProcessorAssetCapability[];
     matchesFileFilter(_filepath: string): boolean;

package/src/plugins/processor.js

@@ -16,7 +16,6 @@ function resolveGeneratedPath(type, options) {
 }
 class Processor {
   name;
-  dependencies = [];
   context;
   options;
   watchConfig;
@@ -54,6 +53,28 @@ class Processor {
    */
   async prepareBuildContributions() {
   }
+  /**
+   * Reports whether this processor's build inputs changed since the last
+   * incremental static build.
+   *
+   * @remarks
+   * No shipped processor overrides this today. Integrations and processors can
+   * opt in when they own build inputs that should invalidate incremental static
+   * exports without a full rebuild.
+   */
+  didChange() {
+    return false;
+  }
+  /**
+   * Releases runtime resources owned by the processor.
+   *
+   * @remarks
+   * Core does not call this hook today. Override only when a processor owns
+   * watchers, compiler handles, or other resources that outlive individual
+   * requests.
+   */
+  async teardown() {
+  }
   getCachePath(key) {
     return `${this.context?.cache}/${key}`;
   }
@@ -76,9 +97,6 @@ class Processor {
   getWatchConfig() {
     return this.watchConfig;
   }
-  getDependencies() {
-    return this.dependencies;
-  }
   getName() {
     return this.name;
   }

package/src/plugins/source-transform.d.ts

@@ -4,9 +4,21 @@ export interface EcoSourceTransformResult {
     code: string;
     map?: unknown;
 }
+/**
+ * Bundler-neutral source transform registered on {@link EcoPagesAppConfig.sourceTransforms}.
+ *
+ * @remarks
+ * Prefer this shape over a competing {@link EcoBuildPlugin} `onLoad` handler when
+ * the transform only rewrites module source. Browser/HMR builds run source
+ * transforms after first-wins `onLoad` plugins, so metadata injection and similar
+ * passes still run on rewritten output from boundary/runtime plugins.
+ */
 export interface EcoSourceTransform {
+    /** Stable transform name. Also used to dedupe loader plugins in browser builds. */
     name: string;
+    /** File-path filter tested against {@link normalizeTransformId | normalized ids}. */
     filter: RegExp;
+    /** Runs before default transforms, or after them when set to `post`. */
     enforce?: 'pre' | 'post';
     transform(code: string, id: string): EcoSourceTransformResult | string | undefined;
 }
@@ -24,8 +36,27 @@ export declare function normalizeTransformId(id: string): string;
  * Applies one source transform if the normalized id matches its filter.
  */
 export declare function applySourceTransform(transform: EcoSourceTransform, code: string, id: string): EcoSourceTransformResult | string | undefined;
+/**
+ * Applies app-owned source transforms in deterministic `pre` → default → `post` order.
+ *
+ * @remarks
+ * Used by the Rolldown plugin bridge after `onLoad` plugins produce final module
+ * contents. Transforms that do not match `filter` are skipped; matching transforms
+ * are chained left-to-right on the current source string.
+ *
+ * @param transforms - App-owned transforms, usually from {@link getAppSourceTransforms}.
+ * @param code - Current module source.
+ * @param id - Module id forwarded to each transform after query/hash normalization.
+ * @returns The transformed source, or the original `code` when no transform matches.
+ */
+export declare function applySourceTransforms(transforms: readonly EcoSourceTransform[], code: string, id: string): string;
 /**
  * Adapts a source transform into the existing Ecopages build-plugin contract.
+ *
+ * @remarks
+ * Server-oriented builds and loader registration still use this adapter.
+ * Browser/HMR builds should register the transform in `appConfig.sourceTransforms`
+ * instead so the Rolldown bridge can run it after competing `onLoad` plugins.
  */
 export declare function createEcoBuildPluginFromSourceTransform(transform: EcoSourceTransform): EcoBuildPlugin;
 /**

package/src/plugins/source-transform.js

@@ -13,6 +13,27 @@ function applySourceTransform(transform, code, id) {
   }
   return transform.transform(code, normalizedId);
 }
+const SOURCE_TRANSFORM_ENFORCE_ORDER = {
+  pre: 0,
+  default: 1,
+  post: 2
+};
+function getSourceTransformEnforceOrder(transform) {
+  return SOURCE_TRANSFORM_ENFORCE_ORDER[transform.enforce ?? "default"];
+}
+function applySourceTransforms(transforms, code, id) {
+  let current = code;
+  for (const transform of [...transforms].sort(
+    (left, right) => getSourceTransformEnforceOrder(left) - getSourceTransformEnforceOrder(right)
+  )) {
+    const result = applySourceTransform(transform, current, id);
+    if (!result) {
+      continue;
+    }
+    current = typeof result === "string" ? result : result.code;
+  }
+  return current;
+}
 function inferLoaderFromPath(filePath) {
   const extension = path.extname(filePath).toLowerCase();
   switch (extension) {
@@ -56,13 +77,14 @@ function createVitePluginFromSourceTransform(transform) {
   };
 }
 function getAppSourceTransforms(appConfig) {
-  return Array.from(appConfig.sourceTransforms.values());
+  return appConfig.sourceTransforms ? Array.from(appConfig.sourceTransforms.values()) : [];
 }
 function createVitePluginsFromAppSourceTransforms(appConfig) {
   return getAppSourceTransforms(appConfig).map((transform) => createVitePluginFromSourceTransform(transform));
 }
 export {
   applySourceTransform,
+  applySourceTransforms,
   createEcoBuildPluginFromSourceTransform,
   createVitePluginFromSourceTransform,
   createVitePluginsFromAppSourceTransforms,

package/src/route-renderer/GRAPH.md

@@ -33,15 +33,15 @@ flowchart TD
 
 ## 2) Route Render Flow
 
-`IntegrationRenderer.execute()` delegates shared route orchestration to `RouteRenderFlow`.
+`IntegrationRenderer.execute()` delegates shared route orchestration to `RouteRenderOrchestrator`.
 
 ```mermaid
 flowchart TD
-  A[IntegrationRenderer.execute] --> B[RouteRenderFlow.prepareRenderOptions]
+  A[IntegrationRenderer.execute] --> B[RouteRenderOrchestrator.prepareRenderOptions]
   B --> C[resolvePageModule]
   C --> D[ownershipValidationService.validate]
   D --> E[resolvePageData]
-  E --> F[ownershipPlanningService.buildPlan]
+  E --> F[ownershipValidationService.validate + throwIfOwnershipInvalid]
   F --> G[resolveDependencies]
   G --> H[buildPageBrowserGraph]
   H --> I{shouldRenderPageComponent?}
@@ -77,7 +77,7 @@ flowchart TD
   D -- Yes --> E[render inline]
   D -- No --> F[delegate to owning renderer]
   F --> G[owning renderer renderComponentWithForeignChildren]
-  G --> H[owning renderer renderForeignSubtree when payload form is needed]
+  G --> H[owning renderer renderComponentWithForeignChildren mapped via toForeignSubtreeRenderPayload]
   H --> I[resolved html plus assets and attachment policy]
 ```
 
@@ -121,12 +121,12 @@ flowchart TD
 The most useful reading order is:
 
 1. `route-renderer.ts`
-2. `orchestration/route-render-flow.ts`
+2. `orchestration/route-render-orchestrator.ts`
 3. `orchestration/integration-renderer.ts`
 4. `orchestration/ownership-validation.service.ts`
 5. `orchestration/ownership-planning.service.ts`
 6. `orchestration/component-render-context.ts`
-7. `orchestration/queued-foreign-subtree-resolution.service.ts`
+7. `orchestration/foreign-subtree-execution.service.ts`
 8. `page-loading/page-module-loader.ts`
 9. `page-loading/dependency-resolver.ts`
 10. `eco/eco.ts`
@@ -134,12 +134,12 @@ The most useful reading order is:
 ## 7) Key Files
 
 - `packages/core/src/route-renderer/route-renderer.ts`
-- `packages/core/src/route-renderer/orchestration/route-render-flow.ts`
+- `packages/core/src/route-renderer/orchestration/route-render-orchestrator.ts`
 - `packages/core/src/route-renderer/orchestration/integration-renderer.ts`
 - `packages/core/src/route-renderer/orchestration/ownership-validation.service.ts`
 - `packages/core/src/route-renderer/orchestration/ownership-planning.service.ts`
 - `packages/core/src/route-renderer/orchestration/component-render-context.ts`
-- `packages/core/src/route-renderer/orchestration/queued-foreign-subtree-resolution.service.ts`
+- `packages/core/src/route-renderer/orchestration/foreign-subtree-execution.service.ts`
 - `packages/core/src/route-renderer/page-loading/page-module-loader.ts`
 - `packages/core/src/route-renderer/page-loading/dependency-resolver.ts`
 - `packages/core/src/eco/eco.ts`

package/src/route-renderer/README.md

@@ -16,18 +16,30 @@ The route renderer layer is responsible for:
 
 The architecture is organized around three distinct concepts:
 
-- `ownership`: preparation-time metadata that describes which integration owns each declared component edge
+- `ownership`: declared component dependency metadata validated before render
 - `foreign child`: a component encountered during render whose owning integration differs from the current integration
 - `foreign subtree`: the resolved HTML, assets, and root-attachment metadata returned by the owning renderer for that foreign child
 
 These concepts intentionally live in different places:
 
-- `ownership-planning.service.ts` builds `ownershipPlan`
-- `ownership-validation.service.ts` validates declared foreign ownership up front
+- `ownership-validation.service.ts` validates declared foreign ownership up front and fails the render on misconfiguration
 - `component-render-context.ts` intercepts foreign children during active component render
-- `queued-foreign-subtree-resolution.service.ts` resolves queued foreign subtrees for renderers that cannot hand them off inline
-- `integration-renderer.ts` owns renderer-to-renderer delegation and shared shell composition
-- `route-render-flow.ts` owns route preparation, final response capture, and unresolved artifact enforcement
+- `foreign-subtree-execution.service.ts` owns mixed-integration execution policy and queued token resolution
+- `document-shell-render.service.ts` composes page, layout, and html template shells with one execution-scoped renderer cache
+- `integration-renderer.ts` owns renderer-to-renderer delegation and integration-specific render hooks
+- `route-render-orchestrator.ts` owns route preparation, final response capture, and unresolved artifact enforcement
+
+## Build-Time JSX vs Runtime Foreign Children
+
+Mixed-integration apps use two separate mechanisms:
+
+| Layer   | Mechanism                                                         | Purpose                                                                                  |
+| ------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| Build   | `getJsxOwnershipPlugins()` / `getHostScopedJsxOwnershipPlugins()` | Prepend `@jsxImportSource` so bundled `.tsx` files compile with the correct JSX runtime  |
+| Build   | `eco-component-meta-plugin`                                       | Prepends the owning integration pragma when injecting `__eco` metadata into native files |
+| Runtime | `eco.component()` / `eco.embed()` + foreign-child runtime         | Hand off cross-integration children during SSR                                           |
+
+See [`../build/README.md`](../build/README.md) for the JSX ownership helper split.
 
 ## Main Files
 
@@ -38,12 +50,12 @@ These concepts intentionally live in different places:
 
 ### `orchestration/`
 
-- `route-render-flow.ts`: one route render from page-module loading through final HTML output
+- `route-render-orchestrator.ts`: one route render from page-module loading through final HTML output
 - `integration-renderer.ts`: abstract base class for route rendering, explicit view rendering, and foreign-child delegation
-- `ownership-planning.service.ts`: declared ownership graph construction
 - `ownership-validation.service.ts`: up-front ownership validation for route roots and declared descendants
+- `foreign-subtree-execution.service.ts`: foreign-child execution policy, queue token resolution, and `toForeignSubtreeRenderPayload()`
+- `document-shell-render.service.ts`: shared page/layout/html shell composition and attribute stamping helpers
 - `component-render-context.ts`: active render context used by `eco.component()` to intercept foreign children
-- `queued-foreign-subtree-resolution.service.ts`: queue resolution for renderers that need token-based foreign-subtree handoff
 - `render-output.utils.ts`: unresolved artifact normalization and marker inspection
 
 ### `page-loading/`
@@ -56,11 +68,11 @@ These concepts intentionally live in different places:
 The route-render contract is:
 
 1. `RouteRendererFactory` selects the owning integration renderer.
-2. `IntegrationRenderer.execute()` delegates preparation and finalization to `RouteRenderFlow`.
-3. `RouteRenderFlow.prepareRenderOptions()` loads the page module, validates ownership, builds `ownershipPlan`, resolves page data, resolves dependencies, and builds the page browser graph.
+2. `IntegrationRenderer.execute()` delegates preparation and finalization to `RouteRenderOrchestrator`.
+3. `RouteRenderOrchestrator.prepareRenderOptions()` loads the page module, validates ownership (fail-fast), resolves page data, resolves dependencies, and builds the page browser graph.
 4. The integration renderer performs page, layout, and document-shell rendering. When it encounters a foreign child, it delegates that child back to the owning renderer.
 5. If a renderer needs queued handoff, it emits internal foreign-subtree tokens and resolves them before returning final HTML.
-6. `RouteRenderFlow.execute()` captures the final body, rejects unresolved `<eco-marker>` artifacts, stamps root or document attributes when needed, and runs the HTML transformer.
+6. `RouteRenderOrchestrator.executePrepared()` captures the final body, rejects unresolved `<eco-marker>` artifacts, stamps root or document attributes when needed, and runs the HTML transformer.
 
 Important:
 
@@ -72,38 +84,28 @@ Important:
 
 Mixed-integration component configs must declare every possible foreign child in `config.dependencies.components`.
 
-That declaration is used for two things:
-
-- `OwnershipValidationService` surfaces missing metadata or unknown integrations before render execution
-- `OwnershipPlanningService` records the expected ownership shape in `ownershipPlan`
+`OwnershipValidationService` surfaces missing metadata or unknown integrations during `prepareRenderOptions()` and throws before render execution starts.
 
 At runtime, renderers still discover actual foreign children through the active component render context.
 
 ## Foreign Subtree Contract
 
-`renderForeignSubtree()` is the compatibility contract for renderer-to-renderer handoff. It returns:
-
-- `html`
-- `assets`
-- `rootTag`
-- optional `rootAttributes`
-- `attachmentPolicy`
-- `integrationName`
-
-`renderComponentWithForeignChildren()` is the higher-level renderer entrypoint. It is responsible for:
+`renderComponentWithForeignChildren()` is the renderer entrypoint for mixed-integration trees. It is responsible for:
 
 - reusing the execution-scoped owning-renderer cache
 - deciding whether the current component can stay local
 - creating a foreign-child runtime when nested foreign ownership must be resolved
 - normalizing unresolved artifact HTML before the render leaves the renderer
 
+Queue resolution maps owning-renderer output into the foreign-subtree payload shape via `toForeignSubtreeRenderPayload()` inside `foreign-subtree-execution.service.ts`.
+
 ## Queue Model
 
 Not every integration needs queue-based handoff.
 
 - If a renderer can resolve a foreign child inline, it returns resolved output immediately.
 - If it cannot, it may emit internal foreign-subtree tokens and resolve them before returning final HTML.
-- The queue service is only for renderer-owned transport inside one render pass. It is not a general route-level fallback mechanism.
+- Queue mechanics live inside `ForeignSubtreeExecutionService`; they are renderer-owned transport inside one render pass, not a general route-level fallback mechanism.
 
 ## React Island Notes
 
@@ -114,5 +116,5 @@ Not every integration needs queue-based handoff.
 
 ## Current Limits
 
-- `ownershipPlan` is still diagnostic and preparatory metadata; it does not yet drive a full route-composer execution model.
 - Different integrations still own different foreign-child runtime strategies, which is intentional where child transport or hydration behavior differs.
+- `integration-renderer.ts` remains the largest integration hook surface even after document-shell extraction.

package/src/route-renderer/orchestration/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/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/component-graph.d.ts

@@ -0,0 +1,36 @@
+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[];
+/** @deprecated Use `mapComponentGraph` from `component-graph.ts`. */
+export declare const mapDeclaredOwnershipGraph: typeof mapComponentGraph;