@ecopages/core 0.2.0-alpha.24 → 0.2.0-alpha.26

package/src/eco/eco.ts

@@ -1,205 +0,0 @@
-/**
- * The eco namespace - unified component and page factory API
- * @module
- */
-
-import type {
-	EcoComponent,
-	EcoHtmlComponent,
-	EcoLayoutComponent,
-	EcoPagesElement,
-	EcoPageComponent,
-	GetMetadata,
-	GetStaticPaths,
-	GetStaticProps,
-	Middleware,
-	RequestLocals,
-	RequestPageContext,
-} from '../types/public-types.ts';
-import type { CacheStrategy } from '../services/cache/cache.types.ts';
-import type {
-	ComponentOptions,
-	Eco,
-	HtmlOptions,
-	LayoutOptions,
-	PageOptions,
-	PageOptionsBase,
-	PagePropsFor,
-	PagePropsForWithLocals,
-	PageRequires,
-} from './eco.types.ts';
-import {
-	finalizeComponentRender,
-	interceptComponentBoundary,
-} from '../route-renderer/orchestration/component-render-context.ts';
-import { isThenable } from '../route-renderer/orchestration/render-output.utils.ts';
-
-/**
- * Creates a component factory with lazy-trigger support and boundary-runtime
- * interception.
- *
- * Behavior:
- * - In normal render flow, returns `options.render(props)` with optional lazy
- *   trigger/script wrapping.
- * - When rendering under an active component boundary runtime and the current
- *   renderer-owned boundary runtime resolves the boundary immediately, returns
- *   that resolved output instead of rendering the component inline.
- *
- * @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 componentProps = (props ?? {}) as Record<string, unknown>;
-		const renderInline = () => finalizeComponentRender(comp, options.render(props)) as E;
-		const boundaryRender = interceptComponentBoundary({
-			component: comp,
-			props: componentProps,
-			targetIntegration: integrationName,
-		});
-
-		if (isThenable<unknown | undefined>(boundaryRender)) {
-			return boundaryRender.then((resolvedBoundaryRender) =>
-				resolvedBoundaryRender !== undefined ? (resolvedBoundaryRender as E) : renderInline(),
-			) as E;
-		}
-
-		if (boundaryRender !== undefined) {
-			return boundaryRender as E;
-		}
-
-		return renderInline();
-	}) 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 document shell component.
- *
- * Phase 1 keeps this as a semantic alias over eco.component() so existing
- * renderer behavior remains unchanged.
- */
-function html<E = EcoPagesElement>(options: HtmlOptions<E>): EcoHtmlComponent<E> {
-	return createComponentFactory(options) as EcoHtmlComponent<E>;
-}
-
-/**
- * Creates a route layout component.
- *
- * Phase 1 keeps this as a semantic alias over eco.component() so existing
- * renderer behavior remains unchanged.
- */
-function layout<E = EcoPagesElement>(options: LayoutOptions<E>): EcoLayoutComponent<E> {
-	return createComponentFactory(options) as EcoLayoutComponent<E>;
-}
-
-/**
- * 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,
-	html,
-	layout,
-	page,
-	metadata,
-	staticPaths,
-	staticProps,
-};

package/src/eco/eco.types.ts

@@ -1,221 +0,0 @@
-/**
- * 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 '../types/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>;
-}
-
-export type HtmlOptions<E = EcoPagesElement> = ComponentOptions<HtmlTemplateProps, E>;
-
-export type LayoutOptions<E = EcoPagesElement> = ComponentOptions<LayoutProps<E>, 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?: EcoPageLayoutComponent<E>;
-
-	/**
-	 * 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 document shell component for the HTML wrapper.
-	 */
-	html: <E = EcoPagesElement>(options: HtmlOptions<E>) => EcoHtmlComponent<E>;
-
-	/**
-	 * Create a route layout component.
-	 */
-	layout: <E = EcoPagesElement>(options: LayoutOptions<E>) => EcoLayoutComponent<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.test.ts

