@ecopages/core 0.2.0-alpha.1

package/src/eco/eco.ts

@@ -0,0 +1,221 @@
+/**
+ * The eco namespace - unified component and page factory API
+ * @module
+ */
+
+import type {
+	EcoComponent,
+	EcoPagesElement,
+	EcoPageComponent,
+	GetMetadata,
+	GetStaticPaths,
+	GetStaticProps,
+	Middleware,
+	RequestLocals,
+	RequestPageContext,
+} from '../public-types.ts';
+import type { CacheStrategy } from '../services/cache/cache.types.ts';
+import type {
+	ComponentOptions,
+	Eco,
+	PageOptions,
+	PageOptionsBase,
+	PagePropsFor,
+	PagePropsForWithLocals,
+	PageRequires,
+} from './eco.types.ts';
+import { createNodeId, createPropsRef, createSlotRef, getComponentRenderContext } from './component-render-context.ts';
+import { createComponentMarker, parseComponentMarkers } from '../route-renderer/component-marker.ts';
+import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from './eco.utils.ts';
+
+/**
+ * Creates a component factory with lazy-trigger support and deferred-boundary
+ * marker emission.
+ *
+ * Behavior:
+ * - In normal render flow, returns `options.render(props)` with optional lazy
+ *   trigger/script wrapping.
+ * - When rendering under component graph context and the active boundary policy
+ *   decides the target boundary should defer, emits an `eco-marker` token
+ *   instead of rendering the component immediately.
+ *
+ * @param options Component options for rendering and dependency declaration.
+ * @returns Configured eco component.
+ */
+function createComponentFactory<P, E>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
+	const integrationName = options.integration ?? options.__eco?.integration;
+	const comp: EcoComponent<P, E> = ((props: P) => {
+		const renderContext = getComponentRenderContext();
+		const shouldEmitMarker =
+			renderContext !== undefined &&
+			renderContext.boundaryContext.decideBoundaryRender({
+				currentIntegration: renderContext.currentIntegration,
+				targetIntegration: integrationName,
+				component: comp,
+			}) === 'defer';
+
+		if (shouldEmitMarker && renderContext) {
+			const nodeId = createNodeId(renderContext);
+			const propsRef = createPropsRef(renderContext);
+			const componentRef = comp.config?.__eco?.id ?? comp.config?.__eco?.file;
+
+			if (!componentRef) {
+				throw new Error(
+					'[ecopages] Missing component reference metadata for cross-integration marker emission.',
+				);
+			}
+
+			const componentProps = (props ?? {}) as Record<string, unknown>;
+			renderContext.propsByRef[propsRef] = componentProps;
+
+			let slotRef: string | undefined;
+			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);
+				}
+			}
+
+			return createComponentMarker({
+				nodeId,
+				integration: integrationName as string,
+				componentRef,
+				propsRef,
+				slotRef,
+			}) as E;
+		}
+
+		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);
+		}
+
+		const lazyGroups = comp.config?._resolvedLazyScripts;
+
+		if (lazyGroups && lazyGroups.length > 0) {
+			if (isThenable(content)) {
+				return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
+			}
+			return wrapWithScriptsInjector(content, lazyGroups);
+		}
+
+		return content;
+	}) as EcoComponent<P, E>;
+
+	comp.config = {
+		__eco: options.__eco,
+		integration: options.integration,
+		dependencies: options.dependencies,
+	};
+
+	return comp;
+}
+
+/**
+ * Creates a reusable component with optional dependencies.
+ *
+ * @param options Component definition options.
+ * @returns Eco component function.
+ */
+function component<P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
+	return createComponentFactory(options);
+}
+
+/**
+ * Creates a page component with typed props and optional static helpers.
+ */
+function page<T = {}, E = EcoPagesElement>(options: PageOptions<T, E> & { requires?: undefined }): EcoPageComponent<T>;
+function page<T = {}, E = EcoPagesElement, const K extends keyof RequestLocals = keyof RequestLocals>(
+	options: Omit<PageOptions<T, E>, 'render' | 'requires'> & {
+		requires: PageRequires<K>;
+		render: (props: PagePropsForWithLocals<T, K>) => E | Promise<E>;
+	},
+): EcoPageComponent<T>;
+
+/**
+ * Creates a page component and attaches optional static APIs.
+ *
+ * @param options Page options.
+ * @returns Eco page component.
+ */
+function page<T, E>(
+	options: PageOptionsBase<T, E> & { cache?: CacheStrategy; middleware?: Middleware[] },
+): EcoPageComponent<T> {
+	const { layout, dependencies, render, staticPaths, staticProps, metadata, cache, requires, middleware } = options;
+
+	const componentOptions: ComponentOptions<PagePropsFor<T> & Partial<RequestPageContext>, E> = {
+		__eco: options.__eco,
+		integration: options.integration,
+		dependencies: layout
+			? {
+					...dependencies,
+					components: [...(dependencies?.components || []), layout],
+				}
+			: dependencies,
+		render,
+	};
+
+	const pageComponent = createComponentFactory(componentOptions) as EcoPageComponent<T>;
+
+	if (layout && pageComponent.config) {
+		pageComponent.config.layout = layout;
+	}
+
+	if (staticPaths) pageComponent.staticPaths = staticPaths;
+	if (staticProps) pageComponent.staticProps = staticProps;
+	if (metadata) pageComponent.metadata = metadata;
+	if (cache) pageComponent.cache = cache;
+	if (requires) pageComponent.requires = requires;
+	if (middleware) pageComponent.middleware = middleware;
+
+	return pageComponent;
+}
+
+/**
+ * Type-safe wrapper for metadata functions.
+ *
+ * @param fn Metadata factory function.
+ * @returns The same function.
+ */
+function metadata<P = {}>(fn: GetMetadata<P>): GetMetadata<P> {
+	return fn;
+}
+
+/**
+ * Type-safe wrapper for static paths functions.
+ *
+ * @param fn Static paths function.
+ * @returns The same function.
+ */
+function staticPaths(fn: GetStaticPaths): GetStaticPaths {
+	return fn;
+}
+
+/**
+ * Type-safe wrapper for static props functions.
+ *
+ * @param fn Static props function.
+ * @returns The same function.
+ */
+function staticProps<P>(fn: GetStaticProps<P>): GetStaticProps<P> {
+	return fn;
+}
+
+/**
+ * The eco namespace - provides factories for components and pages
+ */
+export const eco: Eco = {
+	component,
+	page,
+	metadata,
+	staticPaths,
+	staticProps,
+};

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

