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

package/src/route-renderer/orchestration/document-shell-render.service.js

@@ -0,0 +1,120 @@
+function resolveDocumentShellLayouts(input) {
+  if (input.layouts && input.layouts.length > 0) {
+    return input.layouts;
+  }
+  return input.layout ? [input.layout] : [];
+}
+function resolveComponentIntegrationName(component) {
+  return component.config?.integration ?? component.config?.__eco?.integration ?? "ecopages";
+}
+async function composeSequentialLayoutChildren(context) {
+  if (!context.primaryRender) {
+    throw new Error("[ecopages] composeSequentialLayoutChildren requires primaryRender.");
+  }
+  let children = context.primaryRender.html;
+  const layoutRenders = [];
+  for (const layout of [...context.layouts].reverse()) {
+    const layoutRender = await context.renderComponentWithForeignChildren({
+      component: layout.component,
+      props: layout.props ?? {},
+      children,
+      integrationContext: { rendererCache: context.rendererCache }
+    });
+    layoutRenders.push(layoutRender);
+    children = layoutRender.html;
+  }
+  return {
+    children,
+    layoutRenders
+  };
+}
+async function composeDocumentShell(dependencies, input) {
+  const rendererCache = /* @__PURE__ */ new Map();
+  const layouts = resolveDocumentShellLayouts(input);
+  const composeChildren = input.composeChildren ?? composeSequentialLayoutChildren;
+  const usesCustomComposeChildren = input.composeChildren !== void 0;
+  let primaryRender;
+  let children;
+  let layoutRenders;
+  if (usesCustomComposeChildren) {
+    const composed = await composeChildren({
+      primaryComponent: input.primaryComponent,
+      primaryProps: input.primaryProps,
+      layouts,
+      rendererCache,
+      renderComponentWithForeignChildren: dependencies.renderComponentWithForeignChildren
+    });
+    children = composed.children;
+    layoutRenders = composed.layoutRenders;
+    primaryRender = composed.primaryRender ?? {
+      html: typeof composed.children === "string" ? composed.children : "",
+      assets: [],
+      canAttachAttributes: true,
+      rootTag: "main",
+      integrationName: resolveComponentIntegrationName(input.primaryComponent)
+    };
+  } else {
+    primaryRender = await dependencies.renderComponentWithForeignChildren({
+      component: input.primaryComponent,
+      props: input.primaryProps,
+      integrationContext: { rendererCache }
+    });
+    const composed = await composeChildren({
+      primaryComponent: input.primaryComponent,
+      primaryProps: input.primaryProps,
+      primaryRender,
+      layouts,
+      rendererCache,
+      renderComponentWithForeignChildren: dependencies.renderComponentWithForeignChildren
+    });
+    children = composed.children;
+    layoutRenders = composed.layoutRenders;
+  }
+  const documentRender = await dependencies.renderComponentWithForeignChildren({
+    component: input.htmlTemplate,
+    props: input.documentProps,
+    children,
+    integrationContext: { rendererCache }
+  });
+  dependencies.appendProcessedDependencies(
+    primaryRender.assets,
+    ...layoutRenders.map((layoutRender) => layoutRender.assets),
+    documentRender.assets
+  );
+  return {
+    documentHtml: documentRender.html
+  };
+}
+function applyDocumentShellAttributeStamping(html, stamping, options) {
+  let nextHtml = html;
+  if (options.componentRootAttributes && Object.keys(options.componentRootAttributes).length > 0) {
+    nextHtml = stamping.applyAttributesToFirstBodyElement(nextHtml, options.componentRootAttributes);
+  }
+  if (options.documentAttributes && Object.keys(options.documentAttributes).length > 0) {
+    nextHtml = stamping.applyAttributesToHtmlElement(nextHtml, options.documentAttributes);
+  }
+  return nextHtml;
+}
+async function renderPageDocumentShell(dependencies, input, docType) {
+  const { documentHtml: composedDocumentHtml } = await composeDocumentShell(dependencies, {
+    primaryComponent: input.page.component,
+    primaryProps: input.page.props,
+    layout: input.layout,
+    layouts: input.layouts,
+    composeChildren: input.composeChildren,
+    htmlTemplate: input.htmlTemplate,
+    documentProps: {
+      metadata: input.metadata,
+      pageProps: input.pageProps,
+      ...input.documentProps ?? {}
+    }
+  });
+  const documentHtml = input.transformDocumentHtml ? input.transformDocumentHtml(composedDocumentHtml) : composedDocumentHtml;
+  return `${docType}${documentHtml}`;
+}
+export {
+  applyDocumentShellAttributeStamping,
+  composeDocumentShell,
+  composeSequentialLayoutChildren,
+  renderPageDocumentShell
+};

