@ecopages/core 0.2.0-beta.3 → 0.2.0-beta.30

package/src/build/rolldown-dev-build-adapter.js

@@ -1,166 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import { dev } from "rolldown/experimental";
-import {
-  buildResultFromRolldownOutput,
-  resolveRolldownOptions,
-  rewriteBrowserRuntimeImportsInOutputs,
-  toBuildLogs,
-  transpileProfileToOptions
-} from "./rolldown-adapter-helpers.js";
-const moduleRequire = createRequire(import.meta.url);
-class RolldownDevBuildAdapter {
-  /**
-   * `'rolldown-dev'` (not `'rolldown'`) so {@link getBuildAdapterOwnership}
-   * round-trips correctly and `createBuildAdapter({ ownership })` can
-   * re-select this class.
-   */
-  ownership = "rolldown-dev";
-  cachedEngine;
-  engineInstanceCount = 0;
-  pendingBuilds = [];
-  appRootRequireCache = /* @__PURE__ */ new Map();
-  /**
-   * Stable key over the inputs that affect the engine configuration.
-   * Plugin order is intentionally not part of the key: two plugin
-   * sets with the same names are interchangeable for caching.
-   */
-  getCacheKey(plugins, contextRoot, target, format) {
-    const pluginNames = plugins.map((p) => p.name).join(":");
-    return `${contextRoot}::${pluginNames}::${target ?? "default"}::${format ?? "esm"}`;
-  }
-  /**
-   * Returns the cached engine, creating a new one when the cache
-   * key changes. On a cache miss the prior engine is closed and
-   * {@link engineInstanceCount} is incremented.
-   */
-  async getOrCreateEngine(options, contextRoot) {
-    const bundlePlugins = options.plugins ?? [];
-    const cacheKey = this.getCacheKey(bundlePlugins, contextRoot, options.target, options.format);
-    if (this.cachedEngine) {
-      const existingKey = this.getCacheKey(
-        this.cachedEngine.bundlePlugins,
-        this.cachedEngine.contextRoot,
-        options.target,
-        options.format
-      );
-      if (existingKey === cacheKey) {
-        return this.cachedEngine;
-      }
-      await this.cachedEngine.engine.close();
-      this.cachedEngine = void 0;
-    }
-    const outdir = path.resolve(options.outdir ?? "dist/assets");
-    const { inputOptions, outputOptions } = resolveRolldownOptions(
-      options,
-      contextRoot,
-      outdir,
-      this.appRootRequireCache
-    );
-    const engine = await dev(inputOptions, outputOptions, {
-      rebuildStrategy: "never",
-      onOutput: (result) => {
-        if (result instanceof Error) {
-          return;
-        }
-        const next = this.pendingBuilds.shift();
-        if (next) {
-          next.resolve(result);
-        }
-      }
-    });
-    this.cachedEngine = {
-      engine,
-      engineStarted: false,
-      contextRoot,
-      bundlePlugins
-    };
-    this.engineInstanceCount += 1;
-    return this.cachedEngine;
-  }
-  /**
-   * Triggers a build on the cached engine and returns the next
-   * `RolldownOutput` delivered to `onOutput`.
-   *
-   * First call after engine creation invokes `engine.run`; subsequent
-   * calls invoke `engine.triggerFullBuild` and reuse the cached
-   * module graph, resolver, and transform caches.
-   *
-   * If the trigger itself throws, the queued build is removed so
-   * the next `build()` does not consume a stale slot.
-   */
-  async runBuild(cached) {
-    const outputPromise = new Promise((resolve, reject) => {
-      this.pendingBuilds.push({ resolve, reject });
-    });
-    try {
-      if (!cached.engineStarted) {
-        cached.engineStarted = true;
-        await cached.engine.run();
-      } else {
-        cached.engine.triggerFullBuild();
-      }
-    } catch (error) {
-      this.pendingBuilds.shift();
-      throw error;
-    }
-    return outputPromise;
-  }
-  /** Throws on error; see {@link build} for the no-throw variant. */
-  async buildOrThrow(options) {
-    const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
-    const outdir = path.resolve(options.outdir ?? "dist/assets");
-    const plugins = options.plugins ?? [];
-    const cached = await this.getOrCreateEngine(options, contextRoot);
-    const output = await this.runBuild(cached);
-    const baseResult = buildResultFromRolldownOutput(output, outdir, contextRoot);
-    return rewriteBrowserRuntimeImportsInOutputs(baseResult, contextRoot, plugins);
-  }
-  async build(options) {
-    try {
-      return await this.buildOrThrow(options);
-    } catch (error) {
-      return {
-        success: false,
-        logs: toBuildLogs(error),
-        outputs: []
-      };
-    }
-  }
-  resolve(importPath, rootDir) {
-    return moduleRequire.resolve(importPath, { paths: [rootDir] });
-  }
-  getTranspileOptions(profile) {
-    return transpileProfileToOptions(profile);
-  }
-  /**
-   * Closes the cached DevEngine and rejects any in-flight builds
-   * with `'DevBuildAdapter closed'`.
-   *
-   * @remarks
-   * Not on the {@link BuildAdapter} interface, so it is only
-   * reachable through the concrete class. The adapter is meant to
-   * live for the process lifetime; this is for explicit teardown.
-   */
-  async close() {
-    if (this.cachedEngine) {
-      await this.cachedEngine.engine.close();
-      this.cachedEngine = void 0;
-    }
-    while (this.pendingBuilds.length > 0) {
-      const pending = this.pendingBuilds.shift();
-      pending?.reject(new Error("DevBuildAdapter closed"));
-    }
-  }
-  /** Test-only: number of engines created over the adapter's lifetime. */
-  getEngineInstanceCountForTests() {
-    return this.engineInstanceCount;
-  }
-}
-function createRolldownDevBuildAdapter() {
-  return new RolldownDevBuildAdapter();
-}
-export {
-  RolldownDevBuildAdapter,
-  createRolldownDevBuildAdapter
-};

