@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.33

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

@@ -1,366 +1,354 @@
-import {
-  getComponentRenderContext,
-  runWithComponentRenderContext
-} from "./component-render-context.js";
-import { assertForeignChildrenNotOpaque, isMarkupNodeLike } from "./foreign-child-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
-  };
+import { getComponentRenderContext, runWithComponentRenderContext, } from './component-render-context.js';
+import { assertForeignChildrenNotOpaque, isMarkupNodeLike } from './foreign-child-output.utils.js';
+/**
+ * Maps one component render result into the foreign-subtree payload shape used by
+ * queue resolution and integration tests.
+ */
+export 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 {
-  requiresForeignChildRuntime(input) {
-    const children = input.children ?? input.props.children;
-    if (children === void 0 || children === null) {
-      return false;
-    }
-    if (typeof children === "string") {
-      return false;
+/**
+ * Executes one component render tree under Foreign Child support.
+ *
+ * This service owns mixed-integration execution policy and the queued token
+ * mechanics renderers use when foreign children cannot resolve inline.
+ */
+export class ForeignSubtreeExecutionService {
+    requiresForeignChildRuntime(input) {
+        const children = input.children ?? input.props.children;
+        if (children === undefined || children === null) {
+            return false;
+        }
+        if (typeof children === 'string') {
+            return false;
+        }
+        if (typeof children !== 'object') {
+            return false;
+        }
+        return !isMarkupNodeLike(children);
     }
-    if (typeof children !== "object") {
-      return false;
+    shouldDelegateForeignChild(input) {
+        return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
     }
-    return !isMarkupNodeLike(children);
-  }
-  shouldDelegateForeignChild(input) {
-    return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
-  }
-  createFailFastRuntime(rendererName) {
-    const interceptForeignChild = (input) => {
-      if (!this.shouldDelegateForeignChild(input)) {
+    createFailFastRuntime(rendererName) {
+        const interceptForeignChild = (input) => {
+            if (!this.shouldDelegateForeignChild(input)) {
+                return {
+                    kind: 'inline',
+                    props: 'props' in input && input.props ? { ...input.props } : undefined,
+                };
+            }
+            throw new Error(`[ecopages] ${rendererName} renderer crossed into ${input.targetIntegration} without a renderer-owned foreign-child runtime. Override createForeignChildRuntime() to resolve foreign children inside the owning renderer.`);
+        };
         return {
-          kind: "inline",
-          props: "props" in input && input.props ? { ...input.props } : void 0
+            interceptForeignChild,
+            interceptForeignChildSync: interceptForeignChild,
+        };
+    }
+    getQueuedRuntimeContext(input, runtimeContextKey) {
+        return this.getRuntimeContext(input, runtimeContextKey);
+    }
+    createQueuedRuntime(options) {
+        return this.createQueueRuntime({
+            renderInput: options.renderInput,
+            rendererCache: options.rendererCache,
+            runtimeContextKey: options.runtimeContextKey,
+            tokenPrefix: options.tokenPrefix,
+            shouldQueueForeignChild: (input) => this.shouldDelegateForeignChild(input),
+            createRuntimeContext: options.createRuntimeContext,
+        });
+    }
+    createQueueRuntime(options) {
+        const runtimeContext = this.ensureRuntimeContext(options);
+        const interceptForeignChild = (input) => {
+            if (!options.shouldQueueForeignChild(input)) {
+                return {
+                    kind: 'inline',
+                    props: { ...input.props },
+                };
+            }
+            if ('children' in input.props) {
+                assertForeignChildrenNotOpaque(input.props.children, 'foreign-subtree queue');
+            }
+            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,
+            };
         };
-      }
-      throw new Error(
-        `[ecopages] ${rendererName} renderer crossed into ${input.targetIntegration} without a renderer-owned foreign-child runtime. Override createForeignChildRuntime() to resolve foreign children inside the owning renderer.`
-      );
-    };
-    return {
-      interceptForeignChild,
-      interceptForeignChildSync: interceptForeignChild
-    };
-  }
-  getQueuedRuntimeContext(input, runtimeContextKey) {
-    return this.getRuntimeContext(input, runtimeContextKey);
-  }
-  createQueuedRuntime(options) {
-    return this.createQueueRuntime({
-      renderInput: options.renderInput,
-      rendererCache: options.rendererCache,
-      runtimeContextKey: options.runtimeContextKey,
-      tokenPrefix: options.tokenPrefix,
-      shouldQueueForeignChild: (input) => this.shouldDelegateForeignChild(input),
-      createRuntimeContext: options.createRuntimeContext
-    });
-  }
-  createQueueRuntime(options) {
-    const runtimeContext = this.ensureRuntimeContext(options);
-    const interceptForeignChild = (input) => {
-      if (!options.shouldQueueForeignChild(input)) {
         return {
-          kind: "inline",
-          props: { ...input.props }
+            interceptForeignChild,
+            interceptForeignChildSync: interceptForeignChild,
         };
-      }
-      if ("children" in input.props) {
-        assertForeignChildrenNotOpaque(input.props.children, "foreign-subtree queue");
-      }
-      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({
-      currentIntegrationName: options.currentIntegrationName,
-      html: options.html,
-      runtimeContext,
-      queueLabel: options.queueLabel,
-      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
-        if (children === void 0) {
-          return { assets: [], html: void 0 };
-        }
-        if (typeof children !== "string" && !isMarkupNodeLike(children)) {
-          assertForeignChildrenNotOpaque(children, options.queueLabel);
-          return { assets: [], children };
+    getRuntimeContext(input, runtimeContextKey) {
+        const integrationContext = input.integrationContext;
+        const runtimeContext = integrationContext?.[runtimeContextKey];
+        if (typeof runtimeContext !== 'object' || runtimeContext === null) {
+            return undefined;
         }
-        const html = await this.resolveQueuedTokens(
-          typeof children === "string" ? children : children.outerHTML ?? "",
-          queuedResolutionsByToken,
-          resolveToken
-        );
-        return { assets: [], html };
-      },
-      getOwningRenderer: options.getOwningRenderer,
-      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
-      dedupeProcessedAssets: options.dedupeProcessedAssets
-    });
-  }
-  async resolveQueuedHtml(options) {
-    return this.resolveQueuedForeignSubtreeTokens({
-      html: options.html,
-      runtimeContext: options.runtimeContext,
-      queueLabel: options.queueLabel,
-      renderQueuedChildren: options.renderQueuedChildren,
-      resolveForeignSubtree: (input, rendererCache) => this.resolveForeignSubtreeInOwningRenderer({
-        currentIntegrationName: options.currentIntegrationName,
-        input,
-        rendererCache,
-        getOwningRenderer: options.getOwningRenderer
-      }),
-      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
-      dedupeProcessedAssets: options.dedupeProcessedAssets
-    });
-  }
-  async resolveQueuedForeignSubtreeTokens(options) {
-    if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
-      return { assets: [], html: options.html };
+        return runtimeContext;
     }
-    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);
+    async resolveStringQueuedHtml(options) {
+        const runtimeContext = this.getQueuedRuntimeContext(options.renderInput, options.runtimeContextKey);
+        return this.resolveQueuedHtml({
+            currentIntegrationName: options.currentIntegrationName,
+            html: options.html,
+            runtimeContext,
+            queueLabel: options.queueLabel,
+            renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
+                if (children === undefined) {
+                    return { assets: [], html: undefined };
+                }
+                if (typeof children !== 'string' && !isMarkupNodeLike(children)) {
+                    assertForeignChildrenNotOpaque(children, options.queueLabel);
+                    return { assets: [], children };
+                }
+                const html = await this.resolveQueuedTokens(typeof children === 'string' ? children : (children.outerHTML ?? ''), queuedResolutionsByToken, resolveToken);
+                return { assets: [], html };
+            },
+            getOwningRenderer: options.getOwningRenderer,
+            applyAttributesToFirstElement: options.applyAttributesToFirstElement,
+            dedupeProcessedAssets: options.dedupeProcessedAssets,
+        });
+    }
+    async resolveQueuedHtml(options) {
+        return this.resolveQueuedForeignSubtreeTokens({
+            html: options.html,
+            runtimeContext: options.runtimeContext,
+            queueLabel: options.queueLabel,
+            renderQueuedChildren: options.renderQueuedChildren,
+            resolveForeignSubtree: (input, rendererCache) => this.resolveForeignSubtreeInOwningRenderer({
+                currentIntegrationName: options.currentIntegrationName,
+                input,
+                rendererCache: rendererCache,
+                getOwningRenderer: options.getOwningRenderer,
+            }),
+            applyAttributesToFirstElement: options.applyAttributesToFirstElement,
+            dedupeProcessedAssets: options.dedupeProcessedAssets,
+        });
+    }
+    async resolveQueuedForeignSubtreeTokens(options) {
+        if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
+            return { assets: [], html: options.html };
         }
-        const foreignSubtreeRender = await options.resolveForeignSubtree(
-          {
-            component: resolution.component,
-            props: { ...resolution.props },
-            children: renderedChildren.html ?? renderedChildren.children,
-            integrationContext: {
-              rendererCache: runtimeContext.rendererCache,
-              componentInstanceId: resolution.componentInstanceId
+        const runtimeContext = options.runtimeContext;
+        const queuedResolutionsByToken = new Map();
+        const resolvedHtmlByToken = new Map();
+        const resolvingTokens = 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;
             }
-          },
-          runtimeContext.rendererCache
-        );
-        if (!foreignSubtreeRender) {
-          throw new Error(
-            `[ecopages] ${options.queueLabel} queued foreign subtree could not resolve its owning renderer.`
-          );
+            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 resolvedHtml = foreignSubtreeRender.attachmentPolicy.kind === 'first-element' &&
+                    foreignSubtreeRender.rootAttributes
+                    ? options.applyAttributesToFirstElement(foreignSubtreeRender.html, foreignSubtreeRender.rootAttributes)
+                    : foreignSubtreeRender.html;
+                resolvedHtmlByToken.set(token, resolvedHtml);
+                return resolvedHtml;
+            }
+            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) ??
+            new Map();
+        const delegatedForeignChildRender = await this.resolveForeignChildInOwningRenderer({
+            currentIntegrationName: options.currentIntegrationName,
+            input: options.input,
+            rendererCache,
+            getOwningRenderer: options.getOwningRenderer,
+        });
+        if (delegatedForeignChildRender) {
+            return delegatedForeignChildRender;
         }
-        if ((foreignSubtreeRender.assets?.length ?? 0) > 0) {
-          collectedAssets.push(...foreignSubtreeRender.assets ?? []);
+        const hasForeignChildren = options.hasForeignChildDescendants(options.input.component) ||
+            this.requiresForeignChildRuntime(options.input);
+        const activeRenderContext = getComponentRenderContext();
+        if (!hasForeignChildren) {
+            if (!activeRenderContext || activeRenderContext.currentIntegration === options.currentIntegrationName) {
+                return options.normalizeComponentRenderOutput(await options.renderComponent(options.input));
+            }
+            const sameIntegrationExecution = await runWithComponentRenderContext({
+                currentIntegration: options.currentIntegrationName,
+            }, async () => options.renderComponent(options.input));
+            return options.normalizeComponentRenderOutput(sameIntegrationExecution.value);
         }
-        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));
+        const execution = await runWithComponentRenderContext({
+            currentIntegration: options.currentIntegrationName,
+            foreignChildRuntime: options.createForeignChildRuntime({
+                renderInput: options.input,
+                rendererCache,
+            }),
+        }, async () => options.renderComponent(options.input));
+        return options.normalizeComponentRenderOutput(execution.value);
     }
-    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({
-      currentIntegrationName: options.currentIntegrationName,
-      input: options.input,
-      rendererCache,
-      getOwningRenderer: options.getOwningRenderer
-    });
-    if (delegatedForeignChildRender) {
-      return delegatedForeignChildRender;
+    getRendererCache(integrationContext) {
+        if (integrationContext?.rendererCache instanceof Map) {
+            return integrationContext.rendererCache;
+        }
+        return undefined;
     }
-    const hasForeignChildren = options.hasForeignChildDescendants(options.input.component) || this.requiresForeignChildRuntime(options.input);
-    const activeRenderContext = getComponentRenderContext();
-    if (!hasForeignChildren) {
-      if (!activeRenderContext || activeRenderContext.currentIntegration === options.currentIntegrationName) {
-        return options.normalizeComponentRenderOutput(await options.renderComponent(options.input));
-      }
-      const sameIntegrationExecution = await runWithComponentRenderContext(
-        {
-          currentIntegration: options.currentIntegrationName
-        },
-        async () => options.renderComponent(options.input)
-      );
-      return options.normalizeComponentRenderOutput(sameIntegrationExecution.value);
+    withRendererCache(input, rendererCache) {
+        const integrationContext = input.integrationContext;
+        const sharedRendererCache = rendererCache;
+        return {
+            ...input,
+            integrationContext: integrationContext
+                ? { ...integrationContext, rendererCache: sharedRendererCache }
+                : { rendererCache: sharedRendererCache },
+        };
     }
-    const execution = await runWithComponentRenderContext(
-      {
-        currentIntegration: options.currentIntegrationName,
-        foreignChildRuntime: options.createForeignChildRuntime({
-          renderInput: options.input,
-          rendererCache
-        })
-      },
-      async () => options.renderComponent(options.input)
-    );
-    return options.normalizeComponentRenderOutput(execution.value);
-  }
-  getRendererCache(integrationContext) {
-    if (integrationContext?.rendererCache instanceof Map) {
-      return integrationContext.rendererCache;
+    getForeignOwnerIntegrationName(component, currentIntegrationName) {
+        const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
+        if (!integrationName || integrationName === 'html' || integrationName === currentIntegrationName) {
+            return undefined;
+        }
+        return integrationName;
     }
-    return void 0;
-  }
-  withRendererCache(input, rendererCache) {
-    const integrationContext = input.integrationContext;
-    const sharedRendererCache = rendererCache;
-    return {
-      ...input,
-      integrationContext: integrationContext ? { ...integrationContext, rendererCache: sharedRendererCache } : { rendererCache: sharedRendererCache }
-    };
-  }
-  getForeignOwnerIntegrationName(component, currentIntegrationName) {
-    const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
-    if (!integrationName || integrationName === "html" || integrationName === currentIntegrationName) {
-      return void 0;
+    async resolveForeignChildInOwningRenderer(options) {
+        return await this.runInForeignOwningRenderer({
+            currentIntegrationName: options.currentIntegrationName,
+            input: options.input,
+            rendererCache: options.rendererCache,
+            getOwningRenderer: options.getOwningRenderer,
+            run: (owningRenderer, delegatedInput) => owningRenderer.renderComponentWithForeignChildren(delegatedInput),
+        });
     }
-    return integrationName;
-  }
-  async resolveForeignChildInOwningRenderer(options) {
-    return await this.runInForeignOwningRenderer({
-      currentIntegrationName: options.currentIntegrationName,
-      input: options.input,
-      rendererCache: options.rendererCache,
-      getOwningRenderer: options.getOwningRenderer,
-      run: (owningRenderer, delegatedInput) => owningRenderer.renderComponentWithForeignChildren(delegatedInput)
-    });
-  }
-  async resolveForeignSubtreeInOwningRenderer(options) {
-    return await this.runInForeignOwningRenderer({
-      currentIntegrationName: options.currentIntegrationName,
-      input: options.input,
-      rendererCache: options.rendererCache,
-      getOwningRenderer: options.getOwningRenderer,
-      run: async (owningRenderer, delegatedInput) => toForeignSubtreeRenderPayload(await owningRenderer.renderComponentWithForeignChildren(delegatedInput))
-    });
-  }
-  async runInForeignOwningRenderer(options) {
-    const foreignOwnerIntegrationName = this.getForeignOwnerIntegrationName(
-      options.input.component,
-      options.currentIntegrationName
-    );
-    if (!foreignOwnerIntegrationName) {
-      return void 0;
+    async resolveForeignSubtreeInOwningRenderer(options) {
+        return await this.runInForeignOwningRenderer({
+            currentIntegrationName: options.currentIntegrationName,
+            input: options.input,
+            rendererCache: options.rendererCache,
+            getOwningRenderer: options.getOwningRenderer,
+            run: async (owningRenderer, delegatedInput) => toForeignSubtreeRenderPayload(await owningRenderer.renderComponentWithForeignChildren(delegatedInput)),
+        });
     }
-    const owningRenderer = await options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
-    if (owningRenderer.name === options.currentIntegrationName) {
-      return void 0;
+    async runInForeignOwningRenderer(options) {
+        const foreignOwnerIntegrationName = this.getForeignOwnerIntegrationName(options.input.component, options.currentIntegrationName);
+        if (!foreignOwnerIntegrationName) {
+            return undefined;
+        }
+        const owningRenderer = await options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
+        if (owningRenderer.name === options.currentIntegrationName) {
+            return undefined;
+        }
+        const delegatedInputWithCache = this.withRendererCache(options.input, options.rendererCache);
+        const delegatedChildren = delegatedInputWithCache.children ?? delegatedInputWithCache.props.children;
+        return await options.run(owningRenderer, {
+            ...delegatedInputWithCache,
+            children: delegatedChildren,
+        });
     }
-    const delegatedInputWithCache = this.withRendererCache(options.input, options.rendererCache);
-    const delegatedChildren = delegatedInputWithCache.children ?? delegatedInputWithCache.props.children;
-    return await options.run(owningRenderer, {
-      ...delegatedInputWithCache,
-      children: delegatedChildren
-    });
-  }
-  async resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken) {
-    let resolvedHtml = html;
-    for (const token of queuedResolutionsByToken.keys()) {
-      if (!resolvedHtml.includes(token)) {
-        continue;
-      }
-      resolvedHtml = resolvedHtml.split(token).join(await resolveToken(token));
+    async resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken) {
+        let resolvedHtml = html;
+        for (const token of queuedResolutionsByToken.keys()) {
+            if (!resolvedHtml.includes(token)) {
+                continue;
+            }
+            resolvedHtml = resolvedHtml.split(token).join(await resolveToken(token));
+        }
+        return resolvedHtml;
     }
-    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 = {};
+    createForeignSubtreeToken(tokenPrefix, runtimeContext, foreignSubtreeId) {
+        return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? 'root'}__${foreignSubtreeId}__`;
     }
-    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;
+    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];
     }
-    integrationContext.rendererCache = options.rendererCache;
-    options.renderInput.integrationContext = integrationContext;
-    return integrationContext[options.runtimeContextKey];
-  }
 }
-export {
-  ForeignSubtreeExecutionService,
-  toForeignSubtreeRenderPayload
-};