package/src/route-renderer/orchestration/foreign-subtree-execution.service.d.ts

@@ -1,11 +1,36 @@
 import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
 import type { BaseIntegrationContext, ComponentRenderInput, ComponentRenderResult, EcoComponent, ForeignSubtreeRenderPayload } from '../../types/public-types.js';
 import { type ForeignChildRuntime } from './component-render-context.js';
-import { QueuedForeignSubtreeResolutionService, type QueuedForeignSubtreeResolution, type QueuedForeignSubtreeResolutionContext } from './queued-foreign-subtree-resolution.service.js';
+export type QueuedForeignChildDecisionInput = {
+    currentIntegration: string;
+    targetIntegration?: string;
+    component: EcoComponent;
+    props: Record<string, unknown>;
+};
+export type QueuedForeignSubtreeResolution = {
+    token: string;
+    component: EcoComponent;
+    props: Record<string, unknown>;
+    componentInstanceId: string;
+};
+/**
+ * Shared mutable state for one renderer-owned queued foreign-subtree runtime.
+ */
+export type QueuedForeignSubtreeResolutionContext = {
+    rendererCache: Map<string, unknown>;
+    componentInstanceScope?: string;
+    nextForeignSubtreeId: number;
+    queuedResolutions: QueuedForeignSubtreeResolution[];
+};
+type QueuedForeignSubtreeIntegrationContext = BaseIntegrationContext & Record<string, unknown>;
+type QueuedForeignSubtreeChildRenderResult = {
+    assets: ProcessedAsset[];
+    html?: string;
+    children?: unknown;
+};
 export interface ForeignSubtreeExecutionOwningRenderer {
     readonly name: string;
     renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-    renderForeignSubtree(input: ComponentRenderInput): Promise<ForeignSubtreeRenderPayload>;
 }
 export interface ForeignSubtreeExecutionDecisionInput {
     currentIntegration: string;
@@ -54,34 +79,41 @@ export interface ForeignSubtreeQueuedHtmlOptions<TContext extends QueuedForeignS
     applyAttributesToFirstElement(html: string, attributes: Record<string, string>): string;
     dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
 }