package/src/build/runtime-build-executor.d.ts

@@ -1,21 +0,0 @@
-import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import { type BuildExecutor } from './build-adapter.js';
-/**
- * Installs the app-owned runtime build executor for one app instance.
- *
- * @remarks
- * Wraps the app-owned adapter in a {@link SerializedBuildExecutor} so
- * every dev-watch caller issues builds against a single FIFO queue.
- * Plugin injection is applied here via {@link withBuildExecutorPlugins}
- * so app-owned plugins are merged into every rebuild without callers
- * having to know about the manifest.
- *
- * Idempotent across calls: re-invoking replaces the existing executor
- * on `appConfig.runtime` with a fresh wrapper.
- *
- * @param appConfig - The app config whose runtime state is updated.
- *   The function reads the existing executor (falling back to the
- *   app-owned adapter) and writes the wrapped executor back.
- * @returns The installed {@link BuildExecutor}.
- */
-export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

package/src/build/runtime-build-executor.js

@@ -1,19 +0,0 @@
-import {
-  getAppBuildAdapter,
-  getAppBuildExecutor,
-  getAppServerBuildPlugins,
-  setAppBuildExecutor,
-  withBuildExecutorPlugins
-} from "./build-adapter.js";
-import { SerializedBuildExecutor } from "./serialized-build-executor.js";
-function installAppRuntimeBuildExecutor(appConfig) {
-  const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
-  const buildExecutor = new SerializedBuildExecutor(
-    withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig))
-  );
-  setAppBuildExecutor(appConfig, buildExecutor);
-  return buildExecutor;
-}
-export {
-  installAppRuntimeBuildExecutor
-};

package/src/build/runtime-build-output-normalizer.d.ts

@@ -1,3 +0,0 @@
-export declare function isDeclaredAppPackageImport(specifier: string, rootDir: string): boolean;
-export declare function normalizeNodeRuntimeBuildOutputFile(filePath: string, rootDir: string): void;
-export declare function normalizeNodeRuntimeBuildOutputs(outputPaths: string[], rootDir: string): void;

package/src/build/runtime-build-output-normalizer.js

