@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

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

@@ -0,0 +1,178 @@
+/**
+ * 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 { 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>;
+}
+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>;
+}
+export {};

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
+};

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

@@ -0,0 +1,16 @@
+import type { ResolvedLazyTrigger } from '../public-types.js';
+/**
+ * Serializes resolved lazy triggers into a JSON string safe for embedding
+ * inside an inline `<script type="ecopages/global-injector-map">` tag.
+ *
+ * The `</script` sequence is escaped because an unescaped occurrence in inline
+ * script content causes the HTML parser to close the script tag prematurely,
+ * breaking page rendering. `JSON.stringify` does not perform this escape by
+ * default, so a targeted replacement is applied after serialization.
+ */
+export declare function buildGlobalInjectorMapScript(triggers: ResolvedLazyTrigger[]): string;
+/**
+ * Builds the inline module script 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;

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

@@ -0,0 +1,80 @@
+function buildGlobalInjectorMap(triggers) {
+  const map = {};
+  for (const { triggerId, rules } of triggers) {
+    const entry = map[triggerId] ?? {};
+    for (const rule of rules) {
+      if ("on:idle" in rule) {
+        const { scripts } = rule["on:idle"];
+        entry["on:idle"] = {
+          scripts: Array.from(/* @__PURE__ */ new Set([...entry["on:idle"]?.scripts ?? [], ...scripts]))
+        };
+        continue;
+      }
+      if ("on:interaction" in rule) {
+        const { value, scripts } = rule["on:interaction"];
+        entry["on:interaction"] = {
+          value,
+          scripts: Array.from(/* @__PURE__ */ new Set([...entry["on:interaction"]?.scripts ?? [], ...scripts]))
+        };
+        continue;
+      }
+      if ("on:visible" in rule) {
+        const { value, scripts } = rule["on:visible"];
+        entry["on:visible"] = {
+          ...value ? { value } : {},
+          scripts: Array.from(/* @__PURE__ */ new Set([...entry["on:visible"]?.scripts ?? [], ...scripts]))
+        };
+        continue;
+      }
+    }
+    if (Object.keys(entry).length > 0) {
+      map[triggerId] = entry;
+    }
+  }
+  return map;
+}
+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 pruneStaleTriggerMaps() {
+	const mapScripts = Array.from(document.querySelectorAll('script[type="ecopages/global-injector-map"]'));
+	if (mapScripts.length <= 1) {
+		return;
+	}
+
+	const latestMapScript = mapScripts[mapScripts.length - 1];
+	for (const mapScript of mapScripts) {
+		if (mapScript !== latestMapScript) {
+			mapScript.remove();
+		}
+	}
+}
+
+const globalScope = window;
+if (typeof globalScope.__ecoGlobalInjectorCleanup === 'function') {
+	globalScope.__ecoGlobalInjectorCleanup();
+}
+
+const injector = initGlobalInjector();
+
+const handleAfterSwap = () => {
+	pruneStaleTriggerMaps();
+	injector.refresh();
+};
+
+document.addEventListener('eco:after-swap', handleAfterSwap);
+pruneStaleTriggerMaps();
+
+globalScope.__ecoGlobalInjectorCleanup = () => {
+	document.removeEventListener('eco:after-swap', handleAfterSwap);
+	injector.cleanup();
+};`;
+}
+export {
+  buildGlobalInjectorBootstrapContent,
+  buildGlobalInjectorMapScript
+};

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

@@ -0,0 +1,8 @@
+import type { ResolvedLazyScriptGroup } from '../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;

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

@@ -0,0 +1,70 @@
+function normalizeScripts(scripts) {
+  return scripts.split(",").map((scriptPath) => scriptPath.trim()).filter(Boolean).map((scriptPath) => {
+    if (scriptPath.startsWith("/")) {
+      return scriptPath;
+    }
+    const normalizedRelativePath = scriptPath.replace(/^\/+/, "").replace(/^(\.\/)+/, "");
+    return `/${normalizedRelativePath}`;
+  });
+}
+function dedupeCsvValues(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    for (const token of value.split(",").map((part) => part.trim()).filter(Boolean)) {
+      seen.add(token);
+    }
+  }
+  return Array.from(seen).join(",");
+}
+function buildInjectorMap(lazyGroups) {
+  const map = {};
+  for (const group of lazyGroups) {
+    const scripts = normalizeScripts(group.scripts);
+    const lazy = group.lazy;
+    if ("on:idle" in lazy) {
+      map["on:idle"] = {
+        scripts: [...map["on:idle"]?.scripts ?? [], ...scripts]
+      };
+      continue;
+    }
+    if ("on:interaction" in lazy) {
+      const currentValue = map["on:interaction"]?.value;
+      const nextValue = lazy["on:interaction"];
+      map["on:interaction"] = {
+        value: typeof currentValue === "string" ? dedupeCsvValues([currentValue, nextValue]) : nextValue,
+        scripts: [...map["on:interaction"]?.scripts ?? [], ...scripts]
+      };
+      continue;
+    }
+    if ("on:visible" in lazy) {
+      const currentValue = map["on:visible"]?.value;
+      const currentThreshold = typeof currentValue === "string" ? currentValue : void 0;
+      const nextValue = lazy["on:visible"];
+      map["on:visible"] = {
+        ...nextValue === true ? currentThreshold ? { value: currentThreshold } : {} : { value: String(nextValue) },
+        scripts: [...map["on:visible"]?.scripts ?? [], ...scripts]
+      };
+      continue;
+    }
+    throw new Error(
+      `Invalid lazy options: must specify on:idle, on:interaction, or on:visible. Received: ${JSON.stringify(lazy)}`
+    );
+  }
+  for (const key of Object.keys(map)) {
+    const scripts = map[key]?.scripts;
+    if (scripts) {
+      map[key] = {
+        ...map[key],
+        scripts: Array.from(new Set(scripts))
+      };
+    }
+  }
+  return map;
+}
+function buildInjectorMapScript(lazyGroups) {
+  const map = buildInjectorMap(lazyGroups);
+  return JSON.stringify(map).replace(/<\/script/gi, "<\\/script");
+}
+export {
+  buildInjectorMapScript
+};

package/src/eco/module-dependencies.d.ts

@@ -0,0 +1,18 @@
+export type ModuleDependencyDeclaration = {
+    from: string;
+    imports?: string[];
+};
+/**
+ * Parses a module grammar declaration into normalized object form.
+ *
+ * Supported input examples:
+ * - `react-aria-components`
+ * - `react-aria-components{Table,Select}`
+ */
+export declare function parseModuleDeclaration(value: string): ModuleDependencyDeclaration;
+/**
+ * Normalizes and deduplicates module declarations from `modules`.
+ *
+ * Returns canonical object declarations suitable for downstream bundling logic.
+ */
+export declare function normalizeModuleDeclarations(modules?: string[]): ModuleDependencyDeclaration[];

package/src/eco/module-dependencies.js

@@ -0,0 +1,49 @@
+function normalizeImports(imports) {
+  if (!imports || imports.length === 0) {
+    return void 0;
+  }
+  const normalized = Array.from(new Set(imports.map((entry) => entry.trim()).filter((entry) => entry.length > 0)));
+  return normalized.length > 0 ? normalized : void 0;
+}
+function parseModuleDeclaration(value) {
+  const source = value.trim();
+  if (source.length === 0) {
+    throw new Error("Module declaration cannot be empty");
+  }
+  const openBraceIndex = source.indexOf("{");
+  if (openBraceIndex < 0) {
+    return { from: source };
+  }
+  const closeBraceIndex = source.lastIndexOf("}");
+  if (closeBraceIndex !== source.length - 1 || closeBraceIndex <= openBraceIndex) {
+    throw new Error(`Invalid module declaration '${value}'`);
+  }
+  const from = source.slice(0, openBraceIndex).trim();
+  if (from.length === 0) {
+    throw new Error(`Invalid module declaration '${value}'`);
+  }
+  const importsSlice = source.slice(openBraceIndex + 1, closeBraceIndex);
+  const imports = normalizeImports(importsSlice.split(","));
+  return {
+    from,
+    imports
+  };
+}
+function normalizeModuleDeclarations(modules) {
+  const declarations = modules ?? [];
+  const output = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const declaration of declarations) {
+    const normalized = parseModuleDeclaration(declaration);
+    const key = `${normalized.from}::${(normalized.imports ?? []).join(",")}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      output.push(normalized);
+    }
+  }
+  return output;
+}
+export {
+  normalizeModuleDeclarations,
+  parseModuleDeclaration
+};

