@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

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

@@ -1,231 +0,0 @@
-import {
-  getComponentRenderContext,
-  runWithComponentRenderContext
-} from "./component-render-context.js";
-import {
-  QueuedForeignSubtreeResolutionService
-} from "./queued-foreign-subtree-resolution.service.js";
-import { isMarkupNodeLike } from "./render-output.utils.js";
-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) {
-      return false;
-    }
-    if (typeof children === "string") {
-      return false;
-    }
-    if (typeof children !== "object") {
-      return false;
-    }
-    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)) {
-        return {
-          kind: "inline",
-          props: "props" in input && input.props ? { ...input.props } : void 0
-        };
-      }
-      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.queuedForeignSubtreeResolutionService.getRuntimeContext(input, runtimeContextKey);
-  }
-  createQueuedRuntime(options) {
-    return this.queuedForeignSubtreeResolutionService.createRuntime({
-      renderInput: options.renderInput,
-      rendererCache: options.rendererCache,
-      runtimeContextKey: options.runtimeContextKey,
-      tokenPrefix: options.tokenPrefix,
-      shouldQueueForeignChild: (input) => this.shouldDelegateForeignChild(input),
-      createRuntimeContext: options.createRuntimeContext
-    });
-  }
-  /**
-   * Resolves a string-first renderer HTML fragment that may contain queued Foreign Subtree tokens.
-   */
-  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)) {
-          return { assets: [], children };
-        }
-        const html = await this.resolveQueuedTokens(
-          typeof children === "string" ? children : children.outerHTML ?? String(children ?? ""),
-          queuedResolutionsByToken,
-          resolveToken
-        );
-        return { assets: [], html };
-      },
-      getOwningRenderer: options.getOwningRenderer,
-      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
-      dedupeProcessedAssets: options.dedupeProcessedAssets
-    });
-  }
-  async resolveQueuedHtml(options) {
-    return this.queuedForeignSubtreeResolutionService.resolveQueuedHtml({
-      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
-    });
-  }
-  /**
-   * Executes one component render with Foreign Child support under the current integration.
-   */
-  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;
-    }
-    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 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;
-    }
-    return void 0;
-  }
-  withRendererCache(input, rendererCache) {
-    const integrationContext = input.integrationContext;
-    const sharedRendererCache = rendererCache;
-    return {
-      ...input,
-      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) {
-      return void 0;
-    }
-    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: (owningRenderer, delegatedInput) => owningRenderer.renderForeignSubtree(delegatedInput)
-    });
-  }
-  async runInForeignOwningRenderer(options) {
-    const foreignOwnerIntegrationName = this.getForeignOwnerIntegrationName(
-      options.input.component,
-      options.currentIntegrationName
-    );
-    if (!foreignOwnerIntegrationName) {
-      return void 0;
-    }
-    const owningRenderer = options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
-    if (owningRenderer.name === options.currentIntegrationName) {
-      return void 0;
-    }
-    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));
-    }
-    return resolvedHtml;
-  }
-}
-export {
-  ForeignSubtreeExecutionService
-};

package/src/route-renderer/orchestration/ownership-planning.service.d.ts

@@ -1,24 +0,0 @@
-import type { OwnershipPlan, OwnershipValidationError, EcoComponent } from '../../types/public-types.js';
-type OwnershipPlanBuildInput = {
-    routeFile: string;
-    currentIntegrationName: string;
-    HtmlTemplate: EcoComponent;
-    Layout?: EcoComponent;
-    Page: EcoComponent;
-    validationErrors?: OwnershipValidationError[];
-};
-/**
- * Builds a declared ownership plan from the component dependency graph.
- *
- * The plan reflects the declared component dependency graph for one route after
- * route-root ownership validation has already run. It records ownership shape,
- * foreign-edge counts, and any validation errors supplied by an earlier
- * validation pass.
- */
-export declare class OwnershipPlanningService {
-    /**
-     * Builds the structural ownership plan for one route render.
-     */
-    buildPlan(input: OwnershipPlanBuildInput): OwnershipPlan;
-}
-export {};

package/src/route-renderer/orchestration/ownership-planning.service.js