@@ -0,0 +1,170 @@
+/**
+ * Type definitions for the eco namespace API
+ * @module
+ */
+import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoInjectedMeta, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, Middleware, RequestLocals, RequestPageContext } from '../public-types.js';
+import type { CacheStrategy } from '../services/cache/cache.types.js';
+type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
+    [P in K]-?: Exclude<RequestLocals[P], null | undefined>;
+};
+type RequiresKeys = keyof RequestLocals;
+export type PageRequires<K extends RequiresKeys = RequiresKeys> = K | readonly K[];
+/**
+ * Lazy trigger options map directly to scripts-injector attributes.
+ * Only one trigger type can be active at a time.
+ */
+export type LazyTrigger = DependencyLazyTrigger;
+/**
+ * Options for creating a component with eco.component()
+ * @template P - The props type for the component
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export interface ComponentOptions<P, E = EcoPagesElement> {
+    /** @internal Injected by eco-component-meta-plugin */
+    __eco?: EcoInjectedMeta;
+    integration?: string;
+    dependencies?: EcoComponentDependencies;
+    render: (props: P) => E | Promise<E>;
+}
+/**
+ * Base options shared by all page variants
+ */
+export interface PageOptionsBase<T, E = EcoPagesElement> {
+    /** @internal Injected by eco-component-meta-plugin */
+    __eco?: EcoInjectedMeta;
+    integration?: string;
+    dependencies?: EcoComponentDependencies;
+    layout?: EcoComponent<{
+        children: E;
+    } & Partial<RequestPageContext>>;
+    /**
+     * Define static paths for dynamic routes (e.g., [slug].tsx).
+     * Returns all possible paths that should be pre-rendered at build time.
+     */
+    staticPaths?: GetStaticPaths;
+    /**
+     * Fetch data for the page at build time.
+     * Props returned here are passed to both render() and metadata().
+     */
+    staticProps?: GetStaticProps<T>;
+    /**
+     * Generate page metadata (title, description, etc.).
+     * Receives props from staticProps if defined.
+     */
+    metadata?: GetMetadata<T>;
+    /**
+     * Declares which `locals` keys must be present for this page.
+     *
+     * This is a typing and documentation feature; runtime enforcement must be done via handler/page middleware.
+     */
+    requires?: PageRequires;
+    render: (props: PagePropsFor<T> & Partial<RequestPageContext>) => E | Promise<E>;
+}
+/**
+ * Page options without middleware - allows any cache strategy
+ */
+interface PageOptionsWithoutMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+    /**
+     * Cache configuration for ISR (Incremental Static Regeneration).
+     * - `'static'`: Cache indefinitely (default)
+     * - `'dynamic'`: No caching, render on every request
+     * - `{ revalidate: number, tags?: string[] }`: Cache with time-based revalidation
+     */
+    cache?: CacheStrategy;
+    middleware?: undefined;
+}
+/**
+ * Page options with middleware - requires cache: 'dynamic'
+ */
+interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+    /**
+     * Cache must be 'dynamic' when using middleware.
+     * Middleware runs on every request, so caching would bypass middleware effects.
+     */
+    cache: 'dynamic';
+    /**
+     * Request-time middleware for file-based routes.
+     * Runs before rendering and can short-circuit by returning a Response.
+     */
+    middleware: Middleware[];
+}
+/**
+ * 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
+ * runs on every request and caching would bypass middleware effects.
+ *
+ * @template T - The props type for the page
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export type PageOptions<T, E = EcoPagesElement> = PageOptionsWithoutMiddleware<T, E> | PageOptionsWithMiddleware<T, E>;
+export type PagePropsForWithLocals<T, K extends RequiresKeys | never = never> = PagePropsFor<T> & (K extends never ? Partial<RequestPageContext> : Omit<Partial<RequestPageContext>, 'locals'> & {
+    locals: WithRequiredLocals<Extract<K, keyof RequestLocals>>;
+});
+/**
+ * Extracts props type from getStaticProps return type, or uses T directly if it's a props object.
+ * Always includes params and query for page context.
+ */
+export type PagePropsFor<T> = T extends GetStaticProps<infer P> ? P & {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+} : T & {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+};
+/**
+ * A page component with optional attached static functions.
+ * Used by the consolidated eco.page() API where staticPaths, staticProps,
+ * and metadata are defined inline and attached to the component.
+ */
+export type EcoPageComponent<T> = EcoComponent<PagePropsFor<T> & Partial<RequestPageContext>> & {
+    staticPaths?: GetStaticPaths;
+    staticProps?: GetStaticProps<T>;
+    metadata?: GetMetadata<T>;
+    cache?: CacheStrategy;
+    requires?: PageRequires;
+    middleware?: Middleware[];
+};
+/**
+ * The eco namespace interface
+ */
+export interface Eco {
+    /**
+     * Create a reusable component with dependencies and optional lazy-loading.
+     * @template P - Props type
+     * @template E - Element/return type (EcoPagesElement for Kita, ReactNode for React)
+     */
+    component: <P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>) => EcoComponent<P, E>;
+    /**
+     * Create a page component with type-safe props from getStaticProps.
+     * Returns an EcoPageComponent with attached staticPaths, staticProps, and metadata.
+     *
+     * If `requires` is provided, the `render` callback receives `locals` as required and non-null for the required keys.
+     */
+    page: {
+        <T = {}, E = EcoPagesElement>(options: PageOptions<T, E> & {
+            requires?: undefined;
+        }): EcoPageComponent<T>;
+        <T = {}, E = EcoPagesElement, const K extends RequiresKeys = RequiresKeys>(options: Omit<PageOptions<T, E>, 'render' | 'requires'> & {
+            requires: PageRequires<K>;
+            render: (props: PagePropsForWithLocals<T, K>) => E | Promise<E>;
+        }): EcoPageComponent<T>;
+    };
+    /**
+     * Type-safe wrapper for page metadata (identity function)
+     */
+    metadata: <P = {}>(fn: GetMetadata<P>) => GetMetadata<P>;
+    /**
+     * Type-safe wrapper for static paths (identity function)
+     */
+    staticPaths: (fn: GetStaticPaths) => GetStaticPaths;
+    /**
+     * Type-safe wrapper for static props (identity function)
+     */
+    staticProps: <P>(fn: GetStaticProps<P>) => GetStaticProps<P>;
+}
+export {};

