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

package/src/route-renderer/orchestration/render-output.utils.js

@@ -0,0 +1,171 @@
+import { buildInjectorMapScript } from "../../eco/lazy-injector-map.js";
+function cloneTemplateStrings(strings, firstString) {
+  const nextStrings = [...strings];
+  nextStrings[0] = firstString;
+  const rawDescriptor = Object.getOwnPropertyDescriptor(strings, "raw");
+  if (rawDescriptor && Array.isArray(rawDescriptor.value)) {
+    const rawStrings = [...rawDescriptor.value];
+    rawStrings[0] = firstString;
+    Object.defineProperty(nextStrings, "raw", {
+      ...rawDescriptor,
+      value: rawStrings
+    });
+  }
+  return nextStrings;
+}
+function cloneTemplateContentWithUpdatedFirstString(content, firstString) {
+  const descriptors = Object.getOwnPropertyDescriptors(content);
+  const clonedContent = Object.create(Object.getPrototypeOf(content));
+  const stringsDescriptor = descriptors.strings;
+  Object.defineProperties(clonedContent, {
+    ...descriptors,
+    strings: {
+      ...stringsDescriptor,
+      value: cloneTemplateStrings(content.strings, firstString)
+    }
+  });
+  return clonedContent;
+}
+function cloneMarkupNodeLikeWithUpdatedOuterHtml(content, outerHTML) {
+  const descriptors = Object.getOwnPropertyDescriptors(content);
+  const clonedContent = Object.create(Object.getPrototypeOf(content));
+  const outerHTMLDescriptor = descriptors.outerHTML;
+  Object.defineProperties(clonedContent, {
+    ...descriptors,
+    outerHTML: {
+      configurable: outerHTMLDescriptor?.configurable ?? true,
+      enumerable: outerHTMLDescriptor?.enumerable ?? true,
+      writable: true,
+      value: outerHTML
+    }
+  });
+  return clonedContent;
+}
+function wrapWithScriptsInjectorMarkup(content, injectorMapScript) {
+  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${content}<\/scripts-injector>`;
+}
+function cloneTemplateContentWithWrappedInjector(content, injectorMapScript) {
+  if (content.strings.length === 0) {
+    return wrapWithScriptsInjectorMarkup(String(content), injectorMapScript);
+  }
+  const nextStrings = [...content.strings];
+  nextStrings[0] = wrapWithScriptsInjectorMarkup(nextStrings[0] ?? "", injectorMapScript);
+  nextStrings[nextStrings.length - 1] = `${nextStrings[nextStrings.length - 1] ?? ""}<\/scripts-injector>`;
+  const rawDescriptor = Object.getOwnPropertyDescriptor(content.strings, "raw");
+  if (rawDescriptor && Array.isArray(rawDescriptor.value)) {
+    const rawStrings = [...rawDescriptor.value];
+    rawStrings[0] = wrapWithScriptsInjectorMarkup(rawStrings[0] ?? "", injectorMapScript);
+    rawStrings[rawStrings.length - 1] = `${rawStrings[rawStrings.length - 1] ?? ""}<\/scripts-injector>`;
+    Object.defineProperty(nextStrings, "raw", {
+      ...rawDescriptor,
+      value: rawStrings
+    });
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(content);
+  const clonedContent = Object.create(Object.getPrototypeOf(content));
+  const stringsDescriptor = descriptors.strings;
+  Object.defineProperties(clonedContent, {
+    ...descriptors,
+    strings: {
+      ...stringsDescriptor,
+      value: nextStrings
+    }
+  });
+  return clonedContent;
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function isTemplateContentShape(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.strings) && ((value.values ?? void 0) === void 0 || Array.isArray(value.values));
+}
+function isMarkupNodeLikeShape(value) {
+  return typeof value === "object" && value !== null && typeof value.nodeType === "number";
+}
+function injectTriggerAttributeIntoString(content, triggerId) {
+  const str = content;
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] !== "<") {
+      i++;
+      continue;
+    }
+    const next = str[i + 1];
+    if (next === "!" || next === "?") {
+      const end = str.indexOf(">", i);
+      if (end === -1) break;
+      i = end + 1;
+      continue;
+    }
+    if (next && /[a-zA-Z]/.test(next)) {
+      const tagSlice = str.slice(i + 1);
+      const nameEnd = tagSlice.search(/[\s/>]/);
+      if (nameEnd === -1) break;
+      const insertAt = i + 1 + nameEnd;
+      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
+    }
+    break;
+  }
+  return str;
+}
+function addTriggerAttribute(content, triggerId) {
+  if (isTemplateContentShape(content)) {
+    if (content.strings.length === 0) {
+      return String(content);
+    }
+    return cloneTemplateContentWithUpdatedFirstString(
+      content,
+      injectTriggerAttributeIntoString(content.strings[0] ?? "", triggerId)
+    );
+  }
+  if (isMarkupNodeLikeShape(content) && typeof content.outerHTML === "string") {
+    return cloneMarkupNodeLikeWithUpdatedOuterHtml(
+      content,
+      injectTriggerAttributeIntoString(content.outerHTML, triggerId)
+    );
+  }
+  return injectTriggerAttributeIntoString(String(content), triggerId);
+}
+function wrapWithScriptsInjector(content, lazyGroups) {
+  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
+  if (isTemplateContentShape(content)) {
+    return cloneTemplateContentWithWrappedInjector(content, injectorMapScript);
+  }
+  if (isMarkupNodeLikeShape(content) && typeof content.outerHTML === "string") {
+    return cloneMarkupNodeLikeWithUpdatedOuterHtml(
+      content,
+      wrapWithScriptsInjectorMarkup(content.outerHTML, injectorMapScript)
+    );
+  }
+  return wrapWithScriptsInjectorMarkup(String(content), injectorMapScript);
+}
+function decodeHtmlEntities(value) {
+  let decoded = value;
+  let previous;
+  do {
+    previous = decoded;
+    decoded = decoded.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&#x27;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+  } while (decoded !== previous);
+  return decoded;
+}
+function normalizeBoundaryArtifactHtml(html) {
+  return html.replace(
+    /&(?:amp;)?lt;eco-marker\b[\s\S]*?&(?:amp;)?gt;&(?:amp;)?lt;\/eco-marker&(?:amp;)?gt;/g,
+    (marker) => decodeHtmlEntities(marker)
+  );
+}
+function inspectBoundaryArtifactHtml(html) {
+  const normalizedHtml = normalizeBoundaryArtifactHtml(html);
+  return {
+    normalizedHtml,
+    hasUnresolvedBoundaryArtifacts: normalizedHtml.includes("<eco-marker")
+  };
+}
+export {
+  addTriggerAttribute,
+  decodeHtmlEntities,
+  inspectBoundaryArtifactHtml,
+  isThenable,
+  normalizeBoundaryArtifactHtml,
+  wrapWithScriptsInjector
+};

package/src/route-renderer/orchestration/render-preparation.service.d.ts

@@ -0,0 +1,120 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../../types/public-types.js';
+import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import { BoundaryPlanningService } from './boundary-planning.service.js';
+import { PagePackagingService } from './page-packaging.service.js';
+type ResolvedPageModule = {
+    Page: EcoPageFile['default'] | EcoPageComponent<any>;
+    getStaticProps?: GetStaticProps<Record<string, unknown>>;
+    getMetadata?: GetMetadata;
+    integrationSpecificProps: Record<string, unknown>;
+};
+export interface RenderPreparationCallbacks {
+    resolvePageModule(file: string): Promise<ResolvedPageModule>;
+    getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
+    resolvePageData(pageModule: {
+        getStaticProps?: GetStaticProps<Record<string, unknown>>;
+        getMetadata?: GetMetadata;
+    }, routeOptions: RouteRendererOptions): Promise<{
+        props: Record<string, unknown>;
+        metadata: PageMetadataProps;
+    }>;
+    resolveDependencies(components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
+    buildRouteRenderAssets(file: string): Promise<ProcessedAsset[]> | undefined;
+    shouldRenderPageComponent(input: {
+        Page: EcoComponent;
+        Layout?: EcoComponent;
+        options: RouteRendererOptions;
+    }): boolean;
+    renderPageComponent(input: {
+        component: EcoComponent;
+        props: Record<string, unknown>;
+    }): Promise<ComponentRenderResult>;
+}
+export interface RenderPreparationServiceDependencies {
+    boundaryPlanningService?: BoundaryPlanningService;
+    pagePackagingService?: PagePackagingService;
+}
+/**
+ * Prepares the normalized render inputs consumed by `IntegrationRenderer.execute()`.
+ *
+ * This service owns the orchestration that happens before the main HTML render:
+ * page module resolution, data loading, dependency aggregation, page-root
+ * component artifact capture, lazy trigger bootstrap generation, and request
+ * locals policy.
+ */
+export declare class RenderPreparationService {
+    private appConfig;
+    private assetProcessingService;
+    private readonly boundaryPlanningService;
+    private readonly pagePackagingService;
+    /**
+     * Creates the render-preparation orchestrator for one app instance.
+     *
+     * @remarks
+     * The service is app-scoped because it depends on finalized config defaults and
+     * the app-owned asset-processing pipeline while remaining renderer-agnostic.
+     */
+    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RenderPreparationServiceDependencies);
+    /**
+     * Builds the final render options object used by the integration-specific
+     * renderer.
+     *
+     * The returned object contains normalized page data, processed dependency
+     * state, component render artifacts, and the locals contract expected by the
+     * rest of the pipeline.
+     *
+     * @typeParam C Integration render output element type.
+     * @param routeOptions Route-level render inputs.
+     * @param currentIntegrationName Active integration name for this preparation pass.
+     * @param callbacks Renderer-specific hooks used during preparation.
+     * @returns Normalized render options.
+     */
+    prepare<C = EcoPagesElement>(routeOptions: RouteRendererOptions, currentIntegrationName: string, callbacks: RenderPreparationCallbacks): Promise<IntegrationRendererRenderOptions<C>>;
+    /**
+     * Collects resolved lazy trigger metadata from the component tree.
+     *
+     * Traversal is depth-first and deduplicated by component identity so shared
+     * component dependencies do not emit duplicate trigger sets.
+     *
+     * @param components Root component set.
+     * @param seen Internal visited set for shared graphs.
+     * @returns All resolved lazy triggers reachable from the root set.
+     */
+    private collectResolvedTriggers;
+    /**
+     * Collects global integration dependencies used by nested components belonging
+     * to integrations other than the current renderer.
+     *
+     * @param components Root component set.
+     * @returns Processed integration dependencies contributed by nested integrations.
+     */
+    private collectUsedIntegrationDependencies;
+    /**
+     * Discovers integration names referenced by the component dependency graph.
+     *
+     * @param components Root component set.
+     * @param seen Internal visited set for shared graphs.
+     * @returns Set of integration names found in the graph.
+     */
+    private collectIntegrationNames;
+    /**
+     * Renders the page root through the component-level render contract so any
+     * integration-specific assets and root attributes are available before the main
+     * document render.
+     *
+     * @param input Page root render inputs.
+     * @returns Structured component render result.
+     */
+    private renderPageRoot;
+    /**
+     * Builds the runtime assets needed to bootstrap global lazy trigger execution.
+     *
+     * @param triggers Fully resolved lazy trigger definitions.
+     * @returns Processed assets that should be merged into the final dependency set.
+     */
+    private buildGlobalInjectorAssets;
+    private buildEagerSsrLazyAssets;
+    private collectEagerSsrLazyDependencies;
+}
+export {};

package/src/route-renderer/orchestration/render-preparation.service.js

@@ -0,0 +1,364 @@
+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";
+import { LocalsAccessError } from "../../errors/locals-access-error.js";
+import { BoundaryPlanningService } from "./boundary-planning.service.js";
+import { PagePackagingService } from "./page-packaging.service.js";
+import { dedupeProcessedAssets } from "./processed-asset-dedupe.js";
+function createPageLocalsProxy(filePath) {
+  const errorMessage = `[ecopages] Request locals are only available during request-time rendering with cache: 'dynamic'. Page: ${filePath}. If you meant to use locals here, set cache: 'dynamic' and provide locals from route middleware/handlers.`;
+  return new Proxy(
+    {},
+    {
+      get: () => {
+        throw new LocalsAccessError(errorMessage);
+      },
+      set: () => {
+        throw new LocalsAccessError(errorMessage);
+      },
+      has: () => {
+        throw new LocalsAccessError(errorMessage);
+      },
+      ownKeys: () => {
+        throw new LocalsAccessError(errorMessage);
+      },
+      deleteProperty: () => {
+        throw new LocalsAccessError(errorMessage);
+      },
+      defineProperty: () => {
+        throw new LocalsAccessError(errorMessage);
+      },
+      getOwnPropertyDescriptor: () => {
+        throw new LocalsAccessError(errorMessage);
+      }
+    }
+  );
+}
+class RenderPreparationService {
+  appConfig;
+  assetProcessingService;
+  boundaryPlanningService;
+  pagePackagingService;
+  /**
+   * Creates the render-preparation orchestrator for one app instance.
+   *
+   * @remarks
+   * The service is app-scoped because it depends on finalized config defaults and
+   * the app-owned asset-processing pipeline while remaining renderer-agnostic.
+   */
+  constructor(appConfig, assetProcessingService, dependencies = {}) {
+    this.appConfig = appConfig;
+    this.assetProcessingService = assetProcessingService;
+    this.boundaryPlanningService = dependencies.boundaryPlanningService ?? new BoundaryPlanningService(appConfig);
+    this.pagePackagingService = dependencies.pagePackagingService ?? new PagePackagingService();
+  }
+  /**
+   * Builds the final render options object used by the integration-specific
+   * renderer.
+   *
+   * The returned object contains normalized page data, processed dependency
+   * state, component render artifacts, and the locals contract expected by the
+   * rest of the pipeline.
+   *
+   * @typeParam C Integration render output element type.
+   * @param routeOptions Route-level render inputs.
+   * @param currentIntegrationName Active integration name for this preparation pass.
+   * @param callbacks Renderer-specific hooks used during preparation.
+   * @returns Normalized render options.
+   */
+  async prepare(routeOptions, currentIntegrationName, callbacks) {
+    const pageModule = await callbacks.resolvePageModule(routeOptions.file);
+    const { Page, integrationSpecificProps } = pageModule;
+    const HtmlTemplate = await callbacks.getHtmlTemplate();
+    const { props, metadata } = await callbacks.resolvePageData(pageModule, routeOptions);
+    const Layout = Page.config?.layout;
+    const boundaryPlan = this.boundaryPlanningService.buildPlan({
+      routeFile: routeOptions.file,
+      currentIntegrationName,
+      HtmlTemplate,
+      Layout,
+      Page
+    });
+    const componentsToResolve = Layout ? [HtmlTemplate, Layout, Page] : [HtmlTemplate, Page];
+    const resolvedDependencies = await callbacks.resolveDependencies(componentsToResolve);
+    const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(
+      componentsToResolve,
+      currentIntegrationName
+    );
+    const pageDeps = await callbacks.buildRouteRenderAssets(routeOptions.file) || [];
+    const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
+    let componentRender;
+    if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
+      const pageRootRender = await this.renderPageRoot({
+        Page,
+        props,
+        routeOptions,
+        callbacks
+      });
+      componentRender = pageRootRender.componentRender;
+      if (componentRender.assets?.length) {
+        allDependencies.push(...componentRender.assets);
+      }
+    }
+    const triggers = this.collectResolvedTriggers(componentsToResolve);
+    if (triggers.length > 0) {
+      const globalAssets = await this.buildGlobalInjectorAssets(triggers, currentIntegrationName);
+      allDependencies.push(...globalAssets);
+    }
+    const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, currentIntegrationName);
+    if (eagerSsrLazyAssets.length > 0) {
+      allDependencies.push(...eagerSsrLazyAssets);
+    }
+    const dedupedDependencies = dedupeProcessedAssets(allDependencies);
+    const pagePackage = this.pagePackagingService.createPagePackage(dedupedDependencies);
+    const pageProps = {
+      ...props,
+      params: routeOptions.params || {},
+      query: routeOptions.query || {}
+    };
+    const cacheStrategy = Page.cache;
+    const defaultCacheStrategy = this.appConfig.cache?.defaultStrategy ?? "static";
+    const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
+    const localsAvailable = effectiveCacheStrategy === "dynamic" && routeOptions.locals !== void 0;
+    const pageLocals = localsAvailable ? routeOptions.locals : createPageLocalsProxy(routeOptions.file);
+    const locals = localsAvailable ? routeOptions.locals : void 0;
+    const preparedOptions = {
+      ...routeOptions,
+      resolvedDependencies,
+      pagePackage,
+      componentRender,
+      HtmlTemplate,
+      Layout,
+      props,
+      Page,
+      metadata,
+      params: routeOptions.params || {},
+      query: routeOptions.query || {},
+      pageProps,
+      locals,
+      pageLocals,
+      cacheStrategy,
+      boundaryPlan
+    };
+    return {
+      ...integrationSpecificProps,
+      ...preparedOptions
+    };
+  }
+  /**
+   * Collects resolved lazy trigger metadata from the component tree.
+   *
+   * Traversal is depth-first and deduplicated by component identity so shared
+   * component dependencies do not emit duplicate trigger sets.
+   *
+   * @param components Root component set.
+   * @param seen Internal visited set for shared graphs.
+   * @returns All resolved lazy triggers reachable from the root set.
+   */
+  collectResolvedTriggers(components, seen = /* @__PURE__ */ new Set()) {
+    const triggers = [];
+    for (const comp of components) {
+      if (!comp) {
+        continue;
+      }
+      const ecoComp = comp;
+      if (seen.has(ecoComp)) {
+        continue;
+      }
+      seen.add(ecoComp);
+      const ownTriggers = ecoComp.config?._resolvedLazyTriggers;
+      if (ownTriggers?.length) {
+        triggers.push(...ownTriggers);
+      }
+      const nested = ecoComp.config?.dependencies?.components;
+      if (nested?.length) {
+        triggers.push(...this.collectResolvedTriggers(nested, seen));
+      }
+    }
+    return triggers;
+  }
+  /**
+   * Collects global integration dependencies used by nested components belonging
+   * to integrations other than the current renderer.
+   *
+   * @param components Root component set.
+   * @returns Processed integration dependencies contributed by nested integrations.
+   */
+  collectUsedIntegrationDependencies(components, currentIntegrationName) {
+    const integrationNames = this.collectIntegrationNames(components);
+    const dependencies = [];
+    for (const integrationName of integrationNames) {
+      if (integrationName === currentIntegrationName) {
+        continue;
+      }
+      const integrationPlugin = this.appConfig.integrations.find(
+        (integration) => integration.name === integrationName
+      );
+      if (!integrationPlugin || typeof integrationPlugin.getResolvedIntegrationDependencies !== "function") {
+        continue;
+      }
+      dependencies.push(...integrationPlugin.getResolvedIntegrationDependencies());
+    }
+    return dependencies;
+  }
+  /**
+   * Discovers integration names referenced by the component dependency graph.
+   *
+   * @param components Root component set.
+   * @param seen Internal visited set for shared graphs.
+   * @returns Set of integration names found in the graph.
+   */
+  collectIntegrationNames(components, seen = /* @__PURE__ */ new Set()) {
+    const integrationNames = /* @__PURE__ */ new Set();
+    for (const comp of components) {
+      if (!comp) {
+        continue;
+      }
+      const ecoComp = comp;
+      if (seen.has(ecoComp)) {
+        continue;
+      }
+      seen.add(ecoComp);
+      const integrationName = ecoComp.config?.integration ?? ecoComp.config?.__eco?.integration;
+      if (integrationName) {
+        integrationNames.add(integrationName);
+      }
+      const nested = ecoComp.config?.dependencies?.components;
+      if (nested?.length) {
+        const nestedNames = this.collectIntegrationNames(nested, seen);
+        for (const nestedName of nestedNames) {
+          integrationNames.add(nestedName);
+        }
+      }
+    }
+    return integrationNames;
+  }
+  /**
+   * Renders the page root through the component-level render contract so any
+   * integration-specific assets and root attributes are available before the main
+   * document render.
+   *
+   * @param input Page root render inputs.
+   * @returns Structured component render result.
+   */
+  async renderPageRoot(input) {
+    return {
+      componentRender: await input.callbacks.renderPageComponent({
+        component: input.Page,
+        props: {
+          ...input.props,
+          params: input.routeOptions.params || {},
+          query: input.routeOptions.query || {}
+        }
+      })
+    };
+  }
+  /**
+   * Builds the runtime assets needed to bootstrap global lazy trigger execution.
+   *
+   * @param triggers Fully resolved lazy trigger definitions.
+   * @returns Processed assets that should be merged into the final dependency set.
+   */
+  async buildGlobalInjectorAssets(triggers, currentIntegrationName) {
+    const globalInjectorImportPath = createRequire(import.meta.url).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 this.assetProcessingService.processDependencies([mapScript, bootstrapInlineScript], currentIntegrationName);
+  }
+  async buildEagerSsrLazyAssets(components, currentIntegrationName) {
+    const dependencies = this.collectEagerSsrLazyDependencies(components);
+    if (dependencies.length === 0) {
+      return [];
+    }
+    return this.assetProcessingService.processDependencies(dependencies, `${currentIntegrationName}:ssr-lazy`);
+  }
+  collectEagerSsrLazyDependencies(components) {
+    const dependencies = [];
+    const visitedConfigs = /* @__PURE__ */ new Set();
+    const seenKeys = /* @__PURE__ */ new Set();
+    const normalizeAttributes = (attributes) => ({
+      type: "module",
+      defer: "",
+      ...attributes ?? {}
+    });
+    const collect = (config) => {
+      if (!config || visitedConfigs.has(config)) {
+        return;
+      }
+      visitedConfigs.add(config);
+      const componentFile = config.__eco?.file;
+      if (componentFile) {
+        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"
+            })
+          );
+        }
+      }
+      if (config.layout?.config) {
+        collect(config.layout.config);
+      }
+      for (const nestedComponent of config.dependencies?.components ?? []) {
+        collect(nestedComponent?.config);
+      }
+    };
+    for (const component of components) {
+      collect(component.config);
+    }
+    return dependencies;
+  }
+}
+export {
+  RenderPreparationService
+};