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

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

@@ -0,0 +1,98 @@
+function walkComponentGraph(input) {
+  const seenComponents = /* @__PURE__ */ new Set();
+  const seenConfigs = /* @__PURE__ */ new Set();
+  const visitComponent = (component, parentIntegrationName, source) => {
+    if (!component) {
+      return;
+    }
+    const ecoComponent = component;
+    if (seenComponents.has(ecoComponent)) {
+      return;
+    }
+    seenComponents.add(ecoComponent);
+    const integrationName = ecoComponent.config?.integration ?? ecoComponent.config?.__eco?.integration ?? parentIntegrationName;
+    if (input.onConfig && ecoComponent.config && !seenConfigs.has(ecoComponent.config)) {
+      seenConfigs.add(ecoComponent.config);
+      input.onConfig(ecoComponent.config);
+    }
+    if (input.onComponent) {
+      const shouldContinue = input.onComponent({
+        component: ecoComponent,
+        parentIntegrationName,
+        source
+      });
+      if (shouldContinue === false) {
+        return;
+      }
+    }
+    if (input.visitLayout) {
+      for (const layout of ecoComponent.config?.layouts ?? []) {
+        if (layout?.config) {
+          visitConfig(layout.config, integrationName);
+        }
+      }
+    }
+    for (const child of ecoComponent.config?.dependencies?.components ?? []) {
+      visitComponent(child, integrationName, "dependency");
+    }
+  };
+  const visitConfig = (config, parentIntegrationName) => {
+    if (!config || seenConfigs.has(config)) {
+      return;
+    }
+    seenConfigs.add(config);
+    if (input.onConfig) {
+      input.onConfig(config);
+    }
+    if (input.visitLayout) {
+      for (const layout of config.layouts ?? []) {
+        if (layout?.config) {
+          visitConfig(layout.config, parentIntegrationName);
+        }
+      }
+    }
+    for (const child of config.dependencies?.components ?? []) {
+      visitComponent(child, parentIntegrationName, "dependency");
+    }
+  };
+  for (const root of input.roots) {
+    visitComponent(root.component, input.currentIntegrationName, root.source);
+  }
+}
+function mapComponentGraph(input) {
+  let nextSyntheticId = 0;
+  const mapComponent = (component, source, parentIntegrationName, lineage) => {
+    const integrationName = component.config?.integration ?? component.config?.__eco?.integration ?? parentIntegrationName;
+    const componentMeta = component.config?.__eco;
+    const isForeignToParent = integrationName !== parentIntegrationName;
+    const componentId = componentMeta?.id ?? componentMeta?.file ?? `${source}:${nextSyntheticId += 1}`;
+    const nextLineage = new Set(lineage);
+    nextLineage.add(component);
+    const children = (component.config?.dependencies?.components ?? []).flatMap((child) => {
+      if (!child || nextLineage.has(child)) {
+        return [];
+      }
+      return [mapComponent(child, "dependency", integrationName, nextLineage)];
+    });
+    return input.mapNode(
+      {
+        component,
+        source,
+        parentIntegrationName,
+        integrationName,
+        componentId,
+        isForeignToParent
+      },
+      children
+    );
+  };
+  return input.roots.map(
+    ({ component, source }) => mapComponent(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
+  );
+}
+const mapDeclaredOwnershipGraph = mapComponentGraph;
+export {
+  mapComponentGraph,
+  mapDeclaredOwnershipGraph,
+  walkComponentGraph
+};

package/src/route-renderer/orchestration/component-render-context.d.ts

@@ -12,13 +12,6 @@ export type ForeignChildInterceptionResult = {
 } | {
     kind: 'resolved';
     value: unknown;
-};
-export type ForeignChildRenderInterception = {
-    kind: 'inline';
-    props?: Record<string, unknown>;
-} | {
-    kind: 'resolved';
-    value: unknown;
 } | undefined;
 /**
  * Foreign-child metadata passed into the active renderer-owned runtime.
@@ -44,7 +37,7 @@ export interface ForeignChildRuntime {
      * which decides whether the child stays inline or leaves the current renderer.
      */
     interceptForeignChild?(input: ForeignChildInterceptionInput): ForeignChildInterceptionResult | Promise<ForeignChildInterceptionResult>;
-    interceptForeignChildSync?(input: ForeignChildInterceptionInput): ForeignChildInterceptionResult;
+    interceptForeignChildSync?(input: ForeignChildInterceptionInput): Exclude<ForeignChildInterceptionResult, undefined>;
 }
 type ForeignChildRenderInput = {
     component: EcoComponent;
@@ -58,7 +51,7 @@ type ForeignChildRenderInput = {
 export type ComponentRenderContext = {
     currentIntegration: string;
     foreignChildRuntime?: ForeignChildRuntime;
-    interceptForeignChild(input: ForeignChildRenderInput): Promise<ForeignChildRenderInterception> | ForeignChildRenderInterception;
+    interceptForeignChild(input: ForeignChildRenderInput): Promise<ForeignChildInterceptionResult> | ForeignChildInterceptionResult;
     finalizeComponentRender<T>(component: EcoComponent, content: T): T;
 };
 /**
@@ -72,7 +65,7 @@ export declare function getComponentRenderContext(): ComponentRenderContext | un
  *
  * The active runtime may resolve the foreign child immediately or keep it inline.
  */
-export declare function interceptForeignChild(input: ForeignChildRenderInput): Promise<ForeignChildRenderInterception> | ForeignChildRenderInterception;
+export declare function interceptForeignChild(input: ForeignChildRenderInput): Promise<ForeignChildInterceptionResult> | ForeignChildInterceptionResult;
 /**
  * Applies lazy trigger or injector wrapping to completed component output.
  *

package/src/route-renderer/orchestration/component-render-context.js

@@ -51,7 +51,9 @@ class ContextualComponentRenderRuntime extends ComponentRenderOutputRuntime {
     const asyncInterception = this.context.foreignChildRuntime?.interceptForeignChild?.(foreignChildRuntimeInput);
     if (asyncInterception !== void 0) {
       if (isThenable(asyncInterception)) {
-        return asyncInterception.then((result) => this.applyForeignChildInterceptionResult(result));
+        return asyncInterception.then(
+          (result) => result === void 0 ? void 0 : this.applyForeignChildInterceptionResult(result)
+        );
       }
       return this.applyForeignChildInterceptionResult(asyncInterception);
     }

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

@@ -1,18 +1 @@
-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 declare function mapDeclaredOwnershipGraph<T>(input: {
-    roots: DeclaredOwnershipRoot[];
-    currentIntegrationName: string;
-    mapNode: (node: DeclaredOwnershipNodeInput, children: T[]) => T;
-}): T[];
+export { mapComponentGraph, mapDeclaredOwnershipGraph, type ComponentGraphRoot, type ComponentGraphWalkInput, type DeclaredOwnershipNodeInput, type DeclaredOwnershipRoot, } from './component-graph.js';

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

@@ -1,34 +1,8 @@
-function mapDeclaredOwnershipGraph(input) {
-  let nextSyntheticId = 0;
-  const mapComponent = (component, source, parentIntegrationName, lineage) => {
-    const integrationName = component.config?.integration ?? component.config?.__eco?.integration ?? parentIntegrationName;
-    const componentMeta = component.config?.__eco;
-    const isForeignToParent = integrationName !== parentIntegrationName;
-    const componentId = componentMeta?.id ?? componentMeta?.file ?? `${source}:${nextSyntheticId += 1}`;
-    const nextLineage = new Set(lineage);
-    nextLineage.add(component);
-    const children = (component.config?.dependencies?.components ?? []).flatMap((child) => {
-      if (!child || nextLineage.has(child)) {
-        return [];
-      }
-      return [mapComponent(child, "dependency", integrationName, nextLineage)];
-    });
-    return input.mapNode(
-      {
-        component,
-        source,
-        parentIntegrationName,
-        integrationName,
-        componentId,
-        isForeignToParent
-      },
-      children
-    );
-  };
-  return input.roots.map(
-    ({ component, source }) => mapComponent(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
-  );
-}
+import {
+  mapComponentGraph,
+  mapDeclaredOwnershipGraph
+} from "./component-graph.js";
 export {
+  mapComponentGraph,
   mapDeclaredOwnershipGraph
 };

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

@@ -0,0 +1,90 @@
+import type { BaseIntegrationContext, ComponentRenderInput, ComponentRenderResult, EcoComponent, PageMetadataProps } from '../../types/public-types.js';
+import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+export type DocumentShellLayoutInput = {
+    component: EcoComponent;
+    props?: Record<string, unknown>;
+};
+export type DocumentShellComposeChildrenContext = {
+    primaryComponent: EcoComponent;
+    primaryProps: Record<string, unknown>;
+    primaryRender?: ComponentRenderResult;
+    layouts: DocumentShellLayoutInput[];
+    rendererCache: BaseIntegrationContext['rendererCache'];
+    renderComponentWithForeignChildren: DocumentShellRenderDependencies['renderComponentWithForeignChildren'];
+};
+export type DocumentShellComposeChildrenResult = {
+    /** Serialized or element children passed to the HTML template shell. */
+    children: unknown;
+    layoutRenders: ComponentRenderResult[];
+    /**
+     * Primary/page render assets when the hook performs unified composition.
+     *
+     * @remarks
+     * Omit only when the default sequential string path runs (core renders primary first).
+     */
+    primaryRender?: ComponentRenderResult;
+};
+/**
+ * Optional hook that replaces default sequential string layout wrapping.
+ *
+ * @remarks
+ * When provided, core skips the initial primary render and expects the hook to return
+ * `children` for the HTML template. Supply `primaryRender` so dependency assets still merge.
+ */
+export type DocumentShellComposeChildrenHook = (context: DocumentShellComposeChildrenContext) => Promise<DocumentShellComposeChildrenResult>;
+export type DocumentShellComposeInput = {
+    primaryComponent: EcoComponent;
+    primaryProps: Record<string, unknown>;
+    layout?: DocumentShellLayoutInput;
+    layouts?: DocumentShellLayoutInput[];
+    composeChildren?: DocumentShellComposeChildrenHook;
+    htmlTemplate: EcoComponent;
+    documentProps: Record<string, unknown>;
+};
+export type DocumentShellPageRenderInput = {
+    page: {
+        component: EcoComponent;
+        props: Record<string, unknown>;
+    };
+    layout?: DocumentShellLayoutInput;
+    layouts?: DocumentShellLayoutInput[];
+    composeChildren?: DocumentShellComposeChildrenHook;
+    htmlTemplate: EcoComponent;
+    metadata: PageMetadataProps;
+    pageProps: Record<string, unknown>;
+    documentProps?: Record<string, unknown>;
+    transformDocumentHtml?: (html: string) => string;
+};
+export type DocumentShellRenderDependencies = {
+    renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    appendProcessedDependencies(...assetGroups: Array<readonly ProcessedAsset[] | undefined>): ProcessedAsset[];
+};
+export type DocumentShellAttributeStamping = {
+    applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
+    applyAttributesToHtmlElement(html: string, attributes: Record<string, string>): string;
+};
+/**
+ * Default sequential string-child composition for document shell layers.
+ */
+export declare function composeSequentialLayoutChildren(context: DocumentShellComposeChildrenContext): Promise<DocumentShellComposeChildrenResult>;
+/**
+ * Composes page or view content through optional layout and document shells.
+ *
+ * One execution-scoped renderer cache is threaded through every shell layer so
+ * repeated foreign delegation reuses initialized renderers within one render pass.
+ */
+export declare function composeDocumentShell(dependencies: DocumentShellRenderDependencies, input: DocumentShellComposeInput): Promise<{
+    documentHtml: string;
+}>;
+/**
+ * Applies optional component-root and document-root attribute stamping before HTML
+ * transformation runs on explicit renderer-owned paths.
+ */
+export declare function applyDocumentShellAttributeStamping(html: string, stamping: DocumentShellAttributeStamping, options: {
+    componentRootAttributes?: Record<string, string>;
+    documentAttributes?: Record<string, string>;
+}): string;
+/**
+ * Builds the final serialized document HTML for one route page render.
+ */
+export declare function renderPageDocumentShell(dependencies: DocumentShellRenderDependencies, input: DocumentShellPageRenderInput, docType: string): Promise<string>;

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 {};