@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

package/src/config/config-builder.js

@@ -4,30 +4,22 @@ import {
   DEFAULT_ECOPAGES_HOSTNAME,
   DEFAULT_ECOPAGES_PORT,
   DEFAULT_ECOPAGES_WORK_DIR
-} from "../constants.js";
+} from "../config/constants.js";
 import {
   collectConfiguredAppBuildManifestContributions,
   createBuildAdapter,
-  getAppServerBuildPlugins,
   setAppBuildAdapter,
   setAppBuildExecutor,
   updateAppBuildManifest
 } from "../build/build-adapter.js";
-import { createAppBuildExecutor } from "../build/dev-build-coordinator.js";
-import { GHTML_PLUGIN_NAME, ghtmlPlugin } from "../integrations/ghtml/ghtml.plugin.js";
+import { GHTML_PLUGIN_NAME } from "../integrations/ghtml/ghtml.constants.js";
+import { ghtmlPlugin } from "../integrations/ghtml/ghtml.plugin.js";
 import { createEcoComponentMetaPlugin } from "../plugins/eco-component-meta-plugin.js";
+import { createEcoComponentMetaTransform } from "../plugins/eco-component-meta-plugin.js";
 import {
   NoopEntrypointDependencyGraph,
   setAppEntrypointDependencyGraph
 } from "../services/runtime-state/entrypoint-dependency-graph.service.js";
