@ecopages/core 0.2.0-beta.8 → 0.2.0-rc.0

package/src/build/server-side-css-shim-plugin.js

@@ -1,35 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-const CSS_PATH = /\.css$/u;
-const CSS_QUERY = "?ecopages-css-shim";
-function stripShimQuery(id) {
-  const queryIndex = id.indexOf("?");
-  return queryIndex === -1 ? id : id.slice(0, queryIndex);
-}
-function createServerSideCssShimPlugin() {
-  return {
-    name: "ecopages:server-side-css-shim",
-    async resolveId(source, importer) {
-      if (!CSS_PATH.test(source)) {
-        return null;
-      }
-      const resolved = importer ? path.resolve(path.dirname(importer), source) : path.resolve(source);
-      return existsSync(resolved) ? `${resolved}${CSS_QUERY}` : null;
-    },
-    async load(id) {
-      if (!id.endsWith(CSS_QUERY)) {
-        return null;
-      }
-      const realPath = stripShimQuery(id);
-      readFileSync(realPath, "utf-8");
-      return {
-        code: 'export default "";',
-        moduleType: "js",
-        moduleSideEffects: true
-      };
-    }
-  };
-}
-export {
-  createServerSideCssShimPlugin
-};

package/src/hmr/hmr.postcss.test.e2e.js

@@ -1,31 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
-const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/postcss-hmr.css");
-test.describe("HMR E2E PostCSS", () => {
-  test("should hot-update processor-owned CSS without a full page reload", async ({ page }) => {
-    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
-    const title = page.locator(".postcss-title").first();
-    try {
-      await page.goto("/postcss-hmr", { waitUntil: "networkidle" });
-      await expect(title).toBeVisible();
-      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
-      expect(initialColor).toBeTruthy();
-      await page.evaluate(() => {
-        window.__postcssReloadProbe = "before-change";
-      });
-      const modifiedCss = originalCss.replace(".postcss-title {", ".postcss-title {\n	color: rgb(255, 0, 0);");
-      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
-      await expect(
-        page.evaluate(
-          () => window.__postcssReloadProbe ?? null
-        )
-      ).resolves.toBe("before-change");
-    } finally {
-      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-    }
-  });
-});

package/src/hmr/hmr.test.e2e.js