package/src/eco/eco.types.ts

@@ -0,0 +1,202 @@
+/**
+ * Type definitions for the eco namespace API
+ * @module
+ */
+
+import type {
+	DependencyLazyTrigger,
+	EcoComponent,
+	EcoComponentDependencies,
+	EcoInjectedMeta,
+	EcoPagesElement,
+	GetMetadata,
+	GetStaticPaths,
+	GetStaticProps,
+	Middleware,
+	RequestLocals,
+	RequestPageContext,
+} from '../public-types.ts';
+import type { CacheStrategy } from '../services/cache/cache.types.ts';
+
+type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
+	[P in K]-?: Exclude<RequestLocals[P], null | undefined>;
+};
+
+type RequiresKeys = keyof RequestLocals;
+
+export type PageRequires<K extends RequiresKeys = RequiresKeys> = K | readonly K[];
+
+/**
+ * Lazy trigger options map directly to scripts-injector attributes.
+ * Only one trigger type can be active at a time.
+ */
+export type LazyTrigger = DependencyLazyTrigger;
+
+/**
+ * Options for creating a component with eco.component()
+ * @template P - The props type for the component
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export interface ComponentOptions<P, E = EcoPagesElement> {
+	/** @internal Injected by eco-component-meta-plugin */
+	__eco?: EcoInjectedMeta;
+	integration?: string;
+	dependencies?: EcoComponentDependencies;
+	render: (props: P) => E | Promise<E>;
+}
+
+/**
+ * Base options shared by all page variants
+ */
+export interface PageOptionsBase<T, E = EcoPagesElement> {
+	/** @internal Injected by eco-component-meta-plugin */
+	__eco?: EcoInjectedMeta;
+	integration?: string;
+	dependencies?: EcoComponentDependencies;
+	layout?: EcoComponent<{ children: E } & Partial<RequestPageContext>>;
+
+	/**
+	 * Define static paths for dynamic routes (e.g., [slug].tsx).
+	 * Returns all possible paths that should be pre-rendered at build time.
+	 */
+	staticPaths?: GetStaticPaths;
+
+	/**
+	 * Fetch data for the page at build time.
+	 * Props returned here are passed to both render() and metadata().
+	 */
+	staticProps?: GetStaticProps<T>;
+
+	/**
+	 * Generate page metadata (title, description, etc.).
+	 * Receives props from staticProps if defined.
+	 */
+	metadata?: GetMetadata<T>;
+
+	/**
+	 * Declares which `locals` keys must be present for this page.
+	 *
+	 * This is a typing and documentation feature; runtime enforcement must be done via handler/page middleware.
+	 */
+	requires?: PageRequires;
+
+	render: (props: PagePropsFor<T> & Partial<RequestPageContext>) => E | Promise<E>;
+}
+
+/**
+ * Page options without middleware - allows any cache strategy
+ */
+interface PageOptionsWithoutMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+	/**
+	 * Cache configuration for ISR (Incremental Static Regeneration).
+	 * - `'static'`: Cache indefinitely (default)
+	 * - `'dynamic'`: No caching, render on every request
+	 * - `{ revalidate: number, tags?: string[] }`: Cache with time-based revalidation
+	 */
+	cache?: CacheStrategy;
+	middleware?: undefined;
+}
+
+/**
+ * Page options with middleware - requires cache: 'dynamic'
+ */
+interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+	/**
+	 * Cache must be 'dynamic' when using middleware.
+	 * Middleware runs on every request, so caching would bypass middleware effects.
+	 */
+	cache: 'dynamic';
+	/**
+	 * Request-time middleware for file-based routes.
+	 * Runs before rendering and can short-circuit by returning a Response.
+	 */
+	middleware: Middleware[];
+}
+
+/**
+ * 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
+ * runs on every request and caching would bypass middleware effects.
+ *
+ * @template T - The props type for the page
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export type PageOptions<T, E = EcoPagesElement> = PageOptionsWithoutMiddleware<T, E> | PageOptionsWithMiddleware<T, E>;
+
+export type PagePropsForWithLocals<T, K extends RequiresKeys | never = never> = PagePropsFor<T> &
+	(K extends never
+		? Partial<RequestPageContext>
+		: Omit<Partial<RequestPageContext>, 'locals'> & {
+				locals: WithRequiredLocals<Extract<K, keyof RequestLocals>>;
+			});
+
+/**
+ * Extracts props type from getStaticProps return type, or uses T directly if it's a props object.
+ * Always includes params and query for page context.
+ */
+export type PagePropsFor<T> =
+	T extends GetStaticProps<infer P>
+		? P & { params?: Record<string, string>; query?: Record<string, string> }
+		: T & { params?: Record<string, string>; query?: Record<string, string> };
+
+/**
+ * A page component with optional attached static functions.
+ * Used by the consolidated eco.page() API where staticPaths, staticProps,
+ * and metadata are defined inline and attached to the component.
+ */
+export type EcoPageComponent<T> = EcoComponent<PagePropsFor<T> & Partial<RequestPageContext>> & {
+	staticPaths?: GetStaticPaths;
+	staticProps?: GetStaticProps<T>;
+	metadata?: GetMetadata<T>;
+	cache?: CacheStrategy;
+	requires?: PageRequires;
+	middleware?: Middleware[];
+};
+
+/**
+ * The eco namespace interface
+ */
+export interface Eco {
+	/**
+	 * Create a reusable component with dependencies and optional lazy-loading.
+	 * @template P - Props type
+	 * @template E - Element/return type (EcoPagesElement for Kita, ReactNode for React)
+	 */
+	component: <P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>) => EcoComponent<P, E>;
+
+	/**
+	 * Create a page component with type-safe props from getStaticProps.
+	 * Returns an EcoPageComponent with attached staticPaths, staticProps, and metadata.
+	 *
+	 * If `requires` is provided, the `render` callback receives `locals` as required and non-null for the required keys.
+	 */
+	page: {
+		<T = {}, E = EcoPagesElement>(options: PageOptions<T, E> & { requires?: undefined }): EcoPageComponent<T>;
+		<T = {}, E = EcoPagesElement, const K extends RequiresKeys = RequiresKeys>(
+			options: Omit<PageOptions<T, E>, 'render' | 'requires'> & {
+				requires: PageRequires<K>;
+				render: (props: PagePropsForWithLocals<T, K>) => E | Promise<E>;
+			},
+		): EcoPageComponent<T>;
+	};
+
+	/**
+	 * Type-safe wrapper for page metadata (identity function)
+	 */
+	metadata: <P = {}>(fn: GetMetadata<P>) => GetMetadata<P>;
+
+	/**
+	 * Type-safe wrapper for static paths (identity function)
+	 */
+	staticPaths: (fn: GetStaticPaths) => GetStaticPaths;
+
+	/**
+	 * Type-safe wrapper for static props (identity function)
+	 */
+	staticProps: <P>(fn: GetStaticProps<P>) => GetStaticProps<P>;
+}

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

@@ -0,0 +1,40 @@
+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;

package/src/eco/eco.utils.js

@@ -0,0 +1,40 @@
+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>`;
+}
+export {
+  addTriggerAttribute,
+  isThenable,
+  wrapWithScriptsInjector
+};