@@ -1,63 +0,0 @@
-import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
-class OwnershipPlanningService {
-  /**
-   * Builds the structural ownership plan for one route render.
-   */
-  buildPlan(input) {
-    const validationErrors = input.validationErrors ?? [];
-    const rendererNames = /* @__PURE__ */ new Set([input.currentIntegrationName]);
-    let foreignEdgeCount = 0;
-    const roots = [
-      { component: input.HtmlTemplate, source: "html-template" },
-      ...input.Layout ? [{ component: input.Layout, source: "layout" }] : [],
-      { component: input.Page, source: "page" }
-    ];
-    const children = mapDeclaredOwnershipGraph({
-      roots,
-      currentIntegrationName: input.currentIntegrationName,
-      mapNode: ({ component, source, integrationName, componentId, isForeignToParent }, children2) => {
-        const componentMeta = component.config?.__eco;
-        rendererNames.add(integrationName);
-        if (isForeignToParent) {
-          foreignEdgeCount += 1;
-        }
-        return {
-          id: componentId,
-          source,
-          ownership: {
-            integrationName,
-            componentId,
-            componentFile: componentMeta?.file,
-            isPageEntry: source === "page",
-            isForeignToParent
-          },
-          children: children2,
-          declaredDependenciesValid: true
-        };
-      }
-    });
-    const root = {
-      id: `route:${input.routeFile}`,
-      source: "route",
-      ownership: {
-        integrationName: input.currentIntegrationName,
-        componentId: `route:${input.routeFile}`,
-        componentFile: input.routeFile,
-        isPageEntry: false,
-        isForeignToParent: false
-      },
-      children,
-      declaredDependenciesValid: validationErrors.length === 0
-    };
-    return {
-      root,
-      rendererNames: Array.from(rendererNames),
-      foreignEdgeCount,
-      hasValidationErrors: validationErrors.length > 0,
-      validationErrors
-    };
-  }
-}
-export {
-  OwnershipPlanningService
-};

package/src/route-renderer/orchestration/ownership-validation.service.js

@@ -1,53 +0,0 @@
-import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
-class OwnershipValidationService {
-  appConfig;
-  /**
-   * Creates the ownership validator for one finalized app config.
-   */
-  constructor(appConfig) {
-    this.appConfig = appConfig;
-  }
-  /**
-   * Validates foreign ownership edges reachable from the supplied route roots.
-   */
-  validate(input) {
-    return mapDeclaredOwnershipGraph({
-      roots: input.roots,
-      currentIntegrationName: input.currentIntegrationName,
-      mapNode: ({ component, integrationName, componentId, isForeignToParent }, children) => {
-        const componentMeta = component.config?.__eco;
-        const errors = children.flat();
-        if (!isForeignToParent) {
-          return errors;
-        }
-        if (!componentMeta) {
-          errors.push({
-            code: "MISSING_COMPONENT_METADATA",
-            message: `[ecopages] Foreign child "${componentId}" must provide stable __eco metadata so ownership diagnostics stay actionable. Declared dependencies must include all possible foreign children.`,
-            componentId,
-            integrationName
-          });
-        }
-        if (!this.isRegisteredIntegration(integrationName, input.currentIntegrationName)) {
-          errors.push({
-            code: "UNKNOWN_INTEGRATION_OWNER",
-            message: `[ecopages] Foreign child "${componentId}" references unknown integration owner "${integrationName}". Declared dependencies must include all possible foreign children and those integrations must be registered.`,
-            componentId,
-            componentFile: componentMeta?.file,
-            integrationName
-          });
-        }
-        return errors;
-      }
-    }).flat();
-  }
-  isRegisteredIntegration(integrationName, currentIntegrationName) {
-    if (integrationName === currentIntegrationName) {
-      return true;
-    }
-    return this.appConfig.integrations.some((integration) => integration.name === integrationName);
-  }
-}
-export {
-  OwnershipValidationService
-};

package/src/route-renderer/orchestration/processed-asset-dedupe.js