@@ -1,54 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
-const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/index.css");
-async function readMainTitleColor(page) {
-  return page.evaluate(() => {
-    const element = document.querySelector(".main-title");
-    if (!(element instanceof HTMLElement)) {
-      return "";
-    }
-    return getComputedStyle(element).color;
-  });
-}
-test.describe("HMR E2E", () => {
-  test("should load page with .main-title element", async ({ page }) => {
-    await page.goto("/", { waitUntil: "networkidle" });
-    const title = page.locator(".main-title").first();
-    await expect(title).toBeVisible();
-  });
-  test("should connect to HMR WebSocket", async ({ page }) => {
-    const socketPromise = page.waitForEvent("websocket", {
-      predicate: (socket2) => socket2.url().endsWith("/_hmr"),
-      timeout: 1e4
-    });
-    await page.goto("/", { waitUntil: "networkidle" });
-    const socket = await socketPromise;
-    expect(socket.url()).toMatch(/\/_hmr$/);
-  });
-  test("should fall back to a full page reload when raw CSS file changes", async ({ page }) => {
-    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
-    const title = page.locator(".main-title").first();
-    try {
-      await page.goto("/", { waitUntil: "domcontentloaded" });
-      await expect(title).toBeVisible();
-      await expect.poll(async () => readMainTitleColor(page), { timeout: 1e4 }).not.toBe("");
-      const initialColor = await readMainTitleColor(page);
-      expect(initialColor).toBeTruthy();
-      const modifiedCss = originalCss.replace(".main-title {", ".main-title {\n	color: rgb(255, 0, 0);");
-      const reloadPromise = page.waitForEvent("framenavigated", {
-        predicate: (frame) => frame === page.mainFrame(),
-        timeout: 1e4
-      });
-      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-      await reloadPromise;
-      await page.waitForLoadState("domcontentloaded");
-      await expect(title).toBeVisible();
-      await expect.poll(async () => readMainTitleColor(page), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
-    } finally {
-      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-    }
-  });
-});

package/src/integrations/ghtml/ghtml-renderer.js

@@ -1,57 +0,0 @@
-import {
-  IntegrationRenderer
-} from "../../route-renderer/orchestration/integration-renderer.js";
-import { GHTML_PLUGIN_NAME } from "./ghtml.constants.js";
-class GhtmlRenderer extends IntegrationRenderer {
-  name = GHTML_PLUGIN_NAME;
-  async renderComponent(input) {
-    return this.renderStringComponentWithQueuedForeignSubtrees(
-      input,
-      input.component
-    );
-  }
-  async render({
-    params,
-    query,
-    props,
-    locals,
-    pageLocals,
-    metadata,
-    Page,
-    Layout,
-    HtmlTemplate
-  }) {
-    try {
-      return await this.renderPageWithDocumentShell({
-        page: {
-          component: Page,
-          props: { params, query, ...props, locals: pageLocals }
-        },
-        layout: Layout ? {
-          component: Layout,
-          props: locals ? { locals } : {}
-        } : void 0,
-        htmlTemplate: HtmlTemplate,
-        metadata,
-        pageProps: props ?? {}
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering page", error);
-    }
-  }
-  async renderToResponse(view, props, ctx) {
-    try {
-      return await this.renderViewWithDocumentShell({
-        view,
-        props,
-        ctx,
-        layout: view.config?.layout
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering view", error);
-    }
-  }
-}
-export {
-  GhtmlRenderer
-};

package/src/integrations/ghtml/ghtml.constants.d.ts

@@ -1 +0,0 @@
-export declare const GHTML_PLUGIN_NAME = "ghtml";

package/src/integrations/ghtml/ghtml.constants.js

@@ -1,4 +0,0 @@
-const GHTML_PLUGIN_NAME = "ghtml";
-export {
-  GHTML_PLUGIN_NAME
-};

package/src/integrations/ghtml/ghtml.plugin.d.ts

@@ -1,16 +0,0 @@
-import { IntegrationPlugin, type IntegrationPluginConfig } from '../../plugins/integration-plugin.js';
-import { GhtmlRenderer } from './ghtml-renderer.js';
-/**
- * The Ghtml plugin class
- * This plugin provides support for ghtml components in Ecopages
- */
-export declare class GhtmlPlugin extends IntegrationPlugin {
-    renderer: typeof GhtmlRenderer;
-    constructor(options?: Omit<IntegrationPluginConfig, 'name'>);
-}
-/**
- * Factory function to create a Ghtml plugin instance
- * @param options Configuration options for the Ghtml plugin
- * @returns A new GhtmlPlugin instance
- */
-export declare function ghtmlPlugin(options?: Omit<IntegrationPluginConfig, 'name'>): GhtmlPlugin;

package/src/integrations/ghtml/ghtml.plugin.js

@@ -1,20 +0,0 @@
-import { IntegrationPlugin } from "../../plugins/integration-plugin.js";
-import { GhtmlRenderer } from "./ghtml-renderer.js";
-import { GHTML_PLUGIN_NAME } from "./ghtml.constants.js";
-class GhtmlPlugin extends IntegrationPlugin {
-  renderer = GhtmlRenderer;
-  constructor(options) {
-    super({
-      name: GHTML_PLUGIN_NAME,
-      extensions: [".ghtml.ts", ".ghtml.tsx", ".ghtml"],
-      ...options
-    });
-  }
-}
-function ghtmlPlugin(options) {
-  return new GhtmlPlugin(options);
-}
-export {
-  GhtmlPlugin,
-  ghtmlPlugin
-};

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

@@ -1,147 +0,0 @@
-import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from "./render-output.utils.js";
-class ComponentRenderOutputRuntime {
-  finalizeComponentRender(component, content) {
-    const lazyTriggers = component.config?._resolvedLazyTriggers;
-    if (lazyTriggers && lazyTriggers.length > 0) {
-      return this.addTriggerToContent(content, lazyTriggers[0].triggerId);
-    }
-    const lazyGroups = component.config?._resolvedLazyScripts;
-    if (lazyGroups && lazyGroups.length > 0) {
-      return this.wrapContentWithScriptsInjector(content, lazyGroups);
-    }
-    return content;
-  }
-  addTriggerToContent(content, triggerId) {
-    if (isThenable(content)) {
-      return content.then((resolvedContent) => addTriggerAttribute(resolvedContent, triggerId));
-    }
-    return addTriggerAttribute(content, triggerId);
-  }
-  wrapContentWithScriptsInjector(content, lazyGroups) {
-    if (isThenable(content)) {
-      return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
-    }
-    return wrapWithScriptsInjector(content, lazyGroups);
-  }
-}
-class ContextualComponentRenderRuntime extends ComponentRenderOutputRuntime {
-  context;
-  constructor(context) {
-    super();
-    this.context = context;
-  }
-  applyForeignChildInterceptionResult(result) {
-    if (result.kind === "resolved") {
-      return result;
-    }
-    return result.props ? result : void 0;
-  }
-  /**
-   * Resolves one foreign-child interception through the active runtime.
-   *
-   * The runtime may choose inline rendering or immediate resolved output.
-   */
-  interceptForeignChild(input) {
-    const foreignChildRuntimeInput = {
-      currentIntegration: this.context.currentIntegration,
-      targetIntegration: input.targetIntegration,
-      component: input.component,
-      props: input.props
-    };
-    const asyncInterception = this.context.foreignChildRuntime?.interceptForeignChild?.(foreignChildRuntimeInput);
-    if (asyncInterception !== void 0) {
-      if (isThenable(asyncInterception)) {
-        return asyncInterception.then((result) => this.applyForeignChildInterceptionResult(result));
-      }
-      return this.applyForeignChildInterceptionResult(asyncInterception);
-    }
-    const syncInterception = this.context.foreignChildRuntime?.interceptForeignChildSync?.(foreignChildRuntimeInput);
-    if (syncInterception === void 0) {
-      return void 0;
-    }
-    return this.applyForeignChildInterceptionResult(syncInterception);
-  }
-}
-const GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY = "__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__";
-function getSharedContextScope() {
-  const globalProcess = globalThis.process;
-  if (globalProcess && typeof globalProcess === "object") {
-    return globalProcess;
-  }
-  return globalThis;
-}
-function getComponentRenderContextState() {
-  const sharedScope = getSharedContextScope();
-  sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY] ??= {
-    contextStack: [],
-    nodeContextStorage: null,
-    nodeContextStorageLoader: null
-  };
-  return sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY];
-}
-async function getContextStorage() {
-  const state = getComponentRenderContextState();
-  if (state.nodeContextStorage) {
-    return state.nodeContextStorage;
-  }
-  if (state.nodeContextStorageLoader) {
-    return state.nodeContextStorageLoader;
-  }
-  state.nodeContextStorageLoader = import("node:async_hooks").then((module) => {
-    const storage = new module.AsyncLocalStorage();
-    state.nodeContextStorage = {
-      getStore: () => storage.getStore(),
-      run: (store, callback) => storage.run(store, callback)
-    };
-    return state.nodeContextStorage;
-  }).catch(() => {
-    state.nodeContextStorage = null;
-    return null;
-  }).finally(() => {
-    state.nodeContextStorageLoader = null;
-  });
-  return state.nodeContextStorageLoader;
-}
-function getComponentRenderContext() {
-  const state = getComponentRenderContextState();
-  return state.nodeContextStorage?.getStore() ?? state.contextStack[state.contextStack.length - 1];
-}
-const componentRenderOutputRuntime = new ComponentRenderOutputRuntime();
-function interceptForeignChild(input) {
-  return getComponentRenderContext()?.interceptForeignChild(input);
-}
-function finalizeComponentRender(component, content) {
-  const renderContext = getComponentRenderContext();
-  return renderContext?.finalizeComponentRender(component, content) ?? componentRenderOutputRuntime.finalizeComponentRender(component, content);
-}
-async function runWithComponentRenderContext(input, render) {
-  const context = {
-    currentIntegration: input.currentIntegration,
-    foreignChildRuntime: input.foreignChildRuntime
-  };
-  const runtime = new ContextualComponentRenderRuntime(context);
-  context.interceptForeignChild = (deferredInput) => runtime.interceptForeignChild(deferredInput);
-  context.finalizeComponentRender = (component, content) => runtime.finalizeComponentRender(component, content);
-  const storage = await getContextStorage();
-  let value;
-  if (storage) {
-    value = await storage.run(context, render);
-  } else {
-    const state = getComponentRenderContextState();
-    state.contextStack.push(context);
-    try {
-      value = await render();
-    } finally {
-      state.contextStack.pop();
-    }
-  }
-  return {
-    value
-  };
-}
-export {
-  finalizeComponentRender,
-  getComponentRenderContext,
-  interceptForeignChild,
-  runWithComponentRenderContext
-};

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

@@ -1,18 +0,0 @@
-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[];

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

@@ -1,34 +0,0 @@
-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())
-  );
-}
-export {
-  mapDeclaredOwnershipGraph
-};

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