@ecopages/core 0.2.0-alpha.11 → 0.2.0-alpha.13

package/src/route-renderer/orchestration/render-preparation.service.js

@@ -5,9 +5,6 @@ import {
   AssetFactory
 } from "../../services/assets/asset-processing-service/index.js";
 import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
-import {
-  runWithComponentRenderContext
-} from "../../eco/component-render-context.js";
 class RenderPreparationService {
   appConfig;
   assetProcessingService;
@@ -52,13 +49,13 @@ class RenderPreparationService {
     const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
     let componentRender;
     if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
-      componentRender = await this.renderPageRoot({
-        currentIntegrationName,
+      const pageRootRender = await this.renderPageRoot({
         Page,
         props,
         routeOptions,
         callbacks
       });
+      componentRender = pageRootRender.componentRender;
       if (componentRender.assets?.length) {
         allDependencies.push(...componentRender.assets);
       }
@@ -196,12 +193,8 @@ class RenderPreparationService {
    * @returns Structured component render result.
    */
   async renderPageRoot(input) {
-    const execution = await runWithComponentRenderContext(
-      {
-        currentIntegration: input.currentIntegrationName,
-        boundaryContext: input.callbacks.getComponentRenderBoundaryContext()
-      },
-      async () => input.callbacks.renderPageComponent({
+    return {
+      componentRender: await input.callbacks.renderPageComponent({
         component: input.Page,
         props: {
           ...input.props,
@@ -209,8 +202,7 @@ class RenderPreparationService {
           query: input.routeOptions.query || {}
         }
       })
-    );
-    return execution.value;
+    };
   }
   /**
    * Builds the runtime assets needed to bootstrap global lazy trigger execution.

package/src/route-renderer/orchestration/template-serialization.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal template-result shape that core can serialize generically.
+ *
+ * @remarks
+ * Core intentionally models only the transport shape used during deferred
+ * cross-integration child passing: alternating static string segments plus
+ * interpolated runtime values. Concrete runtime markers that identify a given
+ * framework's template payload must stay outside core and be registered by the
+ * owning integration package.
+ */
+export type SerializableTemplateShape = {
+    strings: readonly string[];
+    values?: readonly unknown[];
+};
+/**
+ * Integration-owned adapter that teaches core how to serialize one deferred
+ * template payload shape.
+ *
+ * @remarks
+ * The separation here is intentional: core owns the HTML serialization logic,
+ * but integrations own runtime-shape detection. That keeps package-specific
+ * markers such as framework template sentinels out of core while still letting
+ * deferred children round-trip through mixed renderer boundaries.
+ */
+export type DeferredTemplateSerializer<TTemplate extends SerializableTemplateShape = SerializableTemplateShape> = {
+    matches(value: unknown): value is TTemplate;
+    serialize(template: TTemplate, serializeValue: (value: unknown) => string | undefined): string;
+};
+/**
+ * Serializes a generic template shape into HTML.
+ *
+ * @remarks
+ * This handles only HTML reconstruction semantics: quoted attribute values,
+ * boolean attributes, and omission of client-only event or property bindings.
+ * It does not decide whether an arbitrary value belongs to a framework-specific
+ * template runtime; integrations must make that decision before delegating here.
+ */
+export declare function serializeTemplateShape(template: SerializableTemplateShape, serializeValue: (value: unknown) => string | undefined): string;

package/src/route-renderer/orchestration/template-serialization.js

@@ -0,0 +1,45 @@
+import { escapeHtmlAttribute } from "../../utils/html-escaping.js";
+const ATTRIBUTE_TAIL_PATTERN = /(\s+)([@.?!]?)([^\s"'<>/=`@.?!]+)=$/;
+function getSerializableTemplateAttribute(stringPart) {
+  const match = ATTRIBUTE_TAIL_PATTERN.exec(stringPart);
+  if (!match) return void 0;
+  return {
+    leading: stringPart.slice(0, match.index),
+    whitespace: match[1],
+    prefix: match[2],
+    name: match[3]
+  };
+}
+function serializeTemplateShape(template, serializeValue) {
+  const values = template.values ?? [];
+  let html = "";
+  for (let index = 0; index < values.length; index += 1) {
+    const stringPart = template.strings[index] ?? "";
+    const serializedValue = serializeValue(values[index]);
+    const attribute = getSerializableTemplateAttribute(stringPart);
+    if (!attribute) {
+      html += stringPart;
+      html += serializedValue ?? "";
+      continue;
+    }
+    html += attribute.leading;
+    if (attribute.prefix === "@" || attribute.prefix === "!" || attribute.prefix === ".") {
+      continue;
+    }
+    if (attribute.prefix === "?") {
+      if (serializedValue) {
+        html += `${attribute.whitespace}${attribute.name}`;
+      }
+      continue;
+    }
+    if (serializedValue === void 0) {
+      continue;
+    }
+    html += `${attribute.whitespace}${attribute.name}="${escapeHtmlAttribute(serializedValue)}"`;
+  }
+  html += template.strings[values.length] ?? "";
+  return html;
+}
+export {
+  serializeTemplateShape
+};

package/src/route-renderer/page-loading/dependency-resolver.js

@@ -34,7 +34,12 @@ function extractEcopagesVirtualImports(file) {
     const namedImports = [];
     for (const spec of node.specifiers ?? []) {
       if (spec.type === "ImportSpecifier") {
-        const importedName = spec.imported?.type === "Identifier" ? spec.imported.name : spec.imported?.type === "Literal" ? spec.imported.value : spec.local?.name;
+        let importedName = spec.local?.name;
+        if (spec.imported?.type === "Identifier") {
+          importedName = spec.imported.name;
+        } else if (spec.imported?.type === "Literal") {
+          importedName = spec.imported.value;
+        }
         namedImports.push(importedName);
       }
     }
@@ -62,7 +67,7 @@ function createModuleScriptName(from, imports) {
   return `module-${hash}`;
 }
 function createNamedImportModuleSource(from, imports) {
-  const namedImports = imports.join(", ");
+  const namedImports = [...new Set(imports)].sort().join(", ");
   return `export { ${namedImports} } from '${from}';`;
 }
 function createNamespaceImportModuleSource(from) {
@@ -259,14 +264,11 @@ class DependencyResolverService {
               }
               scriptDependencyKeys.add(depKey2);
               dependencies.push(
-                AssetFactory.createContentScript({
+                AssetFactory.createInlineContentScript({
                   position: "head",
                   content,
-                  attributes: {
-                    type: "module",
-                    defer: "",
-                    ...attributes
-                  }
+                  bundle: false,
+                  attributes
                 })
               );
               continue;

package/src/router/client/navigation-coordinator.js

@@ -16,7 +16,7 @@ function getCandidateOwners(currentOwner, registrations, excludedOwner) {
   }
   return owners;
 }
-function createEcoNavigationRuntime(_windowObject) {
+function createEcoNavigationRuntime() {
   const registrations = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
   let owner = "none";
@@ -204,7 +204,7 @@ function getEcoNavigationRuntime(windowObject = window) {
   const runtimeWindow = windowObject;
   runtimeWindow.__ECO_PAGES__ = runtimeWindow.__ECO_PAGES__ || {};
   if (!runtimeWindow.__ECO_PAGES__.navigation) {
-    runtimeWindow.__ECO_PAGES__.navigation = createEcoNavigationRuntime(runtimeWindow);
+    runtimeWindow.__ECO_PAGES__.navigation = createEcoNavigationRuntime();
   }
   return runtimeWindow.__ECO_PAGES__.navigation;
 }

package/src/router/server/fs-router-scanner.js

@@ -113,7 +113,12 @@ class FSRouterScanner {
     const filePath = path.join(this.dir, file);
     const isCatchAll = filePath.includes("[...");
     const isDynamic = !isCatchAll && filePath.includes("[") && filePath.includes("]");
-    const kind = isCatchAll ? "catch-all" : isDynamic ? "dynamic" : "exact";
+    let kind = "exact";
+    if (isCatchAll) {
+      kind = "catch-all";
+    } else if (isDynamic) {
+      kind = "dynamic";
+    }
     return { route, routePath, filePath, kind };
   }
   async scan() {

package/src/services/module-loading/node-bootstrap-plugin.js

@@ -104,7 +104,20 @@ function resolveNodeBootstrapDependency(args, options) {
     try {
       resolvedPath2 = resolveFromCore(args.path);
     } catch {
-      resolvedPath2 = resolveSpecifier(args.path, resolveParent);
+      try {
+        resolvedPath2 = resolveSpecifier(args.path, resolveParent);
+      } catch {
+        const packageName = getPackageNameFromSpecifier(args.path);
+        const candidatePath = path.join(options.projectDir, "node_modules", packageName);
+        const candidatePackageJson = path.join(candidatePath, "package.json");
+        if (existsSync(candidatePackageJson)) {
+          ensureRuntimePackageLink(options.runtimeNodeModulesDir, args.path, candidatePackageJson);
+          return { path: args.path, external: true };
+        }
+      }
+    }
+    if (!resolvedPath2) {
+      return void 0;
     }
     if (resolvedPath2.includes(`${path.sep}node_modules${path.sep}`)) {
       ensureRuntimePackageLink(options.runtimeNodeModulesDir, args.path, resolvedPath2);

package/src/services/module-loading/page-module-import.service.js

@@ -114,7 +114,7 @@ class PageModuleImportService {
         entrypoints: [filePath],
         root: rootDir,
         outdir,
-        target: "node",
+        target: "es2022",
         format: "esm",
         sourcemap: "none",
         splitting: splitting ?? true,

package/src/services/runtime-state/dev-graph.service.d.ts

@@ -32,7 +32,7 @@ export declare class NoopDevGraphService implements DevGraphService {
     /**
      * Invalidates all server-side module state by incrementing the shared version.
      */
-    invalidateServerModules(_changedFiles?: string[]): void;
+    invalidateServerModules(changedFiles?: string[]): void;
     /**
      * Indicates that this graph cannot target invalidation to one entrypoint set.
      */
@@ -41,19 +41,19 @@ export declare class NoopDevGraphService implements DevGraphService {
      * Returns an empty entrypoint set because this implementation stores no
      * dependency graph metadata.
      */
-    getDependencyEntrypoints(_filePath: string): Set<string>;
+    getDependencyEntrypoints(filePath: string): Set<string>;
     /**
      * Accepts dependency updates to preserve interface compatibility, but stores no
      * graph state in the noop implementation.
      */
-    setEntrypointDependencies(_entrypointPath: string, _dependencies: string[]): void;
+    setEntrypointDependencies(entrypointPath: string, dependencies: string[]): void;
     /**
      * Clears one entrypoint from the graph.
      *
      * @remarks
      * There is no stored graph state in this implementation, so this is a no-op.
      */
-    clearEntrypointDependencies(_entrypointPath: string): void;
+    clearEntrypointDependencies(entrypointPath: string): void;
     /**
      * Resets graph-owned state for a fresh runtime cycle.
      */
@@ -82,7 +82,7 @@ export declare class InMemoryDevGraphService implements DevGraphService {
      * modules. Selective dependency lookups are used by callers that need to limit
      * browser rebuild work.
      */
-    invalidateServerModules(_changedFiles?: string[]): void;
+    invalidateServerModules(changedFiles?: string[]): void;
     /**
      * Indicates that this graph can answer dependency-to-entrypoint lookups.
      */

package/src/services/runtime-state/dev-graph.service.js

@@ -21,8 +21,8 @@ class NoopDevGraphService {
   /**
    * Invalidates all server-side module state by incrementing the shared version.
    */
-  invalidateServerModules(_changedFiles) {
-    this.invalidationState.invalidateServerModules(_changedFiles);
+  invalidateServerModules(changedFiles) {
+    this.invalidationState.invalidateServerModules(changedFiles);
   }
   /**
    * Indicates that this graph cannot target invalidation to one entrypoint set.
@@ -34,15 +34,15 @@ class NoopDevGraphService {
    * Returns an empty entrypoint set because this implementation stores no
    * dependency graph metadata.
    */
-  getDependencyEntrypoints(_filePath) {
-    return this.dependencyGraph.getDependencyEntrypoints(_filePath);
+  getDependencyEntrypoints(filePath) {
+    return this.dependencyGraph.getDependencyEntrypoints(filePath);
   }
   /**
    * Accepts dependency updates to preserve interface compatibility, but stores no
    * graph state in the noop implementation.
    */
-  setEntrypointDependencies(_entrypointPath, _dependencies) {
-    this.dependencyGraph.setEntrypointDependencies(_entrypointPath, _dependencies);
+  setEntrypointDependencies(entrypointPath, dependencies) {
+    this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
   }
   /**
    * Clears one entrypoint from the graph.
@@ -50,8 +50,8 @@ class NoopDevGraphService {
    * @remarks
    * There is no stored graph state in this implementation, so this is a no-op.
    */
-  clearEntrypointDependencies(_entrypointPath) {
-    this.dependencyGraph.clearEntrypointDependencies(_entrypointPath);
+  clearEntrypointDependencies(entrypointPath) {
+    this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
   }
   /**
    * Resets graph-owned state for a fresh runtime cycle.
@@ -78,8 +78,8 @@ class InMemoryDevGraphService {
    * modules. Selective dependency lookups are used by callers that need to limit
    * browser rebuild work.
    */
-  invalidateServerModules(_changedFiles) {
-    this.invalidationState.invalidateServerModules(_changedFiles);
+  invalidateServerModules(changedFiles) {
+    this.invalidationState.invalidateServerModules(changedFiles);
   }
   /**
    * Indicates that this graph can answer dependency-to-entrypoint lookups.

package/src/types/public-types.d.ts

@@ -2,6 +2,7 @@ import type { Readable } from 'node:stream';
 import type { ApiResponseBuilder } from '../adapters/shared/api-response.js';
 import type { BuildExecutor } from '../build/build-adapter.js';
 import type { EcoBuildPlugin } from '../build/build-types.js';
+import type { ComponentBoundaryRuntime } from '../route-renderer/orchestration/component-render-context.js';
 import type { EcoPageComponent } from '../eco/eco.types.js';
 import type { EcoPagesAppConfig } from './internal-types.js';
 import type { HmrStrategy } from '../hmr/hmr-strategy.js';
@@ -11,10 +12,9 @@ import type { CacheStats, CacheStrategy } from '../services/cache/cache.types.js
 import type { InteractionEventsString as ScriptsInjectorInteractionEventsString } from '@ecopages/scripts-injector/types';
 export type { EcoPagesAppConfig } from './internal-types.js';
 export type { EcoPageComponent } from '../eco/eco.types.js';
-export type { MarkerGraphContext } from '../route-renderer/component-graph/marker-graph-resolver.js';
 export type { ProcessedAsset } from '../services/assets/asset-processing-service/assets.types.js';
 import type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput } from '../services/validation/standard-schema.types.js';
-export type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, };
+export type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, ComponentBoundaryRuntime, };
 export type InteractionEventsString = ScriptsInjectorInteractionEventsString;
 export type DependencyLazyTrigger = {
     'on:idle': true;
@@ -262,6 +262,21 @@ export type EcoComponentDependencies = {
     components?: EcoComponent[];
 };
 export type EcoPagesElement = string | Promise<string>;
+/**
+ * Serializable child payloads accepted by cross-integration deferred rendering.
+ *
+ * This models the broad value shapes that EcoPages already flattens when a
+ * foreign component boundary serializes its children for another integration.
+ * It is intentionally transport-oriented rather than framework-native, so it
+ * can be shared across Kita, Lit, React, and Ecopages JSX authoring surfaces
+ * without coupling core types to any one renderer.
+ */
+export type EcoChildren = string | Promise<string> | number | bigint | boolean | null | undefined | readonly EcoChildren[] | {
+    strings: readonly string[];
+    values?: readonly EcoChildren[];
+} | {
+    [key: string]: EcoChildren;
+};
 /**
  * Represents the input configuration for EcoPages.
  */
@@ -667,7 +682,7 @@ export type IntegrationRendererRenderOptions<C = EcoPagesElement> = RouteRendere
 export interface ComponentRenderInput {
     component: EcoComponent;
     props: Record<string, unknown>;
-    children?: string;
+    children?: unknown;
     integrationContext?: unknown;
 }
 export interface ComponentRenderResult {

package/src/utils/html-escaping.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Escapes a string for safe use inside a double-quoted HTML attribute value.
+ *
+ * @param value Raw attribute value.
+ * @returns Escaped attribute-safe string.
+ */
+export declare function escapeHtmlAttribute(value: string): string;

package/src/utils/html-escaping.js

@@ -0,0 +1,6 @@
+function escapeHtmlAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+export {
+  escapeHtmlAttribute
+};

package/src/eco/component-render-context.d.ts

@@ -1,105 +0,0 @@
-import type { EcoComponent } from '../types/public-types.js';
-import type { MarkerNodeId } from '../route-renderer/component-graph/component-marker.js';
-/**
- * Outcome returned by boundary policy during one component render pass.
- *
- * - `inline`: render the target component immediately in the current pass
- * - `defer`: emit an `eco-marker` and resolve it during the marker graph phase
- */
-export type BoundaryRenderMode = 'inline' | 'defer';
-/**
- * Input provided to boundary policy when a component boundary is reached.
- *
- * This keeps `eco.component()` decoupled from concrete integration/plugin
- * objects while still giving policy enough information to decide whether the
- * boundary should render immediately or be deferred.
- */
-export type BoundaryRenderDecisionInput = {
-    currentIntegration: string;
-    targetIntegration?: string;
-    component: EcoComponent;
-};
-/**
- * Narrow render-pass facade used by `eco.component()` for boundary decisions.
- *
- * The boundary context is intentionally small so component rendering can remain
- * unaware of integration registries, plugin instances, or renderer lifecycles.
- */
-export type ComponentRenderBoundaryContext = {
-    /**
-     * Decides whether the next component boundary should render inline or defer to
-     * the marker graph stage.
-     *
-     * @param input Boundary metadata for the current render pass.
-     * @returns Boundary rendering mode for the target component.
-     */
-    decideBoundaryRender(input: BoundaryRenderDecisionInput): BoundaryRenderMode;
-};
-/**
- * Per-render mutable state used while collecting marker graph references.
- *
- * Counters generate deterministic ids within one render execution.
- */
-type ComponentRenderContext = {
-    currentIntegration: string;
-    boundaryContext: ComponentRenderBoundaryContext;
-    nextNodeId: number;
-    nextPropsRefId: number;
-    nextSlotRefId: number;
-    propsByRef: Record<string, Record<string, unknown>>;
-    slotChildrenByRef: Record<string, MarkerNodeId[]>;
-};
-/**
- * Serializable graph context captured from one render execution.
- *
- * This payload is merged with explicit page-module graph context before marker
- * resolution in the route renderer.
- */
-export type ComponentGraphContext = {
-    propsByRef: Record<string, Record<string, unknown>>;
-    slotChildrenByRef: Record<string, MarkerNodeId[]>;
-};
-/**
- * Returns the current component render context, if one is active.
- *
- * @returns Active render context or `undefined` outside render execution.
- */
-export declare function getComponentRenderContext(): ComponentRenderContext | undefined;
-/**
- * Allocates the next marker node id in the active render context.
- *
- * @param context Active render context.
- * @returns Stable marker node id for this render pass.
- */
-export declare function createNodeId(context: ComponentRenderContext): MarkerNodeId;
-/**
- * Allocates the next props reference id in the active render context.
- *
- * @param context Active render context.
- * @returns Props reference key.
- */
-export declare function createPropsRef(context: ComponentRenderContext): string;
-/**
- * Allocates the next slot reference id in the active render context.
- *
- * @param context Active render context.
- * @returns Slot reference key.
- */
-export declare function createSlotRef(context: ComponentRenderContext): string;
-/**
- * Runs render work under a fresh component render context and returns both:
- * - the render result value
- * - captured graph reference maps for downstream marker resolution
- *
- * @param input Execution metadata for current integration and boundary policy.
- * @param render Async render function to execute inside the context.
- * @returns Render result and captured graph context maps.
- */
-export declare function runWithComponentRenderContext<T>(input: {
-    currentIntegration: string;
-    boundaryContext: ComponentRenderBoundaryContext;
-}, render: () => Promise<T>): Promise<{
-    value: T;
-    graphContext: ComponentGraphContext;
-}>;
-export {};

package/src/eco/component-render-context.js

@@ -1,94 +0,0 @@
-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];
-}
-function createNodeId(context) {
-  context.nextNodeId += 1;
-  return `n_${context.nextNodeId}`;
-}
-function createPropsRef(context) {
-  context.nextPropsRefId += 1;
-  return `p_${context.nextPropsRefId}`;
-}
-function createSlotRef(context) {
-  context.nextSlotRefId += 1;
-  return `s_${context.nextSlotRefId}`;
-}
-async function runWithComponentRenderContext(input, render) {
-  const context = {
-    currentIntegration: input.currentIntegration,
-    boundaryContext: input.boundaryContext,
-    nextNodeId: 0,
-    nextPropsRefId: 0,
-    nextSlotRefId: 0,
-    propsByRef: {},
-    slotChildrenByRef: {}
-  };
-  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,
-    graphContext: {
-      propsByRef: context.propsByRef,
-      slotChildrenByRef: context.slotChildrenByRef
-    }
-  };
-}
-export {
-  createNodeId,
-  createPropsRef,
-  createSlotRef,
-  getComponentRenderContext,
-  runWithComponentRenderContext
-};

package/src/route-renderer/component-graph/component-graph-executor.d.ts

@@ -1,33 +0,0 @@
-import type { ComponentMarker } from './component-marker.js';
-import type { ComponentGraph } from './component-graph.js';
-/**
- * Render result returned by a graph node resolver.
- *
- * `html` is inserted in place of the corresponding marker token.
- */
-export type GraphNodeRenderResult = {
-    html: string;
-};
-/**
- * Callback used to render one marker node during graph execution.
- *
- * Resolver implementations may call integration-specific `renderComponent`
- * and can use closure state to wire child output into parent render calls.
- */
-export type GraphNodeResolver = (marker: ComponentMarker) => Promise<GraphNodeRenderResult>;
-/**
- * Resolves all markers in bottom-up order based on computed graph levels.
- *
- * Child nodes are resolved first so parent slot content can consume already
- * resolved child HTML in subsequent resolver invocations.
- *
- * Nodes discovered from serialized props may not exist as literal marker tokens in
- * `inputHtml`. They still resolve so parent nodes can consume their stitched child
- * HTML, while replacement in the outer HTML buffer remains a no-op.
- *
- * @param inputHtml HTML containing marker tokens.
- * @param graph Precomputed marker graph with topological levels.
- * @param resolver Async callback that renders each marker node.
- * @returns HTML with resolved markers replaced.
- */
-export declare function resolveComponentGraph(inputHtml: string, graph: ComponentGraph, resolver: GraphNodeResolver): Promise<string>;

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

@@ -1,30 +0,0 @@
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function replaceMarkerByNodeId(html, nodeId, replacement) {
-  const pattern = `<eco-marker[^>]*data-eco-node-id="${escapeRegex(nodeId)}"[^>]*><\\/eco-marker>`;
-  const markerRegex = new RegExp(pattern);
-  return html.replace(markerRegex, replacement);
-}
-async function resolveComponentGraph(inputHtml, graph, resolver) {
-  let html = inputHtml;
-  const markersById = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes.values()) {
-    markersById.set(node.nodeId, node);
-  }
-  const levels = [...graph.levels].reverse();
-  for (const level of levels) {
-    for (const nodeId of level) {
-      const marker = markersById.get(nodeId);
-      if (!marker) {
-        continue;
-      }
-      const result = await resolver(marker);
-      html = replaceMarkerByNodeId(html, nodeId, result.html);
-    }
-  }
-  return html;
-}
-export {
-  resolveComponentGraph
-};