package/src/errors/http-error.d.ts

@@ -0,0 +1,31 @@
+export interface HttpErrorDetails {
+    [key: string]: unknown;
+}
+export interface HttpErrorJson {
+    error: string;
+    status: number;
+    details?: HttpErrorDetails;
+}
+/**
+ * HTTP error class for structured error handling in route handlers.
+ * Provides static factory methods for common HTTP error responses.
+ */
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly details?: HttpErrorDetails;
+    constructor(status: number, message: string, details?: HttpErrorDetails);
+    /**
+     * Serialize error to JSON for API responses.
+     */
+    toJSON(): HttpErrorJson;
+    /**
+     * Create a Response object from this error.
+     */
+    toResponse(): Response;
+    static BadRequest(message?: string, details?: HttpErrorDetails): HttpError;
+    static Unauthorized(message?: string): HttpError;
+    static Forbidden(message?: string): HttpError;
+    static NotFound(message?: string): HttpError;
+    static Conflict(message?: string, details?: HttpErrorDetails): HttpError;
+    static InternalServerError(message?: string): HttpError;
+}

package/src/errors/http-error.js

@@ -0,0 +1,50 @@
+class HttpError extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+    this.details = details;
+  }
+  /**
+   * Serialize error to JSON for API responses.
+   */
+  toJSON() {
+    const json = {
+      error: this.message,
+      status: this.status
+    };
+    if (this.details) {
+      json.details = this.details;
+    }
+    return json;
+  }
+  /**
+   * Create a Response object from this error.
+   */
+  toResponse() {
+    return Response.json(this.toJSON(), { status: this.status });
+  }
+  static BadRequest(message = "Bad Request", details) {
+    return new HttpError(400, message, details);
+  }
+  static Unauthorized(message = "Unauthorized") {
+    return new HttpError(401, message);
+  }
+  static Forbidden(message = "Forbidden") {
+    return new HttpError(403, message);
+  }
+  static NotFound(message = "Not Found") {
+    return new HttpError(404, message);
+  }
+  static Conflict(message = "Conflict", details) {
+    return new HttpError(409, message, details);
+  }
+  static InternalServerError(message = "Internal Server Error") {
+    return new HttpError(500, message);
+  }
+}
+export {
+  HttpError
+};

