@ecopages/core 0.2.0-alpha.1

package/src/eco/eco.utils.ts

@@ -0,0 +1,89 @@
+import type { EcoComponent } from '../public-types.ts';
+import { buildInjectorMapScript } from './lazy-injector-map.ts';
+
+/**
+ * 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 function isThenable<T>(value: unknown): value is PromiseLike<T> {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		'then' in value &&
+		typeof (value as { then?: unknown }).then === 'function'
+	);
+}
+
+/**
+ * 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 function addTriggerAttribute(content: unknown, triggerId: string): string {
+	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;
+}
+
+/**
+ * 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 function wrapWithScriptsInjector(
+	content: unknown,
+	lazyGroups: NonNullable<EcoComponent['config']>['_resolvedLazyScripts'],
+): string {
+	const wrappedContent = String(content);
+	const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
+	return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}</script>${wrappedContent}</scripts-injector>`;
+}

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/global-injector-map.ts

@@ -0,0 +1,112 @@
+import type { ResolvedLazyTrigger } from '../public-types.ts';
+
+type GlobalInjectorEntry = {
+	'on:idle'?: { scripts: string[] };
+	'on:interaction'?: { value: string; scripts: string[] };
+	'on:visible'?: { value?: string; scripts: string[] };
+};
+
+type GlobalInjectorMap = Record<string, GlobalInjectorEntry>;
+
+/**
+ * Converts a flat list of resolved triggers into the map structure consumed
+ * by the `initGlobalInjector` bootstrap. Multiple triggers sharing the same
+ * `triggerId` are merged so their script lists are deduplicated.
+ */
+function buildGlobalInjectorMap(triggers: ResolvedLazyTrigger[]): GlobalInjectorMap {
+	const map: GlobalInjectorMap = {};
+
+	for (const { triggerId, rules } of triggers) {
+		const entry: GlobalInjectorEntry = map[triggerId] ?? {};
+
+		for (const rule of rules) {
+			if ('on:idle' in rule) {
+				const { scripts } = rule['on:idle'];
+				entry['on:idle'] = {
+					scripts: Array.from(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(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(new Set([...(entry['on:visible']?.scripts ?? []), ...scripts])),
+				};
+				continue;
+			}
+		}
+
+		if (Object.keys(entry).length > 0) {
+			map[triggerId] = entry;
+		}
+	}
+
+	return map;
+}
+
+/**
+ * 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 function buildGlobalInjectorMapScript(triggers: ResolvedLazyTrigger[]): string {
+	const map = buildGlobalInjectorMap(triggers);
+	return JSON.stringify(map).replace(/<\/script/gi, '<\\/script');
+}
+
+/**
+ * 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 function buildGlobalInjectorBootstrapContent(globalInjectorModuleUrl: string): string {
+	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();
+};`;
+}

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/lazy-injector-map.ts

@@ -0,0 +1,120 @@
+import type { InjectorMapConfig } from '@ecopages/scripts-injector/types';
+import type { ResolvedLazyScriptGroup } from '../public-types.ts';
+
+/**
+ * Normalizes a comma-separated scripts string into absolute script URLs.
+ *
+ * @param scripts Comma-separated script paths.
+ * @returns Normalized script path list.
+ */
+function normalizeScripts(scripts: string): string[] {
+	return scripts
+		.split(',')
+		.map((scriptPath) => scriptPath.trim())
+		.filter(Boolean)
+		.map((scriptPath) => {
+			if (scriptPath.startsWith('/')) {
+				return scriptPath;
+			}
+
+			const normalizedRelativePath = scriptPath.replace(/^\/+/, '').replace(/^(\.\/)+/, '');
+			return `/${normalizedRelativePath}`;
+		});
+}
+
+/**
+ * Deduplicates comma-separated values while preserving first-seen order.
+ *
+ * @param values CSV value list.
+ * @returns A single normalized CSV string.
+ */
+function dedupeCsvValues(values: string[]): string {
+	const seen = new Set<string>();
+
+	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(',');
+}
+
+/**
+ * Builds a scripts-injector map config from resolved lazy script groups.
+ *
+ * @param lazyGroups Lazy script groups resolved during dependency processing.
+ * @returns Injector map config keyed by lazy trigger.
+ */
+function buildInjectorMap(lazyGroups: ResolvedLazyScriptGroup[]): InjectorMapConfig {
+	const map: InjectorMapConfig = {};
+
+	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 : undefined;
+			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;
+}
+
+/**
+ * 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 function buildInjectorMapScript(lazyGroups: ResolvedLazyScriptGroup[]): string {
+	const map = buildInjectorMap(lazyGroups);
+	return JSON.stringify(map).replace(/<\/script/gi, '<\\/script');
+}

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/eco/module-dependencies.ts

@@ -0,0 +1,75 @@
+export type ModuleDependencyDeclaration = {
+	from: string;
+	imports?: string[];
+};
+
+function normalizeImports(imports: string[] | undefined): string[] | undefined {
+	if (!imports || imports.length === 0) {
+		return undefined;
+	}
+
+	const normalized = Array.from(new Set(imports.map((entry) => entry.trim()).filter((entry) => entry.length > 0)));
+
+	return normalized.length > 0 ? normalized : undefined;
+}
+
+/**
+ * Parses a module grammar declaration into normalized object form.
+ *
+ * Supported input examples:
+ * - `react-aria-components`
+ * - `react-aria-components{Table,Select}`
+ */
+export function parseModuleDeclaration(value: string): ModuleDependencyDeclaration {
+	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,
+	};
+}
+
+/**
+ * Normalizes and deduplicates module declarations from `modules`.
+ *
+ * Returns canonical object declarations suitable for downstream bundling logic.
+ */
+export function normalizeModuleDeclarations(modules?: string[]): ModuleDependencyDeclaration[] {
+	const declarations = modules ?? [];
+
+	const output: ModuleDependencyDeclaration[] = [];
+	const seen = new Set<string>();
+
+	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;
+}

package/src/env.d.ts

@@ -0,0 +1,20 @@
+interface EcopagesEnv {
+	ECOPAGES_BASE_URL: string;
+	ECOPAGES_HOSTNAME: string;
+	ECOPAGES_PORT: string;
+	ECOPAGES_LOGGER_DEBUG: 'true' | 'false';
+}
+
+declare global {
+	namespace NodeJS {
+		interface ProcessEnv extends EcopagesEnv {}
+	}
+
+	namespace Bun {
+		interface Env extends EcopagesEnv {}
+	}
+
+	interface ImportMetaEnv extends EcopagesEnv {}
+}
+
+export {};

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