+export interface ResolveQueuedForeignSubtreeTokensOptions<TContext extends QueuedForeignSubtreeResolutionContext> {
+    html: string;
+    runtimeContext?: TContext;
+    queueLabel: string;
+    renderQueuedChildren: (children: unknown, runtimeContext: TContext, queuedResolutionsByToken: Map<string, QueuedForeignSubtreeResolution>, resolveToken: (token: string) => Promise<string>) => Promise<QueuedForeignSubtreeChildRenderResult>;
+    resolveForeignSubtree: (input: ComponentRenderInput, rendererCache: Map<string, unknown>) => Promise<ForeignSubtreeRenderPayload | undefined>;
+    applyAttributesToFirstElement: (html: string, attributes: Record<string, string>) => string;
+    dedupeProcessedAssets: (assets: ProcessedAsset[]) => ProcessedAsset[];
+}
+/**
+ * Maps one component render result into the foreign-subtree payload shape used by
+ * queue resolution and integration tests.
+ */
+export declare function toForeignSubtreeRenderPayload(result: ComponentRenderResult): ForeignSubtreeRenderPayload;
 /**
  * Executes one component render tree under Foreign Child support.
  *
- * This service owns the execution policy for mixed-integration component trees:
- * it decides when a child stays inline, when it must delegate to an owning
- * renderer, how one render-pass renderer cache is reused, and how queued
- * Foreign Subtree tokens resolve back into final HTML.
+ * This service owns mixed-integration execution policy and the queued token
+ * mechanics renderers use when foreign children cannot resolve inline.
  */
 export declare class ForeignSubtreeExecutionService {
-    private readonly queuedForeignSubtreeResolutionService;
-    constructor(queuedForeignSubtreeResolutionService?: QueuedForeignSubtreeResolutionService);
     private requiresForeignChildRuntime;
-    /**
-     * Returns whether the current render pass must hand the child off to a foreign owner.
-     */
     shouldDelegateForeignChild(input: ForeignSubtreeExecutionDecisionInput): boolean;
-    /**
-     * Creates the base runtime used when a renderer has not supplied its own queueing runtime.
-     *
-     * The runtime allows same-integration children to continue inline and fails fast
-     * when execution crosses into a foreign owner without a renderer-owned handoff.
-     */
     createFailFastRuntime(rendererName: string): ForeignChildRuntime;
     getQueuedRuntimeContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
     createQueuedRuntime<TContext extends QueuedForeignSubtreeResolutionContext>(options: ForeignSubtreeQueuedRuntimeOptions<TContext>): ForeignChildRuntime;
-    /**
-     * Resolves a string-first renderer HTML fragment that may contain queued Foreign Subtree tokens.
-     */
+    createQueueRuntime<TContext extends QueuedForeignSubtreeResolutionContext>(options: {
+        renderInput: ComponentRenderInput;
+        rendererCache: Map<string, unknown>;
+        runtimeContextKey: string;
+        tokenPrefix: string;
+        shouldQueueForeignChild: (input: QueuedForeignChildDecisionInput) => boolean;
+        createRuntimeContext?: (integrationContext: QueuedForeignSubtreeIntegrationContext, rendererCache: Map<string, unknown>) => TContext;
+    }): ForeignChildRuntime;
+    getRuntimeContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
     resolveStringQueuedHtml<TContext extends QueuedForeignSubtreeResolutionContext>(options: ForeignSubtreeStringQueuedHtmlOptions): Promise<{
         assets: ProcessedAsset[];
         html: string;
@@ -90,21 +122,19 @@ export declare class ForeignSubtreeExecutionService {
         assets: ProcessedAsset[];
         html: string;
     }>;
-    /**
-     * Executes one component render with Foreign Child support under the current integration.
-     */
+    resolveQueuedForeignSubtreeTokens<TContext extends QueuedForeignSubtreeResolutionContext>(options: ResolveQueuedForeignSubtreeTokensOptions<TContext>): Promise<{
+        assets: ProcessedAsset[];
+        html: string;
+    }>;
     executeComponentRender(options: ForeignSubtreeExecutionRenderOptions): Promise<ComponentRenderResult>;
     private getRendererCache;
     private withRendererCache;
-    /**
-     * Returns the delegatable owning renderer integration for one component.
-     *
-     * The pseudo `html` integration marks document-shell ownership only and does
-     * not participate in component-level foreign subtree execution.
-     */
     private getForeignOwnerIntegrationName;
     private resolveForeignChildInOwningRenderer;
     private resolveForeignSubtreeInOwningRenderer;
     private runInForeignOwningRenderer;
     resolveQueuedTokens(html: string, queuedResolutionsByToken: Map<string, QueuedForeignSubtreeResolution>, resolveToken: (token: string) => Promise<string>): Promise<string>;
+    private createForeignSubtreeToken;
+    private ensureRuntimeContext;
 }
+export {};

package/src/route-renderer/orchestration/foreign-subtree-execution.service.js

@@ -2,17 +2,18 @@ import {
   getComponentRenderContext,
   runWithComponentRenderContext
 } from "./component-render-context.js";
-import {
-  QueuedForeignSubtreeResolutionService
-} from "./queued-foreign-subtree-resolution.service.js";
-function isMarkupNodeLike(value) {
-  return typeof value === "object" && value !== null && "nodeType" in value && typeof value.nodeType === "number" && (!("outerHTML" in value) || typeof value.outerHTML === "string");
+import { isMarkupNodeLike } from "./render-output.utils.js";
+function toForeignSubtreeRenderPayload(result) {
+  return {
+    html: result.html,
+    assets: result.assets ?? [],
+    rootTag: result.rootTag,
+    rootAttributes: result.rootAttributes,
+    attachmentPolicy: result.canAttachAttributes ? { kind: "first-element" } : { kind: "none" },
+    integrationName: result.integrationName
+  };
 }
 class ForeignSubtreeExecutionService {
-  queuedForeignSubtreeResolutionService;
-  constructor(queuedForeignSubtreeResolutionService = new QueuedForeignSubtreeResolutionService()) {
-    this.queuedForeignSubtreeResolutionService = queuedForeignSubtreeResolutionService;
-  }
   requiresForeignChildRuntime(input) {
     const children = input.children ?? input.props.children;
     if (children === void 0 || children === null) {
@@ -26,18 +27,9 @@ class ForeignSubtreeExecutionService {
     }
     return !isMarkupNodeLike(children);
   }
-  /**
-   * Returns whether the current render pass must hand the child off to a foreign owner.
-   */
   shouldDelegateForeignChild(input) {
     return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
   }
-  /**
-   * Creates the base runtime used when a renderer has not supplied its own queueing runtime.
-   *
-   * The runtime allows same-integration children to continue inline and fails fast
-   * when execution crosses into a foreign owner without a renderer-owned handoff.
-   */
   createFailFastRuntime(rendererName) {
     const interceptForeignChild = (input) => {
       if (!this.shouldDelegateForeignChild(input)) {
@@ -56,10 +48,10 @@ class ForeignSubtreeExecutionService {
     };
   }
   getQueuedRuntimeContext(input, runtimeContextKey) {
-    return this.queuedForeignSubtreeResolutionService.getRuntimeContext(input, runtimeContextKey);
+    return this.getRuntimeContext(input, runtimeContextKey);
   }
   createQueuedRuntime(options) {
-    return this.queuedForeignSubtreeResolutionService.createRuntime({
+    return this.createQueueRuntime({
       renderInput: options.renderInput,
       rendererCache: options.rendererCache,
       runtimeContextKey: options.runtimeContextKey,
@@ -68,9 +60,42 @@ class ForeignSubtreeExecutionService {
       createRuntimeContext: options.createRuntimeContext
     });
   }
-  /**
-   * Resolves a string-first renderer HTML fragment that may contain queued Foreign Subtree tokens.
-   */
+  createQueueRuntime(options) {
+    const runtimeContext = this.ensureRuntimeContext(options);
+    const interceptForeignChild = (input) => {
+      if (!options.shouldQueueForeignChild(input)) {
+        return {
+          kind: "inline",
+          props: { ...input.props }
+        };
+      }
+      runtimeContext.nextForeignSubtreeId += 1;
+      const foreignSubtreeId = runtimeContext.nextForeignSubtreeId;
+      const token = this.createForeignSubtreeToken(options.tokenPrefix, runtimeContext, foreignSubtreeId);
+      runtimeContext.queuedResolutions.push({
+        token,
+        component: input.component,
+        props: { ...input.props },
+        componentInstanceId: runtimeContext.componentInstanceScope ? `${runtimeContext.componentInstanceScope}_n_${foreignSubtreeId}` : `n_${foreignSubtreeId}`
+      });
+      return {
+        kind: "resolved",
+        value: token
+      };
+    };
+    return {
+      interceptForeignChild,
+      interceptForeignChildSync: interceptForeignChild
+    };
+  }
+  getRuntimeContext(input, runtimeContextKey) {
+    const integrationContext = input.integrationContext;
+    const runtimeContext = integrationContext?.[runtimeContextKey];
+    if (typeof runtimeContext !== "object" || runtimeContext === null) {
+      return void 0;
+    }
+    return runtimeContext;
+  }
   async resolveStringQueuedHtml(options) {
     const runtimeContext = this.getQueuedRuntimeContext(options.renderInput, options.runtimeContextKey);
     return this.resolveQueuedHtml({
@@ -98,7 +123,7 @@ class ForeignSubtreeExecutionService {
     });
   }
   async resolveQueuedHtml(options) {
-    return this.queuedForeignSubtreeResolutionService.resolveQueuedHtml({
+    return this.resolveQueuedForeignSubtreeTokens({
       html: options.html,
       runtimeContext: options.runtimeContext,
       queueLabel: options.queueLabel,
@@ -113,9 +138,93 @@ class ForeignSubtreeExecutionService {
       dedupeProcessedAssets: options.dedupeProcessedAssets
     });
   }
-  /**
-   * Executes one component render with Foreign Child support under the current integration.
-   */
+  async resolveQueuedForeignSubtreeTokens(options) {
+    if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
+      return { assets: [], html: options.html };
+    }
+    const runtimeContext = options.runtimeContext;
+    const queuedResolutionsByToken = /* @__PURE__ */ new Map();
+    const resolvedHtmlByToken = /* @__PURE__ */ new Map();
+    const resolvingTokens = /* @__PURE__ */ new Set();
+    const collectedAssets = [];
+    const syncQueuedResolutions = () => {
+      for (const resolution of runtimeContext.queuedResolutions) {
+        if (!queuedResolutionsByToken.has(resolution.token)) {
+          queuedResolutionsByToken.set(resolution.token, resolution);
+        }
+      }
+    };
+    const resolveToken = async (token) => {
+      syncQueuedResolutions();
+      const cachedHtml = resolvedHtmlByToken.get(token);
+      if (cachedHtml) {
+        return cachedHtml;
+      }
+      const resolution = queuedResolutionsByToken.get(token);
+      if (!resolution) {
+        return token;
+      }
+      if (resolvingTokens.has(token)) {
+        throw new Error(
+          `[ecopages] ${options.queueLabel} foreign-subtree queue contains a cycle or unresolved dependency links.`
+        );
+      }
+      resolvingTokens.add(token);
+      try {
+        const renderedChildren = await options.renderQueuedChildren(
+          resolution.props.children,
+          runtimeContext,
+          queuedResolutionsByToken,
+          resolveToken
+        );
+        syncQueuedResolutions();
+        if (renderedChildren.assets.length > 0) {
+          collectedAssets.push(...renderedChildren.assets);
+        }
+        const foreignSubtreeRender = await options.resolveForeignSubtree(
+          {
+            component: resolution.component,
+            props: { ...resolution.props },
+            children: renderedChildren.html ?? renderedChildren.children,
+            integrationContext: {
+              rendererCache: runtimeContext.rendererCache,
+              componentInstanceId: resolution.componentInstanceId
+            }
+          },
+          runtimeContext.rendererCache
+        );
+        if (!foreignSubtreeRender) {
+          throw new Error(
+            `[ecopages] ${options.queueLabel} queued foreign subtree could not resolve its owning renderer.`
+          );
+        }
+        if ((foreignSubtreeRender.assets?.length ?? 0) > 0) {
+          collectedAssets.push(...foreignSubtreeRender.assets ?? []);
+        }
+        const resolvedHtml2 = foreignSubtreeRender.attachmentPolicy.kind === "first-element" && foreignSubtreeRender.rootAttributes ? options.applyAttributesToFirstElement(
+          foreignSubtreeRender.html,
+          foreignSubtreeRender.rootAttributes
+        ) : foreignSubtreeRender.html;
+        resolvedHtmlByToken.set(token, resolvedHtml2);
+        return resolvedHtml2;
+      } finally {
+        resolvingTokens.delete(token);
+      }
+    };
+    let resolvedHtml = options.html;
+    for (let index = 0; index < runtimeContext.queuedResolutions.length; index += 1) {
+      syncQueuedResolutions();
+      const resolution = runtimeContext.queuedResolutions[index];
+      if (!resolvedHtml.includes(resolution.token)) {
+        continue;
+      }
+      resolvedHtml = resolvedHtml.split(resolution.token).join(await resolveToken(resolution.token));
+    }
+    return {
+      assets: options.dedupeProcessedAssets(collectedAssets),
+      html: resolvedHtml
+    };
+  }
   async executeComponentRender(options) {
     const rendererCache = this.getRendererCache(options.input.integrationContext) ?? /* @__PURE__ */ new Map();
     const delegatedForeignChildRender = await this.resolveForeignChildInOwningRenderer({
@@ -167,12 +276,6 @@ class ForeignSubtreeExecutionService {
       integrationContext: integrationContext ? { ...integrationContext, rendererCache: sharedRendererCache } : { rendererCache: sharedRendererCache }
     };
   }
-  /**
-   * Returns the delegatable owning renderer integration for one component.
-   *
-   * The pseudo `html` integration marks document-shell ownership only and does
-   * not participate in component-level foreign subtree execution.
-   */
   getForeignOwnerIntegrationName(component, currentIntegrationName) {
     const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
     if (!integrationName || integrationName === "html" || integrationName === currentIntegrationName) {
@@ -195,7 +298,7 @@ class ForeignSubtreeExecutionService {
       input: options.input,
       rendererCache: options.rendererCache,
       getOwningRenderer: options.getOwningRenderer,
-      run: (owningRenderer, delegatedInput) => owningRenderer.renderForeignSubtree(delegatedInput)
+      run: async (owningRenderer, delegatedInput) => toForeignSubtreeRenderPayload(await owningRenderer.renderComponentWithForeignChildren(delegatedInput))
     });
   }
   async runInForeignOwningRenderer(options) {
@@ -227,7 +330,33 @@ class ForeignSubtreeExecutionService {
     }
     return resolvedHtml;
   }
+  createForeignSubtreeToken(tokenPrefix, runtimeContext, foreignSubtreeId) {
+    return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? "root"}__${foreignSubtreeId}__`;
+  }
+  ensureRuntimeContext(options) {
+    let integrationContext;
+    if (typeof options.renderInput.integrationContext === "object" && options.renderInput.integrationContext !== null) {
+      integrationContext = options.renderInput.integrationContext;
+    } else {
+      integrationContext = {};
+    }
+    const existingRuntimeContext = integrationContext[options.runtimeContextKey];
+    if (typeof existingRuntimeContext !== "object" || existingRuntimeContext === null) {
+      integrationContext[options.runtimeContextKey] = options.createRuntimeContext?.(integrationContext, options.rendererCache) ?? {
+        rendererCache: options.rendererCache,
+        componentInstanceScope: integrationContext.componentInstanceId,
+        nextForeignSubtreeId: 0,
+        queuedResolutions: []
+      };
+    } else {
+      existingRuntimeContext.rendererCache = options.rendererCache;
+    }
+    integrationContext.rendererCache = options.rendererCache;
+    options.renderInput.integrationContext = integrationContext;
+    return integrationContext[options.runtimeContextKey];
+  }
 }
 export {
-  ForeignSubtreeExecutionService
+  ForeignSubtreeExecutionService,
+  toForeignSubtreeRenderPayload
 };

package/src/route-renderer/orchestration/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/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
+};