package/src/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { HttpError } from './http-error.js';
+export type { HttpErrorDetails, HttpErrorJson } from './http-error.js';

package/src/errors/index.js

@@ -0,0 +1,4 @@
+import { HttpError } from "./http-error.js";
+export {
+  HttpError
+};

package/src/errors/locals-access-error.d.ts

@@ -0,0 +1,4 @@
+export declare class LocalsAccessError extends Error {
+    name: string;
+    constructor(message: string);
+}

package/src/errors/locals-access-error.js

@@ -0,0 +1,9 @@
+class LocalsAccessError extends Error {
+  name = "LocalsAccessError";
+  constructor(message) {
+    super(message);
+  }
+}
+export {
+  LocalsAccessError
+};

package/src/global/app-logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@ecopages/logger';
+export declare const appLogger: Logger;

package/src/global/app-logger.js

@@ -0,0 +1,6 @@
+import { Logger } from "@ecopages/logger";
+const debug = process.env.ECOPAGES_LOGGER_DEBUG === "true";
+const appLogger = new Logger("[@ecopages/core]", { debug });
+export {
+  appLogger
+};

package/src/hmr/client/hmr-runtime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ecopages HMR Runtime
+ * Injected into the browser to handle Hot Module Replacement updates.
+ */
+export {};