@@ -1,111 +0,0 @@
-import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
-const appDeclaredPackageCache = /* @__PURE__ */ new Map();
-function tryResolveRuntimeImport(specifier, resolver) {
-  try {
-    return resolver.resolve(specifier);
-  } catch {
-    return void 0;
-  }
-}
-function isBareRuntimeImport(specifier) {
-  return !specifier.startsWith(".") && !path.isAbsolute(specifier) && !specifier.startsWith("/") && !specifier.startsWith("node:") && !specifier.startsWith("@/") && !specifier.startsWith("~/") && !specifier.startsWith("#") && !specifier.includes(":");
-}
-function getPackageNameFromSpecifier(specifier) {
-  if (specifier.startsWith("@")) {
-    return specifier.split("/").slice(0, 2).join("/");
-  }
-  return specifier.split("/")[0] ?? specifier;
-}
-function getDeclaredAppPackages(rootDir) {
-  const cacheKey = path.resolve(rootDir);
-  const cached = appDeclaredPackageCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const packageJsonPath = path.resolve(rootDir, "package.json");
-  const declaredPackages = /* @__PURE__ */ new Set();
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
-      const entries = packageJson[field];
-      if (!entries || typeof entries !== "object") {
-        continue;
-      }
-      for (const packageName of Object.keys(entries)) {
-        declaredPackages.add(packageName);
-      }
-    }
-  } catch {
-    appDeclaredPackageCache.set(cacheKey, declaredPackages);
-    return declaredPackages;
-  }
-  appDeclaredPackageCache.set(cacheKey, declaredPackages);
-  return declaredPackages;
-}
-function isDeclaredAppPackageImport(specifier, rootDir) {
-  return getDeclaredAppPackages(rootDir).has(getPackageNameFromSpecifier(specifier));
-}
-function rewriteRuntimeImportSpecifier(specifier, quote, rootDir) {
-  if (!isBareRuntimeImport(specifier)) {
-    return void 0;
-  }
-  if (isDeclaredAppPackageImport(specifier, rootDir)) {
-    return void 0;
-  }
-  const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
-  if (!resolvedPath || !/\.(?:[cm]?[jt]s|tsx|jsx)$/u.test(resolvedPath)) {
-    return void 0;
-  }
-  return `${quote}${pathToFileURL(resolvedPath).href}${quote}`;
-}
-function rewriteRuntimeBuildOutputImports(code, rootDir) {
-  const rewriteSpecifier = (prefix, quote, specifier) => {
-    const rewrittenSpecifier = rewriteRuntimeImportSpecifier(specifier, quote, rootDir);
-    return `${prefix}${rewrittenSpecifier ?? `${quote}${specifier}${quote}`}`;
-  };
-  const withResolvedPackages = code.replace(
-    /(\bfrom\s+)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s+)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s*\(\s*)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  );
-  return withResolvedPackages.replace(
-    /(['"])(@oxc-project\/runtime\/(?:helpers(?:\/esm)?\/[^'"\\]+))\1/g,
-    (match, quote, specifier) => {
-      const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
-      return resolvedPath ? `${quote}${pathToFileURL(resolvedPath).href}${quote}` : match;
-    }
-  );
-}
-function normalizeNodeRuntimeBuildOutputFile(filePath, rootDir) {
-  if (!/\.(?:[cm]?js)$/u.test(filePath)) {
-    return;
-  }
-  const fileSystem = corePackageRequire("node:fs");
-  if (!fileSystem.existsSync(filePath)) {
-    return;
-  }
-  const code = fileSystem.readFileSync(filePath, "utf-8");
-  const rewritten = rewriteRuntimeBuildOutputImports(code, rootDir);
-  if (rewritten !== code) {
-    fileSystem.writeFileSync(filePath, rewritten);
-  }
-}
-function normalizeNodeRuntimeBuildOutputs(outputPaths, rootDir) {
-  for (const outputPath of outputPaths) {
-    normalizeNodeRuntimeBuildOutputFile(outputPath, rootDir);
-  }
-}
-export {
-  isDeclaredAppPackageImport,
-  normalizeNodeRuntimeBuildOutputFile,
-  normalizeNodeRuntimeBuildOutputs
-};

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,43 +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");
-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: "networkidle" });
-      await expect(title).toBeVisible();
-      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
-      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("networkidle");
-      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
-    } finally {
-      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-    }
-  });
-});

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