@@ -1,219 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from './eco.utils.ts';
-
-const TRIGGER_ID = 'eco-trigger-abc123';
-
-describe('addTriggerAttribute', () => {
-	describe('basic element injection', () => {
-		test('injects into a plain div', () => {
-			const result = addTriggerAttribute('<div>content</div>', TRIGGER_ID);
-			expect(result).toBe(`<div data-eco-trigger="${TRIGGER_ID}">content</div>`);
-		});
-
-		test('injects into a custom element', () => {
-			const result = addTriggerAttribute('<my-counter value="0"></my-counter>', TRIGGER_ID);
-			expect(result).toBe(`<my-counter data-eco-trigger="${TRIGGER_ID}" value="0"></my-counter>`);
-		});
-
-		test('injects into an element that already has attributes', () => {
-			const result = addTriggerAttribute('<div class="foo" id="bar">content</div>', TRIGGER_ID);
-			expect(result).toBe(`<div data-eco-trigger="${TRIGGER_ID}" class="foo" id="bar">content</div>`);
-		});
-
-		test('injects into a self-closing void element', () => {
-			const result = addTriggerAttribute('<img src="x.png" alt="" />', TRIGGER_ID);
-			expect(result).toBe(`<img data-eco-trigger="${TRIGGER_ID}" src="x.png" alt="" />`);
-		});
-
-		test('injects into an element with no attributes and immediate close', () => {
-			const result = addTriggerAttribute('<section></section>', TRIGGER_ID);
-			expect(result).toBe(`<section data-eco-trigger="${TRIGGER_ID}"></section>`);
-		});
-	});
-
-	describe('leading non-element nodes are skipped', () => {
-		test('skips leading whitespace and injects into the first element', () => {
-			const result = addTriggerAttribute('   \n  <div>content</div>', TRIGGER_ID);
-			expect(result).toBe(`   \n  <div data-eco-trigger="${TRIGGER_ID}">content</div>`);
-		});
-
-		test('skips a leading HTML comment', () => {
-			const result = addTriggerAttribute('<!-- wrapper --><div>content</div>', TRIGGER_ID);
-			expect(result).toBe(`<!-- wrapper --><div data-eco-trigger="${TRIGGER_ID}">content</div>`);
-		});
-
-		test('skips multiple leading HTML comments', () => {
-			const result = addTriggerAttribute('<!-- a --><!-- b --><span>text</span>', TRIGGER_ID);
-			expect(result).toBe(`<!-- a --><!-- b --><span data-eco-trigger="${TRIGGER_ID}">text</span>`);
-		});
-
-		test('skips a leading doctype declaration', () => {
-			const result = addTriggerAttribute('<!DOCTYPE html><html lang="en"></html>', TRIGGER_ID);
-			expect(result).toBe(`<!DOCTYPE html><html data-eco-trigger="${TRIGGER_ID}" lang="en"></html>`);
-		});
-
-		test('skips a leading XML processing instruction', () => {
-			const result = addTriggerAttribute('<?xml version="1.0"?><root/>', TRIGGER_ID);
-			expect(result).toBe(`<?xml version="1.0"?><root data-eco-trigger="${TRIGGER_ID}"/>`);
-		});
-
-		test('skips comment then whitespace then element', () => {
-			const result = addTriggerAttribute('<!-- note -->\n<article>body</article>', TRIGGER_ID);
-			expect(result).toBe(`<!-- note -->\n<article data-eco-trigger="${TRIGGER_ID}">body</article>`);
-		});
-	});
-
-	describe('only the first element is modified', () => {
-		test('does not inject into sibling elements', () => {
-			const result = addTriggerAttribute('<div>first</div><div>second</div>', TRIGGER_ID);
-			expect(result).toBe(`<div data-eco-trigger="${TRIGGER_ID}">first</div><div>second</div>`);
-		});
-	});
-
-	describe('fallback when no element is found', () => {
-		test('preserves JSX template metadata while injecting into the first string', () => {
-			const strings = ['<theme-toggle class=', '></theme-toggle>'];
-			Object.defineProperty(strings, 'raw', {
-				value: ['<theme-toggle class=', '></theme-toggle>'],
-			});
-
-			const template = {
-				_$rType$: 1,
-				rootLocalName: 'theme-toggle',
-				strings,
-				values: ['radiant-switch'],
-			};
-
-			const result = addTriggerAttribute(template, TRIGGER_ID) as unknown as {
-				_$rType$: number;
-				rootLocalName: string;
-				strings: string[];
-				values: unknown[];
-			};
-
-			expect(result._$rType$).toBe(1);
-			expect(result.rootLocalName).toBe('theme-toggle');
-			expect(result.values).toEqual(['radiant-switch']);
-			expect(result.strings).toEqual([
-				`<theme-toggle data-eco-trigger="${TRIGGER_ID}" class=`,
-				'></theme-toggle>',
-			]);
-			expect(Object.getOwnPropertyDescriptor(result.strings, 'raw')?.value).toEqual([
-				`<theme-toggle data-eco-trigger="${TRIGGER_ID}" class=`,
-				'></theme-toggle>',
-			]);
-		});
-
-		test('preserves SSR markup node output while injecting into outerHTML', () => {
-			const markupNode = {
-				nodeType: 1,
-				get outerHTML() {
-					return '<theme-toggle class="radiant-switch"></theme-toggle>';
-				},
-			};
-
-			const result = addTriggerAttribute(markupNode, TRIGGER_ID) as typeof markupNode;
-
-			expect(result.nodeType).toBe(1);
-			expect(result.outerHTML).toBe(
-				`<theme-toggle data-eco-trigger="${TRIGGER_ID}" class="radiant-switch"></theme-toggle>`,
-			);
-		});
-
-		test('returns the original string unchanged when there is no opening tag', () => {
-			const input = 'just some text';
-			expect(addTriggerAttribute(input, TRIGGER_ID)).toBe(input);
-		});
-
-		test('returns the original string unchanged when input is empty', () => {
-			expect(addTriggerAttribute('', TRIGGER_ID)).toBe('');
-		});
-	});
-
-	describe('non-string input coercion', () => {
-		test('coerces a number to string before injecting', () => {
-			const result = addTriggerAttribute(42, TRIGGER_ID);
-			expect(result).toBe('42');
-		});
-
-		test('coerces null to the string "null"', () => {
-			expect(addTriggerAttribute(null, TRIGGER_ID)).toBe('null');
-		});
-	});
-});
-
-describe('isThenable', () => {
-	test('returns true for a native Promise', () => {
-		expect(isThenable(Promise.resolve())).toBe(true);
-	});
-
-	test('returns true for a plain object with a then function', () => {
-		expect(isThenable({ then: () => {} })).toBe(true);
-	});
-
-	test('returns false for a plain string', () => {
-		expect(isThenable('hello')).toBe(false);
-	});
-
-	test('returns false for a number', () => {
-		expect(isThenable(42)).toBe(false);
-	});
-
-	test('returns false for null', () => {
-		expect(isThenable(null)).toBe(false);
-	});
-
-	test('returns false for an object without then', () => {
-		expect(isThenable({ value: 1 })).toBe(false);
-	});
-
-	test('returns false when then is not a function', () => {
-		expect(isThenable({ then: 'not-a-function' })).toBe(false);
-	});
-});
-
-describe('wrapWithScriptsInjector', () => {
-	const lazyGroups = [{ lazy: { 'on:idle': true }, scripts: '/_assets/script.js' }] as const;
-
-	test('preserves JSX template metadata while wrapping content', () => {
-		const strings = ['<theme-toggle class=', '></theme-toggle>'];
-		Object.defineProperty(strings, 'raw', {
-			value: ['<theme-toggle class=', '></theme-toggle>'],
-		});
-
-		const template = {
-			_$rType$: 1,
-			rootLocalName: 'theme-toggle',
-			strings,
-			values: ['radiant-switch'],
-		};
-
-		const result = wrapWithScriptsInjector(template, lazyGroups) as unknown as typeof template;
-
-		expect(result._$rType$).toBe(1);
-		expect(result.rootLocalName).toBe('theme-toggle');
-		expect(result.values).toEqual(['radiant-switch']);
-		expect(result.strings[0]).toContain('<scripts-injector><script type="ecopages/injector-map">');
-		expect(result.strings[0]).toContain('<theme-toggle class=');
-		expect(result.strings[1]).toBe('></theme-toggle></scripts-injector>');
-		expect(Object.getOwnPropertyDescriptor(result.strings, 'raw')?.value[1]).toBe(
-			'></theme-toggle></scripts-injector>',
-		);
-	});
-
-	test('preserves markup-node-like output while wrapping content', () => {
-		const markupNode = {
-			nodeType: 1,
-			get outerHTML() {
-				return '<theme-toggle class="radiant-switch"></theme-toggle>';
-			},
-		};
-
-		const result = wrapWithScriptsInjector(markupNode, lazyGroups) as typeof markupNode;
-
-		expect(result.nodeType).toBe(1);
-		expect(result.outerHTML).toContain('<scripts-injector><script type="ecopages/injector-map">');
-		expect(result.outerHTML).toContain('<theme-toggle class="radiant-switch"></theme-toggle>');
-		expect(result.outerHTML).toContain('</scripts-injector>');
-	});
-});