-import {
-  createNodeRuntimeManifest,
-  setAppNodeRuntimeManifest
-} from "../services/runtime-manifest/node-runtime-manifest.service.js";
-import {
-  InMemoryRuntimeSpecifierRegistry,
-  setAppRuntimeSpecifierRegistry
-} from "../services/runtime-state/runtime-specifier-registry.service.js";
 import {
   CounterServerInvalidationState,
   setAppServerInvalidationState
@@ -47,6 +39,7 @@ const CONFIG_BUILDER_ERRORS = {
   invalidRuntimeVersion: (kind, name, version) => `Cannot validate ${kind} "${name}" runtimeCapability.minRuntimeVersion "${version}" because it is not a dot-separated numeric version`
 };
 class ConfigBuilder {
+  buildOwnership = "rolldown";
   config = {
     baseUrl: "",
     rootDir: ".",
@@ -86,6 +79,7 @@ class ConfigBuilder {
     },
     processors: /* @__PURE__ */ new Map(),
     loaders: /* @__PURE__ */ new Map(),
+    sourceTransforms: /* @__PURE__ */ new Map(),
     workDir: DEFAULT_ECOPAGES_WORK_DIR
   };
   /**
@@ -110,6 +104,32 @@ class ConfigBuilder {
     this.config.rootDir = rootDir;
     return this;
   }
+  /**
+   * Sets which runtime path owns build execution for the finalized app config.
+   *
+   * @remarks
+   * Three ownership values are accepted:
+   *
+   * - `'rolldown'` (default): Ecopages runs builds through
+   *   {@link RolldownBuildAdapter}, creating a new `rolldown()` instance
+   *   per build. Best for one-shot production builds and benchmarks.
+   * - `'rolldown-dev'`: Ecopages runs builds through
+   *   {@link RolldownDevBuildAdapter}, which wraps Rolldown's experimental
+   *   `DevEngine` and reuses the cached module graph, resolver, and
+   *   transform cache across rebuilds. Best for HMR and watch mode where
+   *   the same entrypoints are rebuilt repeatedly.
+   * - `'vite-host'`: a host runtime owns the build. Ecopages exposes a
+   *   {@link ViteHostBuildAdapter} boundary marker that throws on direct
+   *   use. Select this only for host-driven compatibility flows where
+   *   core must not silently fall back to app build execution.
+   *
+   * Defaults to `'rolldown'` when {@link ConfigBuilder.build} runs
+   * without an explicit ownership.
+   */
+  setBuildOwnership(buildOwnership) {
+    this.buildOwnership = buildOwnership;
+    return this;
+  }
   /**
    * Sets the source directory relative to the root directory.
    * This directory contains all the source files for the application.
@@ -289,6 +309,17 @@ class ConfigBuilder {
     }
     return this;
   }
+  /**
+   * Sets the source transforms to use for transform-first bundlers such as Vite.
+   * This replaces any existing source transforms.
+   */
+  setSourceTransforms(sourceTransforms) {
+    this.config.sourceTransforms.clear();
+    for (const sourceTransform of sourceTransforms) {
+      this.addSourceTransform(sourceTransform.name, sourceTransform);
+    }
+    return this;
+  }
   /**
    * Adds a loader to the application.
    *
@@ -304,6 +335,18 @@ class ConfigBuilder {
     this.config.loaders.set(name, loader);
     return this;
   }
+  /**
+   * Adds a source transform to the application.
+   *
+   * @throws Error if a source transform with the same name already exists.
+   */
+  addSourceTransform(name, sourceTransform) {
+    if (this.config.sourceTransforms.has(name)) {
+      throw new Error(CONFIG_BUILDER_ERRORS.duplicateLoaderName(name));
+    }
+    this.config.sourceTransforms.set(name, sourceTransform);
+    return this;
+  }
   /**
    * Sets the cache configuration for ISR and page caching.
    *
@@ -364,7 +407,7 @@ class ConfigBuilder {
     const hasKitaJs = uniqueName.has("kitajs");
     const hasReact = uniqueName.has("react");
     if (hasKitaJs && hasReact) {
-      appLogger.warn(CONFIG_BUILDER_ERRORS.MIXED_JSX_ENGINES);
+      appLogger.debug(CONFIG_BUILDER_ERRORS.MIXED_JSX_ENGINES);
     }
     const integrationsExtensions = integrations.flatMap((integration) => integration.extensions);
     const uniqueExtensions = new Set(integrationsExtensions);
@@ -507,6 +550,10 @@ class ConfigBuilder {
    * This includes the eco-component-meta-plugin which auto-injects __eco metadata into component configs.
    */
   async initializeDefaultLoaders() {
+    const componentMetaTransform = createEcoComponentMetaTransform({ config: this.config });
+    if (!this.config.sourceTransforms.has(componentMetaTransform.name)) {
+      this.config.sourceTransforms.set(componentMetaTransform.name, componentMetaTransform);
+    }
     const componentMetaPlugin = createEcoComponentMetaPlugin({ config: this.config });
     if (!this.config.loaders.has(componentMetaPlugin.name)) {
       this.config.loaders.set(componentMetaPlugin.name, componentMetaPlugin);
@@ -541,21 +588,12 @@ class ConfigBuilder {
     await this.initializeDefaultLoaders();
     this.initializeProcessors();
     this.validateRuntimeCapabilities();
-    const buildAdapter = createBuildAdapter();
+    const buildAdapter = createBuildAdapter({ ownership: this.buildOwnership });
     setAppBuildAdapter(this.config, buildAdapter);
     updateAppBuildManifest(this.config, await collectConfiguredAppBuildManifestContributions(this.config));
     setAppServerInvalidationState(this.config, new CounterServerInvalidationState());
     setAppEntrypointDependencyGraph(this.config, new NoopEntrypointDependencyGraph());
-    setAppRuntimeSpecifierRegistry(this.config, new InMemoryRuntimeSpecifierRegistry());
-    setAppBuildExecutor(
-      this.config,
-      createAppBuildExecutor({
-        development: false,
-        adapter: buildAdapter,
-        getPlugins: () => getAppServerBuildPlugins(this.config)
-      })
-    );
-    setAppNodeRuntimeManifest(this.config, createNodeRuntimeManifest(this.config));
+    setAppBuildExecutor(this.config, buildAdapter);
     return this.config;
   }
 }

package/src/declarations.d.ts

@@ -1,4 +1,4 @@
-import type { EcoPagesAppConfig } from './internal-types';
+import type { EcoPagesAppConfig } from './types/internal-types';
 import type { EcoNavigationRuntime } from './router/client/navigation-coordinator';
 
 type HMRHandler = (url: string) => Promise<void>;

package/src/dev/host-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { EcoPagesAppConfig } from '../types/public-types.js';
+import { type DevelopmentInvalidationPlan } from '../services/invalidation/development-invalidation.service.js';
+export type HostRuntimeModuleLoader = (id: string) => Promise<unknown>;
+export interface DevelopmentHostRuntime {
+    registerHostModuleLoader(loader: HostRuntimeModuleLoader): void;
+    planFileChange(filePath: string): DevelopmentInvalidationPlan;
+    invalidateServerModules(changedFiles?: string[]): void;
+    resetRuntimeState(changedFiles?: string[]): void;
+}
+export declare function createDevelopmentHostRuntime(appConfig: EcoPagesAppConfig): DevelopmentHostRuntime;

package/src/dev/host-runtime.js

@@ -0,0 +1,24 @@
+import {
+  DevelopmentInvalidationService
+} from "../services/invalidation/development-invalidation.service.js";
+import { setHostModuleLoader } from "../services/module-loading/host-module-loader-registry.js";
+function createDevelopmentHostRuntime(appConfig) {
+  const invalidationService = new DevelopmentInvalidationService(appConfig);
+  return {
+    registerHostModuleLoader(loader) {
+      setHostModuleLoader(loader);
+    },
+    planFileChange(filePath) {
+      return invalidationService.planFileChange(filePath);
+    },
+    invalidateServerModules(changedFiles) {
+      invalidationService.invalidateServerModules(changedFiles);
+    },
+    resetRuntimeState(changedFiles) {
+      invalidationService.resetRuntimeState(changedFiles);
+    }
+  };
+}
+export {
+  createDevelopmentHostRuntime
+};

package/src/dev/sc-server.d.ts

@@ -1,5 +1,5 @@
 import type { Server } from 'bun';
-import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
 type StaticContentServerOptions = {
     port?: number;
 };

package/src/dev/sc-server.js

@@ -1,5 +1,5 @@
 import { extname, join } from "node:path";
-import { STATUS_MESSAGE } from "../constants.js";
+import { STATUS_MESSAGE } from "../config/constants.js";
 import { fileSystem } from "@ecopages/file-system";
 import { ServerUtils } from "../utils/server-utils.module.js";
 import { getRequiredBunRuntime } from "../utils/runtime.js";

package/src/eco/eco.browser.d.ts

@@ -0,0 +1,2 @@
+import type { Eco } from './eco.types.js';
+export declare const eco: Eco;

package/src/eco/eco.browser.js

@@ -0,0 +1,88 @@
+function createComponentFactory(options) {
+  const component2 = ((props) => options.render(props));
+  component2.config = {
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: options.dependencies
+  };
+  return component2;
+}
+function component(options) {
+  return createComponentFactory(options);
+}
+function embed(component2, props, children) {
+  const nextProps = children === void 0 ? props : { ...props, children };
+  return component2(nextProps);
+}
+function html(options) {
+  return createComponentFactory(options);
+}
+function layout(options) {
+  return createComponentFactory(options);
+}
+function page(options) {
+  const {
+    layout: pageLayout,
+    dependencies,
+    render,
+    staticPaths: staticPaths2,
+    staticProps: staticProps2,
+    metadata: metadata2,
+    cache,
+    requires,
+    middleware
+  } = options;
+  const pageComponent = createComponentFactory({
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: pageLayout ? {
+      ...dependencies,
+      components: [...dependencies?.components ?? [], pageLayout]
+    } : dependencies,
+    render
+  });
+  if (pageLayout && pageComponent.config) {
+    pageComponent.config.layout = pageLayout;
+  }
+  if (staticPaths2) {
+    pageComponent.staticPaths = staticPaths2;
+  }
+  if (staticProps2) {
+    pageComponent.staticProps = staticProps2;
+  }
+  if (metadata2) {
+    pageComponent.metadata = metadata2;
+  }
+  if (cache) {
+    pageComponent.cache = cache;
+  }
+  if (requires) {
+    pageComponent.requires = requires;
+  }
+  if (middleware) {
+    pageComponent.middleware = middleware;
+  }
+  return pageComponent;
+}
+function metadata(fn) {
+  return fn;
+}
+function staticPaths(fn) {
+  return fn;
+}
+function staticProps(fn) {
+  return fn;
+}
+const eco = {
+  component,
+  embed,
+  html,
+  layout,
+  page,
+  metadata,
+  staticPaths,
+  staticProps
+};
+export {
+  eco
+};

package/src/eco/eco.js

@@ -1,56 +1,40 @@
-import { createNodeId, createPropsRef, createSlotRef, getComponentRenderContext } from "./component-render-context.js";
-import { createComponentMarker, parseComponentMarkers } from "../route-renderer/component-graph/component-marker.js";
-import { getComponentReference } from "../route-renderer/component-graph/component-reference.js";
-import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from "./eco.utils.js";
+import {
+  finalizeComponentRender,
+  getComponentRenderContext,
+  interceptForeignChild
+} from "../route-renderer/orchestration/component-render-context.js";
+import { isThenable } from "../route-renderer/orchestration/render-output.utils.js";
 function createComponentFactory(options) {
   const integrationName = options.integration ?? options.__eco?.integration;
   const comp = ((props) => {
-    const renderContext = getComponentRenderContext();
-    const shouldEmitMarker = renderContext !== void 0 && renderContext.boundaryContext.decideBoundaryRender({
-      currentIntegration: renderContext.currentIntegration,
-      targetIntegration: integrationName,
-      component: comp
-    }) === "defer";
-    if (shouldEmitMarker && renderContext) {
-      const nodeId = createNodeId(renderContext);
-      const propsRef = createPropsRef(renderContext);
-      const componentRef = getComponentReference(comp);
-      const componentProps = props ?? {};
-      renderContext.propsByRef[propsRef] = componentProps;
-      let slotRef;
-      const children = componentProps.children;
-      if (typeof children === "string" && children.includes("<eco-marker")) {
-        const childMarkers = parseComponentMarkers(children);
-        if (childMarkers.length > 0) {
-          slotRef = createSlotRef(renderContext);
-          renderContext.slotChildrenByRef[slotRef] = childMarkers.map((marker) => marker.nodeId);
+    const componentProps = props ?? {};
+    const renderInline = (nextProps = props) => finalizeComponentRender(comp, options.render(nextProps));
+    const activeRenderContext = getComponentRenderContext();
+    const foreignChildRender = interceptForeignChild({
+      component: comp,
+      props: componentProps,
+      targetIntegration: integrationName
+    });
+    if (isThenable(foreignChildRender)) {
+      return foreignChildRender.then((resolvedForeignChildRender) => {
+        if (resolvedForeignChildRender?.kind === "resolved") {
+          return resolvedForeignChildRender.value;
         }
-      }
-      return createComponentMarker({
-        nodeId,
-        integration: integrationName,
-        componentRef,
-        propsRef,
-        slotRef
+        return renderInline(resolvedForeignChildRender?.props ?? props);
       });
     }
-    const content = options.render(props);
-    const lazyTriggers = comp.config?._resolvedLazyTriggers;
-    if (lazyTriggers && lazyTriggers.length > 0) {
-      const triggerId = lazyTriggers[0].triggerId;
-      if (isThenable(content)) {
-        return content.then((resolvedContent) => addTriggerAttribute(resolvedContent, triggerId));
-      }
-      return addTriggerAttribute(content, triggerId);
+    if (foreignChildRender?.kind === "resolved") {
+      return foreignChildRender.value;
     }
-    const lazyGroups = comp.config?._resolvedLazyScripts;
-    if (lazyGroups && lazyGroups.length > 0) {
-      if (isThenable(content)) {
-        return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
-      }
-      return wrapWithScriptsInjector(content, lazyGroups);
+    if (foreignChildRender?.kind === "inline") {
+      return renderInline(foreignChildRender.props ?? props);
     }
-    return content;
+    if (activeRenderContext && activeRenderContext.foreignChildRuntime && integrationName && integrationName !== activeRenderContext.currentIntegration) {
+      throw new Error(
+        `[ecopages] Missing foreign-child interception from ${activeRenderContext.currentIntegration} to ${integrationName} for ${options.__eco?.file ?? "unknown component"}.`
+      );
+    }
+    return renderInline();
   });
   comp.config = {
     __eco: options.__eco,
@@ -62,6 +46,26 @@ function createComponentFactory(options) {
 function component(options) {
   return createComponentFactory(options);
 }
+function isMissingForeignChildInterceptionError(error) {
+  return error instanceof Error && error.message.startsWith("[ecopages] Missing foreign-child interception from ");
+}
+function embed(component2, props, children) {
+  const activeRenderContext = getComponentRenderContext();
+  const ecoComponent = component2;
+  const targetIntegration = ecoComponent.config?.integration ?? ecoComponent.config?.__eco?.integration;
+  const componentFile = ecoComponent.config?.__eco?.file ?? "unknown component";
+  const nextProps = children === void 0 ? props : { ...props, children };
+  try {
+    return component2(nextProps);
+  } catch (error) {
+    if (!isMissingForeignChildInterceptionError(error)) {
+      throw error;
+    }
+    throw new Error(
+      `[ecopages] eco.embed() could not hand off the Foreign Child from ${activeRenderContext?.currentIntegration ?? "unknown integration"} to ${targetIntegration ?? "unknown integration"} for ${componentFile}. The active Integration renderer exposed a foreign-child runtime, but it did not intercept this cross-integration render. Ensure mixed-integration Page, Layout, Html, or Component renders install foreign-child handoff before calling eco.embed().`
+    );
+  }
+}
 function html(options) {
   return createComponentFactory(options);
 }
@@ -102,6 +106,7 @@ function staticProps(fn) {
 }
 const eco = {
   component,
+  embed,
   html,
   layout,
   page,

package/src/eco/eco.types.d.ts

@@ -2,8 +2,53 @@
  * Type definitions for the eco namespace API
  * @module
  */
-import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, Middleware, RequestLocals, RequestPageContext } from '../public-types.js';
+import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, FileRouteMiddleware, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, RequestLocals, RequestPageContext } from '../types/public-types.js';
 import type { CacheStrategy } from '../services/cache/cache.types.js';
+/**
+ * Extracts the props type from one eco component.
+ */
+export type PropsOf<TComponent extends EcoComponent> = TComponent extends EcoComponent<infer P, any> ? P : never;
+/**
+ * Extracts the render result type from one eco component.
+ */
+export type ResultOf<TComponent extends EcoComponent> = TComponent extends EcoComponent<any, infer R> ? R : never;
+/**
+ * Narrows an eco component to its callable function signature.
+ *
+ * This is useful for helper modules such as `EcoEmbed` that invoke a component
+ * directly and need to exclude the non-callable metadata shape from the public
+ * type surface.
+ */
+export type CallableComponentOf<TComponent extends EcoComponent> = Extract<TComponent, (props: any, ...args: any[]) => any>;
+/**
+ * Extracts the declared `children` type from one eco component when present.
+ */
+export type ChildrenOf<TComponent extends EcoComponent> = PropsOf<TComponent> extends {
+    children?: infer T;
+} ? T : PropsOf<TComponent> extends {
+    children: infer T;
+} ? T : never;
+/**
+ * Extracts the props accepted by `eco.embed()` before optional `children`
+ * injection.
+ *
+ * When the target component already declares `children`, callers pass the rest
+ * of the props bag here and provide `children` as the third `eco.embed()`
+ * argument or the `EcoEmbed` wrapper children slot.
+ */
+export type EmbedPropsOf<TComponent extends EcoComponent> = 'children' extends keyof PropsOf<TComponent> ? Omit<PropsOf<TComponent>, 'children'> : PropsOf<TComponent>;
+/**
+ * Props accepted by integration-owned `EcoEmbed` adapters.
+ *
+ * The `component` field is narrowed to the callable portion of the target eco
+ * component so JSX wrappers can invoke `eco.embed()` without repeating local
+ * callable-component extraction logic.
+ */
+export type EcoEmbedProps<TComponent extends EcoComponent> = {
+    component: CallableComponentOf<TComponent>;
+    props: EmbedPropsOf<TComponent>;
+    children?: unknown;
+};
 type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
     [P in K]-?: Exclude<RequestLocals[P], null | undefined>;
 };
@@ -86,16 +131,13 @@ interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsB
      * Request-time middleware for file-based routes.
      * Runs before rendering and can short-circuit by returning a Response.
      */
-    middleware: Middleware[];
+    middleware: FileRouteMiddleware[];
 }
 /**
  * Options for creating a page with eco.page()
  *
- * Supports two patterns:
- * 1. **Consolidated API** (recommended): Define staticPaths, staticProps, and metadata inline
- * 2. **Separate exports** (legacy): Export getStaticPaths, getStaticProps, getMetadata separately
- *
- * When using `middleware`, `cache` must be set to `'dynamic'` because middleware
+ * Define staticPaths, staticProps, and metadata inline. When using
+ * `middleware`, `cache` must be set to `'dynamic'` because middleware
  * runs on every request and caching would bypass middleware effects.
  *
  * @template T - The props type for the page
@@ -127,7 +169,7 @@ export type EcoPageComponent<T> = EcoComponent<PagePropsFor<T> & Partial<Request
     metadata?: GetMetadata<T>;
     cache?: CacheStrategy;
     requires?: PageRequires;
-    middleware?: Middleware[];
+    middleware?: FileRouteMiddleware[];
 };
 /**
  * The eco namespace interface
@@ -139,6 +181,16 @@ export interface Eco {
      * @template E - Element/return type (EcoPagesElement for Kita, ReactNode for React)
      */
     component: <P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>) => EcoComponent<P, E>;
+    /**
+     * Render a component explicitly, with an optional `children` argument.
+     *
+     * This is useful when authoring crosses integration boundaries and inline JSX
+     * would otherwise force one file to model multiple JSX namespaces.
+     */
+    embed: {
+        <TComponent extends EcoComponent>(component: CallableComponentOf<TComponent>, props: PropsOf<TComponent>): ResultOf<TComponent>;
+        <TComponent extends EcoComponent>(component: CallableComponentOf<TComponent>, props: EmbedPropsOf<TComponent>, children: ChildrenOf<TComponent> | unknown): ResultOf<TComponent>;
+    };
     /**
      * Create a document shell component for the HTML wrapper.
      */

package/src/eco/eco.utils.d.ts

@@ -1,40 +1 @@
-import type { EcoComponent } from '../public-types.js';
-/**
- * Returns `true` when `value` is a thenable (Promise-like) object.
- *
- * Used to transparently handle both synchronous and asynchronous component
- * render results without requiring every caller to branch on `instanceof Promise`.
- *
- * @typeParam T Expected resolved type of the thenable.
- */
-export declare function isThenable<T>(value: unknown): value is PromiseLike<T>;
-/**
- * Injects `data-eco-trigger` into the first real HTML element opening tag of
- * a component's rendered output string.
- *
- * The scan skips over leading whitespace, HTML comments (`<!-- -->`), CDATA
- * sections, and doctype declarations so that the attribute is always placed on
- * the first actual element — not spurious markup that can precede it.
- *
- * The insertion point is the end of the element's tag name, before any existing
- * attributes or the closing `>`, which produces output like:
- *
- * ```html
- * <my-element data-eco-trigger="eco-trigger-abc123" class="foo">…</my-element>
- * ```
- *
- * When no eligible opening tag is found the original string is returned
- * unchanged so callers never receive a broken fragment.
- *
- * @param content Rendered HTML string (or any value coercible to string).
- * @param triggerId Stable trigger identifier produced by `buildResolvedLazyTriggers`.
- */
-export declare function addTriggerAttribute(content: unknown, triggerId: string): string;
-/**
- * Wraps rendered component output in a `<scripts-injector>` element that
- * carries an inline injector map for the legacy (non-global-injector) path.
- *
- * @param content Rendered component HTML.
- * @param lazyGroups Resolved lazy script groups attached to the component config.
- */
-export declare function wrapWithScriptsInjector(content: unknown, lazyGroups: NonNullable<EcoComponent['config']>['_resolvedLazyScripts']): string;
+export { addTriggerAttribute, isThenable, wrapWithScriptsInjector, } from '../route-renderer/orchestration/render-output.utils.js';

package/src/eco/eco.utils.js

@@ -1,38 +1,8 @@
-import { buildInjectorMapScript } from "./lazy-injector-map.js";
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function addTriggerAttribute(content, triggerId) {
-  const str = String(content);
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] !== "<") {
-      i++;
-      continue;
-    }
-    const next = str[i + 1];
-    if (next === "!" || next === "?") {
-      const end = str.indexOf(">", i);
-      if (end === -1) break;
-      i = end + 1;
-      continue;
-    }
-    if (next && /[a-zA-Z]/.test(next)) {
-      const tagSlice = str.slice(i + 1);
-      const nameEnd = tagSlice.search(/[\s/>]/);
-      if (nameEnd === -1) break;
-      const insertAt = i + 1 + nameEnd;
-      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
-    }
-    break;
-  }
-  return str;
-}
-function wrapWithScriptsInjector(content, lazyGroups) {
-  const wrappedContent = String(content);
-  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
-  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${wrappedContent}<\/scripts-injector>`;
-}
+import {
+  addTriggerAttribute,
+  isThenable,
+  wrapWithScriptsInjector
+} from "../route-renderer/orchestration/render-output.utils.js";
 export {
   addTriggerAttribute,
   isThenable,

package/src/eco/global-injector-map.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedLazyTrigger } from '../public-types.js';
+import type { ResolvedLazyTrigger } from '../types/public-types.js';
 /**
  * Serializes resolved lazy triggers into a JSON string safe for embedding
  * inside an inline `<script type="ecopages/global-injector-map">` tag.
@@ -10,7 +10,7 @@ import type { ResolvedLazyTrigger } from '../public-types.js';
  */
 export declare function buildGlobalInjectorMapScript(triggers: ResolvedLazyTrigger[]): string;
 /**
- * Builds the inline module script that boots the global lazy injector on the client.
+ * Builds the module source that boots the global lazy injector on the client.
  * Emitted once per page alongside the `ecopages/global-injector-map` script block.
  */
-export declare function buildGlobalInjectorBootstrapContent(globalInjectorModuleUrl: string): string;
+export declare function buildGlobalInjectorBootstrapContent(globalInjectorModuleSpecifier: string): string;

package/src/eco/global-injector-map.js

@@ -37,8 +37,8 @@ function buildGlobalInjectorMapScript(triggers) {
   const map = buildGlobalInjectorMap(triggers);
   return JSON.stringify(map).replace(/<\/script/gi, "<\\/script");
 }
-function buildGlobalInjectorBootstrapContent(globalInjectorModuleUrl) {
-  return `import { initGlobalInjector } from ${JSON.stringify(globalInjectorModuleUrl)};
+function buildGlobalInjectorBootstrapContent(globalInjectorModuleSpecifier) {
+  return `import { initGlobalInjector } from ${JSON.stringify(globalInjectorModuleSpecifier)};
 
 function pruneStaleTriggerMaps() {
 	const mapScripts = Array.from(document.querySelectorAll('script[type="ecopages/global-injector-map"]'));

package/src/eco/lazy-injector-map.d.ts

@@ -1,8 +1,8 @@
-import type { ResolvedLazyScriptGroup } from '../public-types.js';
+import type { ResolvedLazyScriptGroup } from '../types/public-types.js';
 /**
  * Creates a safe JSON payload string for `<script type="ecopages/injector-map">`.
  *
  * @param lazyGroups Lazy script groups resolved during dependency processing.
  * @returns Escaped JSON string safe for inline script embedding.
  */
-export declare function buildInjectorMapScript(lazyGroups: ResolvedLazyScriptGroup[]): string;
+export declare function buildInjectorMapScript(lazyGroups: readonly ResolvedLazyScriptGroup[]): string;