@@ -1,27 +0,0 @@
-function buildProcessedAssetDedupeKey(asset) {
-  return [
-    asset.kind,
-    asset.position ?? "",
-    asset.srcUrl ?? "",
-    asset.filepath ?? "",
-    asset.content ?? "",
-    asset.inline ? "inline" : "external",
-    asset.excludeFromHtml ? "excluded" : "included",
-    asset.packageRole ?? "",
-    JSON.stringify(asset.attributes ?? {})
-  ].join("|");
-}
-function dedupeProcessedAssets(assets) {
-  const unique = /* @__PURE__ */ new Map();
-  for (const asset of assets) {
-    const key = buildProcessedAssetDedupeKey(asset);
-    if (!unique.has(key)) {
-      unique.set(key, asset);
-    }
-  }
-  return [...unique.values()];
-}
-export {
-  buildProcessedAssetDedupeKey,
-  dedupeProcessedAssets
-};

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

@@ -1,91 +0,0 @@
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import type { BaseIntegrationContext, ForeignSubtreeRenderPayload, ComponentRenderInput, EcoComponent } from '../../types/public-types.js';
-import type { ForeignChildRuntime } from './component-render-context.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.
- *
- * Renderers that cannot resolve foreign children inline can enqueue transport
- * tokens during their initial render, then resolve those tokens against the
- * owning renderer before returning final HTML.
- */
-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;
-};
-/**
- * Lower-level queue orchestration for renderer-owned foreign-child runtimes that emit
- * temporary transport tokens during one render pass.
- *
- * The service keeps three responsibilities in one place:
- * - storing per-render queue state on the active integration context
- * - creating a `ForeignChildRuntime` that enqueues foreign children
- * - resolving queued tokens back through the owning renderer before final HTML
- *   leaves the current renderer
- *
- * The deeper Foreign Subtree execution module composes this queue helper with
- * renderer-cache delegation and active render-context execution. This service
- * stays focused on queue bookkeeping, recursion, cycle detection, and asset merging.
- */
-export declare class QueuedForeignSubtreeResolutionService {
-    /**
-     * Reads the queued foreign-subtree runtime state previously attached to one render.
-     */
-    getRuntimeContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
-    /**
-     * Creates the runtime hook used by `runWithComponentRenderContext()` for one
-     * renderer-owned queue.
-     *
-     * When the renderer decides a foreign child must be handed off, the runtime returns
-     * a resolved transport token instead of rendering the foreign component inline.
-     */
-    createRuntime<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;
-    /**
-     * Resolves every queued transport token in one renderer-owned HTML fragment.
-     *
-     * The caller supplies framework-specific child rendering, while this service
-     * handles recursive token replacement, cycle detection, root-attribute
-     * application, and merged asset collection.
-     */
-    resolveQueuedHtml<TContext extends QueuedForeignSubtreeResolutionContext>(options: {
-        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[];
-    }): Promise<{
-        assets: ProcessedAsset[];
-        html: string;
-    }>;
-    private createForeignSubtreeToken;
-    private ensureRuntimeContext;
-}
-export {};

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

@@ -1,170 +0,0 @@
-class QueuedForeignSubtreeResolutionService {
-  /**
-   * Reads the queued foreign-subtree runtime state previously attached to one render.
-   */
-  getRuntimeContext(input, runtimeContextKey) {
-    const integrationContext = input.integrationContext;
-    const runtimeContext = integrationContext?.[runtimeContextKey];
-    if (typeof runtimeContext !== "object" || runtimeContext === null) {
-      return void 0;
-    }
-    return runtimeContext;
-  }
-  /**
-   * Creates the runtime hook used by `runWithComponentRenderContext()` for one
-   * renderer-owned queue.
-   *
-   * When the renderer decides a foreign child must be handed off, the runtime returns
-   * a resolved transport token instead of rendering the foreign component inline.
-   */
-  createRuntime(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
-    };
-  }
-  /**
-   * Resolves every queued transport token in one renderer-owned HTML fragment.
-   *
-   * The caller supplies framework-specific child rendering, while this service
-   * handles recursive token replacement, cycle detection, root-attribute
-   * application, and merged asset collection.
-   */
-  async resolveQueuedHtml(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
-    };
-  }
-  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 {
-  QueuedForeignSubtreeResolutionService
-};