package/src/eco/eco.utils.ts

@@ -1,5 +0,0 @@
-export {
-	addTriggerAttribute,
-	isThenable,
-	wrapWithScriptsInjector,
-} from '../route-renderer/orchestration/render-output.utils.ts';

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

@@ -1,42 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from './global-injector-map.ts';
-import type { ResolvedLazyTrigger } from '../types/public-types.ts';
-
-describe('buildGlobalInjectorMapScript', () => {
-	test('builds merged map by trigger id and escapes script closing tags', () => {
-		const triggers: ResolvedLazyTrigger[] = [
-			{
-				triggerId: 'eco-trigger-one',
-				rules: [
-					{ 'on:interaction': { value: 'click', scripts: ['/a.js', '/b</script>.js'] } },
-					{ 'on:idle': { scripts: ['/idle.js'] } },
-				],
-			},
-			{
-				triggerId: 'eco-trigger-one',
-				rules: [{ 'on:interaction': { value: 'click', scripts: ['/a.js', '/c.js'] } }],
-			},
-		];
-
-		const payload = buildGlobalInjectorMapScript(triggers);
-		expect(payload).toContain('<\\/script>');
-
-		const map = JSON.parse(payload) as Record<string, Record<string, { scripts: string[]; value?: string }>>;
-		expect(map['eco-trigger-one']?.['on:idle']?.scripts).toEqual(['/idle.js']);
-		expect(map['eco-trigger-one']?.['on:interaction']).toEqual({
-			value: 'click',
-			scripts: ['/a.js', '/b</script>.js', '/c.js'],
-		});
-	});
-});
-
-describe('buildGlobalInjectorBootstrapContent', () => {
-	test('binds refresh to after-swap and avoids before-swap cleanup listener', () => {
-		const bootstrap = buildGlobalInjectorBootstrapContent('/assets/injector-global.js');
-
-		expect(bootstrap).toContain("document.addEventListener('eco:after-swap', handleAfterSwap);");
-		expect(bootstrap).not.toContain("document.addEventListener('eco:before-swap'");
-		expect(bootstrap).not.toContain('const handleBeforeSwap');
-		expect(bootstrap).toContain("document.removeEventListener('eco:after-swap', handleAfterSwap);");
-	});
-});