eclipsa 0.1.0 → 0.1.2

package/internal-Dmvt_AGE.d.mts

@@ -0,0 +1,674 @@
+import { i as JSX } from "./types-WOJV0N2h.mjs";
+import { n as EURL, t as Component } from "./component-DjUmyVqL.mjs";
+import { Context } from "hono";
+import { Env, MiddlewareHandler } from "hono/types";
+
+//#region core/router-shared.d.ts
+interface NavigateOptions {
+  replace?: boolean;
+}
+interface Navigate {
+  (href: string, options?: NavigateOptions): Promise<void>;
+  readonly isNavigating: boolean;
+}
+type LinkPrefetchMode = 'focus' | 'hover' | 'intent' | 'none';
+interface RouteLocation {
+  readonly hash: string;
+  readonly href: string;
+  readonly pathname: string;
+  readonly search: string;
+}
+type RouteParams = Record<string, string | string[] | undefined>;
+interface StaticPath {
+  params: RouteParams;
+}
+type GetStaticPaths = () => StaticPath[] | Promise<StaticPath[]>;
+interface RoutePathSegment {
+  kind: 'static' | 'required' | 'optional' | 'rest';
+  value: string;
+}
+interface RouteModuleManifest {
+  error: string | null;
+  hasMiddleware: boolean;
+  layouts: string[];
+  loading: string | null;
+  notFound: string | null;
+  page: string | null;
+  routePath: string;
+  segments: RoutePathSegment[];
+  server: string | null;
+}
+type RouteManifest = RouteModuleManifest[];
+//#endregion
+//#region core/serialize.d.ts
+interface SerializedUndefined {
+  __eclipsa_type: 'undefined';
+}
+interface SerializedObject {
+  __eclipsa_type: 'object';
+  entries: [string, SerializedValue][];
+}
+interface SerializedMap {
+  __eclipsa_type: 'map';
+  entries: [SerializedValue, SerializedValue][];
+}
+interface SerializedSet {
+  __eclipsa_type: 'set';
+  entries: SerializedValue[];
+}
+interface SerializedReference {
+  __eclipsa_type: 'ref';
+  data?: SerializedValue;
+  kind: string;
+  token: string;
+}
+type SerializedValue = SerializedUndefined | SerializedObject | SerializedMap | SerializedSet | SerializedReference | null | boolean | number | string | SerializedValue[];
+interface SerializeValueOptions {
+  maxDepth?: number;
+  maxEntries?: number;
+  serializeReference?: (value: unknown) => SerializedReference | null;
+}
+interface DeserializeValueOptions {
+  deserializeReference?: (value: SerializedReference) => unknown;
+  maxDepth?: number;
+  maxEntries?: number;
+}
+declare const serializeValue: (value: unknown, options?: SerializeValueOptions) => SerializedValue;
+declare const deserializeValue: (value: SerializedValue, options?: DeserializeValueOptions) => unknown;
+declare const escapeJSONScriptText: (json: string) => string;
+declare const escapeInlineScriptText: (script: string) => string;
+declare const serializeJSONScriptContent: (value: unknown, options?: SerializeValueOptions) => string;
+declare const parseSerializedJSON: (json: string) => SerializedValue;
+//#endregion
+//#region core/hooks.d.ts
+declare const APP_HOOKS_ELEMENT_ID = "eclipsa-app-hooks";
+interface AppVariables {}
+interface PublicErrorShape {
+  message: string;
+  [key: string]: unknown;
+}
+interface PublicError extends PublicErrorShape {}
+interface AppHooksManifest {
+  client: string | null;
+}
+type RequestFetch = typeof fetch;
+type BaseAppVariables = AppVariables & {
+  fetch: RequestFetch;
+};
+interface AppEnv extends Env {
+  Variables: BaseAppVariables;
+}
+type EnvVariables<E extends Env> = E extends {
+  Variables: infer Variables;
+} ? Variables : {};
+type WithAppEnv<E extends Env = Env> = Omit<E, 'Variables'> & {
+  Variables: EnvVariables<E> & BaseAppVariables;
+};
+type AppContext<E extends Env = Env> = Context<WithAppEnv<E>>;
+interface HandleResolveOptions {
+  pathname?: string;
+}
+type HandleResolve<E extends Env = Env> = (context?: AppContext<E>, options?: HandleResolveOptions) => Promise<Response>;
+type Handle<E extends Env = Env> = (context: AppContext<E>, resolve: HandleResolve<E>) => Response | Promise<Response>;
+type HandleFetch<E extends Env = Env> = (context: AppContext<E>, request: Request, fetch: RequestFetch) => Response | Promise<Response>;
+interface HandleErrorInput<E extends Env = Env> {
+  context: AppContext<E>;
+  error: unknown;
+  event: 'action' | 'handle' | 'loader' | 'middleware' | 'page' | 'server' | 'transport';
+}
+type HandleError<E extends Env = Env> = (input: HandleErrorInput<E>) => PublicError | void | Promise<PublicError | void>;
+type Reroute = (input: {
+  request: Request | null;
+  url: URL;
+}) => string | URL | void;
+interface TransportHook {
+  decode: (value: unknown) => unknown;
+  encode: (value: unknown) => unknown;
+}
+type Transport = Record<string, TransportHook>;
+type ServerInit = () => void | Promise<void>;
+interface ServerHooksModule<E extends Env = Env> {
+  handle?: Handle<E>;
+  handleError?: HandleError<E>;
+  handleFetch?: HandleFetch<E>;
+  init?: ServerInit;
+}
+interface AppHooksModule {
+  reroute?: Reroute;
+  transport?: Transport;
+}
+interface ResolvedHooks<E extends Env = Env> {
+  app: AppHooksModule;
+  server: ServerHooksModule<E>;
+}
+declare const serializePublicValue: (value: unknown, options?: SerializeValueOptions) => SerializedValue;
+declare const deserializePublicValue: (value: SerializedValue, options?: DeserializeValueOptions) => unknown;
+declare const withServerRequestContext: <T>(context: AppContext<any>, hooks: {
+  handleError?: HandleError<any>;
+  transport?: Transport;
+}, fn: () => T) => T;
+declare const getCurrentServerRequestContext: () => AppContext<any> | null;
+declare const transformCurrentPublicError: (error: unknown, event: HandleErrorInput<any>["event"]) => Promise<unknown>;
+declare const createRequestFetch: (context: AppContext<any>, handleFetch?: HandleFetch<any>) => RequestFetch;
+declare const attachRequestFetch: <E extends Env>(context: AppContext<E>, fetchImpl: RequestFetch) => void;
+declare const resolveReroute: (reroute: Reroute | undefined, request: Request | null, pathname: string, baseUrl: string) => string;
+declare const toPublicError: (error: unknown) => PublicError;
+declare const markPublicError: <T>(error: T, publicError: PublicError) => T;
+declare const runHandleError: (hooks: {
+  handleError?: HandleError<any>;
+}, input: HandleErrorInput<any>) => Promise<PublicError>;
+declare const registerClientHooks: (hooks: AppHooksModule) => void;
+declare const getClientHooks: () => AppHooksModule;
+declare const resetClientHooks: () => void;
+//#endregion
+//#region core/metadata.d.ts
+declare const ROUTE_METADATA_HEAD_ATTR = "data-e-metadata";
+interface MetadataContext {
+  params: RouteParams;
+  url: URL;
+}
+interface OpenGraphMetadata {
+  description?: string;
+  images?: string[];
+  title?: string;
+  type?: string;
+  url?: string;
+}
+interface TwitterMetadata {
+  card?: string;
+  description?: string;
+  images?: string[];
+  title?: string;
+}
+interface RouteMetadata {
+  canonical?: string;
+  description?: string;
+  openGraph?: OpenGraphMetadata;
+  title?: string;
+  twitter?: TwitterMetadata;
+}
+type RouteMetadataValue = RouteMetadata | null | undefined;
+type RouteMetadataResolver = (ctx: MetadataContext) => RouteMetadataValue;
+type RouteMetadataExport = RouteMetadataValue | RouteMetadataResolver;
+declare const resolveRouteMetadata: (value: RouteMetadataExport, ctx: MetadataContext) => RouteMetadata | null;
+declare const composeRouteMetadata: (values: RouteMetadataExport[], ctx: MetadataContext) => RouteMetadata | null;
+declare const renderRouteMetadataHead: (metadata: RouteMetadata | null) => JSX.Element[];
+//#endregion
+//#region core/runtime.d.ts
+declare const RESUME_FINAL_STATE_ELEMENT_ID = "eclipsa-resume-final";
+interface ResumeComponentPayload {
+  optimizedRoot?: boolean;
+  props: SerializedValue;
+  projectionSlots?: Record<string, number>;
+  scope: string;
+  signalIds: string[];
+  symbol: string;
+  visibleCount: number;
+  watchCount: number;
+}
+interface ResumeWatchPayload {
+  componentId: string;
+  mode: WatchMode;
+  scope: string;
+  signals: string[];
+  symbol: string;
+}
+interface ResumeActionPayload {
+  error: SerializedValue;
+  input: SerializedValue;
+  result: SerializedValue;
+}
+interface ResumeVisiblePayload {
+  componentId: string;
+  scope: string;
+  symbol: string;
+}
+interface ResumeLoaderPayload {
+  data: SerializedValue;
+  error: SerializedValue;
+  loaded: boolean;
+}
+interface LoaderSnapshot {
+  data: unknown;
+  error: unknown;
+  loaded: boolean;
+}
+interface ResumePayload {
+  actions: Record<string, ResumeActionPayload>;
+  components: Record<string, ResumeComponentPayload>;
+  loaders: Record<string, ResumeLoaderPayload>;
+  scopes: Record<string, SerializedValue[]>;
+  signals: Record<string, SerializedValue>;
+  subscriptions: Record<string, string[]>;
+  symbols: Record<string, string>;
+  visibles: Record<string, ResumeVisiblePayload>;
+  watches: Record<string, ResumeWatchPayload>;
+}
+interface SignalRecord<T = unknown> {
+  effects: Set<ReactiveEffect>;
+  handle: {
+    value: T;
+  };
+  id: string;
+  subscribers: Set<string>;
+  value: T;
+}
+type CleanupCallback = () => void;
+type RuntimeContextToken<T = unknown> = symbol & {
+  __eclipsa_context_type__?: T;
+};
+interface CleanupSlot {
+  callbacks: CleanupCallback[];
+}
+interface ComponentState {
+  active: boolean;
+  activateModeOnFlush?: 'patch' | 'replace';
+  didMount: boolean;
+  end?: Comment;
+  id: string;
+  mountCleanupSlots: CleanupSlot[];
+  optimizedRoot?: boolean;
+  parentId: string | null;
+  prefersEffectOnlyLocalSignalWrites?: boolean;
+  props: unknown;
+  projectionSlots: Record<string, number> | null;
+  rawProps?: Record<string, unknown> | null;
+  renderEffectCleanupSlot: CleanupSlot;
+  reuseExistingDomOnActivate?: boolean;
+  reuseProjectionSlotDomOnActivate?: boolean;
+  scopeId: string;
+  signalIds: string[];
+  start?: Comment;
+  symbol: string;
+  suspensePromise?: Promise<unknown> | null;
+  visibleCount: number;
+  watchCount: number;
+}
+interface RouterState {
+  currentPath: {
+    value: string;
+  };
+  currentRoute: LoadedRoute | null;
+  currentUrl: {
+    value: string;
+  };
+  defaultTitle: string;
+  isNavigating: {
+    value: boolean;
+  };
+  loadedRoutes: Map<string, LoadedRoute>;
+  location: RouteLocation;
+  manifest: RouteManifest;
+  navigate: Navigate;
+  prefetchedLoaders: Map<string, Map<string, LoaderSnapshot>>;
+  routeModuleBusts: Map<string, number>;
+  routePrefetches: Map<string, Promise<RoutePrefetchResult>>;
+  sequence: number;
+}
+interface RuntimeContainer {
+  actions: Map<string, unknown>;
+  actionStates: Map<string, {
+    error: unknown;
+    input: unknown;
+    result: unknown;
+  }>;
+  components: Map<string, ComponentState>;
+  dirty: Set<string>;
+  dirtyFlushQueued: boolean;
+  doc?: Document;
+  eventDispatchPromise: Promise<void> | null;
+  id: string;
+  imports: Map<string, Promise<RuntimeSymbolModule>>;
+  interactivePrefetchCheckQueued: boolean;
+  loaderStates: Map<string, {
+    data: unknown;
+    error: unknown;
+    loaded: boolean;
+  }>;
+  loaders: Map<string, unknown>;
+  nextComponentId: number;
+  nextElementId: number;
+  nextScopeId: number;
+  nextSignalId: number;
+  pendingSuspensePromises: Set<Promise<unknown>>;
+  resumeReadyPromise: Promise<void> | null;
+  rootChildCursor: number;
+  rootElement?: HTMLElement;
+  router: RouterState | null;
+  asyncSignalStates: Map<string, unknown>;
+  asyncSignalSnapshotCache: Map<string, unknown>;
+  atoms: WeakMap<object, string>;
+  nextAtomId: number;
+  scopes: Map<string, SerializedValue[]>;
+  signals: Map<string, SignalRecord>;
+  symbols: Map<string, string>;
+  visibilityListenersCleanup: (() => void) | null;
+  visibilityCheckQueued: boolean;
+  visibles: Map<string, VisibleState>;
+  watches: Map<string, WatchState>;
+}
+interface RuntimeSymbolModule {
+  default: (scope: unknown[], propsOrArg?: unknown, ...args: unknown[]) => unknown;
+}
+interface ReactiveEffect {
+  fn: () => void;
+  signals: Set<SignalRecord>;
+}
+type WatchMode = 'dynamic' | 'explicit';
+type RouteRenderer = (props: unknown) => unknown;
+interface LoadedRouteModule {
+  metadata: RouteMetadataExport | null;
+  renderer: RouteRenderer;
+  symbol: string | null;
+  url: string;
+}
+interface LoadedRoute {
+  entry: RouteModuleManifest;
+  error: unknown;
+  layouts: LoadedRouteModule[];
+  params: RouteParams;
+  pathname: string;
+  page: LoadedRouteModule;
+  render: RouteRenderer;
+}
+interface RouteDataSuccess {
+  finalHref: string;
+  finalPathname: string;
+  kind: 'page' | 'not-found';
+  loaders: Record<string, ResumeLoaderPayload>;
+  ok: true;
+}
+interface RouteDataRedirect {
+  location: string;
+  ok: false;
+}
+interface RouteDataDocumentFallback {
+  document: true;
+  ok: false;
+}
+type RouteDataResponse = RouteDataSuccess | RouteDataRedirect | RouteDataDocumentFallback;
+type RoutePrefetchResult = RouteDataResponse;
+interface WatchState {
+  cleanupSlot: CleanupSlot;
+  componentId: string;
+  effect: ReactiveEffect;
+  id: string;
+  mode: WatchMode;
+  pending: Promise<void> | null;
+  run: (() => void) | null;
+  scopeId: string;
+  symbol: string;
+  track: (() => void) | null;
+}
+interface VisibleState {
+  cleanupSlot: CleanupSlot;
+  componentId: string;
+  done: boolean;
+  id: string;
+  pending: Promise<void> | null;
+  run: (() => void | Promise<void>) | null;
+  scopeId: string;
+  symbol: string;
+}
+declare const getRuntimeComponentId: () => string | null;
+//#endregion
+//#region core/action.d.ts
+declare const ACTION_CONTENT_TYPE = "application/eclipsa-action+json";
+declare const ACTION_FORM_ATTR = "data-e-action-form";
+declare const ACTION_FORM_FIELD = "__e_action";
+declare const ACTION_REF_BRAND: unique symbol;
+declare const ACTION_INPUT_TYPE: unique symbol;
+interface StandardSchemaIssue {
+  message: string;
+  path?: ReadonlyArray<PropertyKey | {
+    readonly key: PropertyKey;
+  }>;
+}
+type StandardSchemaResult<T> = {
+  issues: readonly StandardSchemaIssue[];
+} | {
+  issues?: undefined;
+  value: T;
+};
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': {
+    readonly validate: (value: unknown, options?: {
+      readonly libraryOptions?: Record<string, unknown>;
+    }) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    } | undefined;
+    readonly vendor: string;
+    readonly version: 1;
+  };
+}
+type InferStandardSchemaInput<Schema extends StandardSchemaV1<any, any>> = NonNullable<Schema['~standard']['types']>['input'];
+type InferStandardSchemaOutput<Schema extends StandardSchemaV1<any, any>> = NonNullable<Schema['~standard']['types']>['output'];
+interface OpaqueSignalRef {
+  readonly [ACTION_REF_BRAND]?: 'signal';
+  readonly containerId: string | null;
+  readonly kind: 'signal-ref';
+  readonly token: string;
+}
+interface OpaqueDomRef {
+  readonly [ACTION_REF_BRAND]?: 'dom';
+  readonly containerId: string | null;
+  readonly kind: 'dom-ref';
+  readonly token: string;
+}
+type ActionOpaqueRef = OpaqueSignalRef | OpaqueDomRef;
+type MiddlewareEnv$1<T> = T extends {
+  readonly __eclipsa_action_env__?: infer MiddlewareEnv;
+} ? Exclude<MiddlewareEnv$1, undefined> extends Env ? WithAppEnv<Exclude<MiddlewareEnv$1, undefined>> : {} : T extends MiddlewareHandler<infer MiddlewareEnv, any, any> ? WithAppEnv<MiddlewareEnv$1> : WithAppEnv<Env>;
+type ActionEnv<Middlewares extends readonly ActionMiddleware<any>[]> = Middlewares extends readonly [infer Head, ...infer Tail] ? Tail extends readonly ActionMiddleware<any>[] ? MiddlewareEnv$1<Head> & ActionEnv<Tail> : MiddlewareEnv$1<Head> : WithAppEnv<Env>;
+type MiddlewareActionInput<T> = T extends {
+  readonly [ACTION_INPUT_TYPE]?: infer Input;
+} ? Exclude<Input, undefined> : never;
+type ActionInput<Middlewares extends readonly ActionMiddleware<any>[]> = [MiddlewareActionInput<Middlewares[number]>] extends [never] ? unknown : MiddlewareActionInput<Middlewares[number]>;
+type ResolvedActionOutput<Output> = Awaited<Output>;
+type ActionStreamYield<Output> = ResolvedActionOutput<Output> extends AsyncIterable<infer Value> ? Value : ResolvedActionOutput<Output> extends ReadableStream<infer Value> ? Value : ResolvedActionOutput<Output>;
+type ActionInvokeResult<Output> = ResolvedActionOutput<Output> extends AsyncIterable<infer Value> ? AsyncGenerator<Value, void, void> : Promise<ResolvedActionOutput<Output>>;
+type ActionInvoker<Input, Result> = unknown extends Input ? (input?: Input | FormData) => Result : undefined extends Input ? (input?: Input | FormData) => Result : (input: Input | FormData) => Result;
+interface ActionSubmission<Input, Output> {
+  readonly error: unknown;
+  readonly input: Input;
+  readonly result: Output | undefined;
+}
+interface ActionFormProps extends Record<string, unknown> {
+  children?: JSX.Element | JSX.Element[];
+}
+interface ActionHandle<Input, Output, InvokeResult = Promise<Output>> {
+  Form: (props: ActionFormProps) => JSX.Element;
+  action: ActionInvoker<Input, InvokeResult>;
+  readonly error: unknown;
+  readonly formActionId: string;
+  readonly isPending: boolean;
+  readonly lastSubmission: ActionSubmission<Input, Output> | undefined;
+  readonly result: Output | undefined;
+}
+interface ActionMiddleware<E extends Env = Env> extends MiddlewareHandler<E> {
+  readonly __eclipsa_action_env__?: E;
+}
+interface ActionValidatorMiddleware<Input, Output> extends ActionMiddleware<{
+  Variables: {
+    input: Output;
+  };
+}> {
+  readonly [ACTION_INPUT_TYPE]?: Input;
+}
+type ActionHandler<E extends Env = Env, Output = unknown> = (c: AppContext<E>) => Output | Promise<Output>;
+type ActionHandlerOutput<Handler extends (...args: any[]) => unknown> = Awaited<ReturnType<Handler>>;
+type ActionUse<Middlewares extends readonly ActionMiddleware<any>[], Handler extends ActionHandler<any, any>> = () => ActionHandle<ActionInput<Middlewares>, ActionStreamYield<ActionHandlerOutput<Handler>>, ActionInvokeResult<ActionHandlerOutput<Handler>>>;
+interface ActionFactory {
+  <Handler extends ActionHandler<{}, any>>(handler: Handler): ActionUse<[], Handler>;
+  <M1 extends ActionMiddleware<any>, Handler extends ActionHandler<ActionEnv<[M1]>, any>>(middleware1: M1, handler: Handler): ActionUse<[M1], Handler>;
+  <M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, Handler extends ActionHandler<ActionEnv<[M1, M2]>, any>>(middleware1: M1, middleware2: M2, handler: Handler): ActionUse<[M1, M2], Handler>;
+  <M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, M3 extends ActionMiddleware<any>, Handler extends ActionHandler<ActionEnv<[M1, M2, M3]>, any>>(middleware1: M1, middleware2: M2, middleware3: M3, handler: Handler): ActionUse<[M1, M2, M3], Handler>;
+  <M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, M3 extends ActionMiddleware<any>, M4 extends ActionMiddleware<any>, Handler extends ActionHandler<ActionEnv<[M1, M2, M3, M4]>, any>>(middleware1: M1, middleware2: M2, middleware3: M3, middleware4: M4, handler: Handler): ActionUse<[M1, M2, M3, M4], Handler>;
+  <M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, M3 extends ActionMiddleware<any>, M4 extends ActionMiddleware<any>, M5 extends ActionMiddleware<any>, Handler extends ActionHandler<ActionEnv<[M1, M2, M3, M4, M5]>, any>>(middleware1: M1, middleware2: M2, middleware3: M3, middleware4: M4, middleware5: M5, handler: Handler): ActionUse<[M1, M2, M3, M4, M5], Handler>;
+}
+interface ActionStateSnapshot {
+  error: unknown;
+  input: unknown;
+  result: unknown;
+}
+interface ActionExecutionValue {
+  input: unknown;
+  kind: 'value';
+  value: unknown;
+}
+interface ActionExecutionResponse {
+  input: unknown;
+  kind: 'response';
+  response: Response;
+}
+type ActionExecutionResult = ActionExecutionResponse | ActionExecutionValue;
+declare const getNormalizedActionInput: (c: AppContext<any>) => Promise<unknown>;
+declare const getActionFormSubmissionId: (c: AppContext<any>) => Promise<string | null>;
+declare const executeActionSubmission: (id: string, c: AppContext<any>) => Promise<ActionExecutionResult>;
+declare const primeActionState: (container: RuntimeContainer, id: string, snapshot: ActionStateSnapshot) => void;
+declare const action: ActionFactory;
+declare const validator: <Schema extends StandardSchemaV1<any, any>>(schema: Schema) => ActionValidatorMiddleware<InferStandardSchemaInput<Schema>, InferStandardSchemaOutput<Schema>>;
+declare function registerAction<Output>(id: string, middlewares: readonly [], handler: ActionHandler<{}, Output>): void;
+declare function registerAction<M1 extends ActionMiddleware<any>, Output>(id: string, middlewares: readonly [M1], handler: ActionHandler<ActionEnv<[M1]>, Output>): void;
+declare function registerAction<M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2], handler: ActionHandler<ActionEnv<[M1, M2]>, Output>): void;
+declare function registerAction<M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, M3 extends ActionMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2, M3], handler: ActionHandler<ActionEnv<[M1, M2, M3]>, Output>): void;
+declare function registerAction<M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, M3 extends ActionMiddleware<any>, M4 extends ActionMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2, M3, M4], handler: ActionHandler<ActionEnv<[M1, M2, M3, M4]>, Output>): void;
+declare function registerAction<M1 extends ActionMiddleware<any>, M2 extends ActionMiddleware<any>, M3 extends ActionMiddleware<any>, M4 extends ActionMiddleware<any>, M5 extends ActionMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2, M3, M4, M5], handler: ActionHandler<ActionEnv<[M1, M2, M3, M4, M5]>, Output>): void;
+declare const hasAction: (id: string) => boolean;
+declare const executeAction: (id: string, c: AppContext<any>) => Promise<Response>;
+declare const __eclipsaAction: <const Middlewares extends readonly ActionMiddleware<any>[], Handler extends ActionHandler<ActionEnv<Middlewares>, any>>(id: string, middlewares: readonly [...Middlewares], handler: Handler) => ActionUse<Middlewares, Handler>;
+//#endregion
+//#region core/loader.d.ts
+declare const SSR_PENDING_LOADER_ERROR: unique symbol;
+type MiddlewareEnv<T> = T extends {
+  readonly __eclipsa_loader_env__?: infer MiddlewareEnv;
+} ? Exclude<MiddlewareEnv, undefined> extends Env ? WithAppEnv<Exclude<MiddlewareEnv, undefined>> : {} : T extends MiddlewareHandler<infer MiddlewareEnv, any, any> ? WithAppEnv<MiddlewareEnv> : WithAppEnv<Env>;
+type LoaderEnv<Middlewares extends readonly LoaderMiddleware<any>[]> = Middlewares extends readonly [infer Head, ...infer Tail] ? Tail extends readonly LoaderMiddleware<any>[] ? MiddlewareEnv<Head> & LoaderEnv<Tail> : MiddlewareEnv<Head> : WithAppEnv<Env>;
+interface LoaderHandle<Output> {
+  readonly data: Output | undefined;
+  readonly error: unknown;
+  readonly isLoading: boolean;
+  load: () => Promise<Output>;
+}
+interface LoaderMiddleware<E extends Env = Env> extends MiddlewareHandler<E> {
+  readonly __eclipsa_loader_env__?: E;
+}
+type LoaderHandler<E extends Env = Env, Output = unknown> = (c: AppContext<E>) => Output | Promise<Output>;
+type LoaderUse<_Middlewares extends readonly LoaderMiddleware<any>[], Output> = () => LoaderHandle<Output>;
+interface LoaderFactory {
+  <Output>(handler: LoaderHandler<{}, Output>): LoaderUse<[], Output>;
+  <M1 extends LoaderMiddleware<any>, Output>(middleware1: M1, handler: LoaderHandler<LoaderEnv<[M1]>, Output>): LoaderUse<[M1], Output>;
+  <M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, Output>(middleware1: M1, middleware2: M2, handler: LoaderHandler<LoaderEnv<[M1, M2]>, Output>): LoaderUse<[M1, M2], Output>;
+  <M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, M3 extends LoaderMiddleware<any>, Output>(middleware1: M1, middleware2: M2, middleware3: M3, handler: LoaderHandler<LoaderEnv<[M1, M2, M3]>, Output>): LoaderUse<[M1, M2, M3], Output>;
+  <M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, M3 extends LoaderMiddleware<any>, M4 extends LoaderMiddleware<any>, Output>(middleware1: M1, middleware2: M2, middleware3: M3, middleware4: M4, handler: LoaderHandler<LoaderEnv<[M1, M2, M3, M4]>, Output>): LoaderUse<[M1, M2, M3, M4], Output>;
+  <M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, M3 extends LoaderMiddleware<any>, M4 extends LoaderMiddleware<any>, M5 extends LoaderMiddleware<any>, Output>(middleware1: M1, middleware2: M2, middleware3: M3, middleware4: M4, middleware5: M5, handler: LoaderHandler<LoaderEnv<[M1, M2, M3, M4, M5]>, Output>): LoaderUse<[M1, M2, M3, M4, M5], Output>;
+}
+declare const markPendingSsrLoader: (container: RuntimeContainer, id: string) => void;
+declare const consumePendingSsrLoaderIds: (container: RuntimeContainer) => string[];
+declare const isPendingSsrLoaderError: (error: unknown) => error is typeof SSR_PENDING_LOADER_ERROR;
+declare const loader: LoaderFactory;
+declare function registerLoader<Output>(id: string, middlewares: readonly [], handler: LoaderHandler<{}, Output>): void;
+declare function registerLoader<M1 extends LoaderMiddleware<any>, Output>(id: string, middlewares: readonly [M1], handler: LoaderHandler<LoaderEnv<[M1]>, Output>): void;
+declare function registerLoader<M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2], handler: LoaderHandler<LoaderEnv<[M1, M2]>, Output>): void;
+declare function registerLoader<M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, M3 extends LoaderMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2, M3], handler: LoaderHandler<LoaderEnv<[M1, M2, M3]>, Output>): void;
+declare function registerLoader<M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, M3 extends LoaderMiddleware<any>, M4 extends LoaderMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2, M3, M4], handler: LoaderHandler<LoaderEnv<[M1, M2, M3, M4]>, Output>): void;
+declare function registerLoader<M1 extends LoaderMiddleware<any>, M2 extends LoaderMiddleware<any>, M3 extends LoaderMiddleware<any>, M4 extends LoaderMiddleware<any>, M5 extends LoaderMiddleware<any>, Output>(id: string, middlewares: readonly [M1, M2, M3, M4, M5], handler: LoaderHandler<LoaderEnv<[M1, M2, M3, M4, M5]>, Output>): void;
+declare const hasLoader: (id: string) => boolean;
+declare const executeLoader: (id: string, c: AppContext<any>) => Promise<Response>;
+declare const primeLoaderState: (container: RuntimeContainer, id: string, c: AppContext<any>) => Promise<unknown>;
+declare const resolvePendingLoaders: (container: RuntimeContainer, c: AppContext<any>) => Promise<boolean>;
+declare const __eclipsaLoader: <const Middlewares extends readonly LoaderMiddleware<any>[], Output>(id: string, middlewares: readonly [...Middlewares], handler: LoaderHandler<LoaderEnv<Middlewares>, Output>) => () => LoaderHandle<Output>;
+//#endregion
+//#region core/internal.d.ts
+declare const LAZY_META_KEY: unique symbol;
+declare const WATCH_META_KEY: unique symbol;
+interface ComponentMeta {
+  captures: () => unknown[];
+  optimizedRoot?: boolean;
+  projectionSlots?: Record<string, number>;
+  symbol: string;
+}
+interface ComponentOptions {
+  optimizedRoot?: boolean;
+}
+interface LazyMeta {
+  captures: () => unknown[];
+  eventName?: string;
+  symbol: string;
+}
+interface WatchMeta {
+  captures: () => unknown[];
+  symbol: string;
+}
+interface SignalMeta<T = unknown> {
+  get(): T;
+  id: string;
+  set(value: T): void;
+}
+interface NavigateMeta {
+  readonly kind: 'navigate';
+}
+interface ActionHandleMeta {
+  readonly id: string;
+  readonly kind: 'action';
+}
+interface ActionHookMeta {
+  readonly id: string;
+  readonly kind: 'action-hook';
+}
+interface LoaderHandleMeta {
+  readonly id: string;
+  readonly kind: 'loader';
+}
+interface LoaderHookMeta {
+  readonly id: string;
+  readonly kind: 'loader-hook';
+}
+interface EventDescriptor {
+  captures: () => unknown[];
+  eventName?: string;
+  symbol: string;
+}
+interface LazyReference<T extends (...args: any[]) => unknown = (...args: any[]) => unknown> extends Function {
+  (...args: Parameters<T>): ReturnType<T>;
+  [LAZY_META_KEY]?: LazyMeta;
+}
+interface WatchReference<T extends (...args: any[]) => unknown = (...args: any[]) => unknown> extends Function {
+  (...args: Parameters<T>): ReturnType<T>;
+  [WATCH_META_KEY]?: WatchMeta;
+}
+declare const __eclipsaComponent: <T>(component: Component<T>, symbol: string, captures: () => unknown[], projectionSlots?: Record<string, number>, options?: ComponentOptions) => Component<T>;
+declare const __eclipsaLazy: <T extends (...args: any[]) => unknown>(symbol: string, fn: T, captures: () => unknown[]) => EURL<T>;
+declare const __eclipsaWatch: <T extends (...args: any[]) => unknown>(symbol: string, fn: T, captures: () => unknown[]) => T;
+declare const __eclipsaEvent: (eventName: string, symbol: string, captures: () => unknown[]) => EventDescriptor;
+declare const getComponentMeta: (value: unknown) => ComponentMeta | null;
+declare const getLazyMeta: (value: unknown) => LazyMeta | null;
+declare const setNavigateMeta: <T extends Navigate>(target: T) => T;
+declare const getNavigateMeta: (value: unknown) => NavigateMeta | null;
+declare const setActionHookMeta: <T extends Function>(target: T, id: string) => T;
+declare const getActionHookMeta: (value: unknown) => ActionHookMeta | null;
+declare const setActionHandleMeta: <T extends object>(target: T, id: string) => T;
+declare const getActionHandleMeta: (value: unknown) => ActionHandleMeta | null;
+declare const setLoaderHookMeta: <T extends Function>(target: T, id: string) => T;
+declare const getLoaderHookMeta: (value: unknown) => LoaderHookMeta | null;
+declare const setLoaderHandleMeta: <T extends object>(target: T, id: string) => T;
+declare const getLoaderHandleMeta: (value: unknown) => LoaderHandleMeta | null;
+declare const registerActionHook: <T extends Function>(id: string, hook: T) => T;
+declare const getRegisteredActionHook: <T extends Function>(id: string) => T | null;
+declare const getRegisteredActionHookIds: () => string[];
+declare const registerLoaderHook: <T extends Function>(id: string, hook: T) => T;
+declare const getRegisteredLoaderHook: <T extends Function>(id: string) => T | null;
+declare const getRegisteredLoaderHookIds: () => string[];
+declare const getWatchMeta: (value: unknown) => WatchMeta | null;
+declare const getEventMeta: (value: unknown) => EventDescriptor | LazyMeta | null;
+declare const setSignalMeta: <T>(target: {
+  value: T;
+}, meta: SignalMeta<T>) => {
+  value: T;
+};
+declare const getSignalMeta: <T>(value: unknown) => SignalMeta<T> | null;
+//#endregion
+export { resolvePendingLoaders as $, HandleErrorInput as $t, getSignalMeta as A, SerializedObject as An, RuntimeContainer as At, LoaderFactory as B, serializeValue as Bn, TwitterMetadata as Bt, getLoaderHandleMeta as C, serializePublicValue as Cn, getNormalizedActionInput as Ct, getRegisteredActionHookIds as D, DeserializeValueOptions as Dn, validator as Dt, getRegisteredActionHook as E, withServerRequestContext as En, registerAction as Et, setActionHookMeta as F, deserializeValue as Fn, ROUTE_METADATA_HEAD_ATTR as Ft, consumePendingSsrLoaderIds as G, RouteLocation as Gn, AppContext as Gt, LoaderHandler as H, LinkPrefetchMode as Hn, renderRouteMetadataHead as Ht, setLoaderHandleMeta as I, escapeInlineScriptText as In, RouteMetadata as It, isPendingSsrLoaderError as J, AppHooksModule as Jt, executeLoader as K, RouteParams as Kn, AppEnv as Kt, setLoaderHookMeta as L, escapeJSONScriptText as Ln, RouteMetadataExport as Lt, registerActionHook as M, SerializedSet as Mn, getRuntimeComponentId as Mt, registerLoaderHook as N, SerializedUndefined as Nn, MetadataContext as Nt, getRegisteredLoaderHook as O, SerializeValueOptions as On, RESUME_FINAL_STATE_ELEMENT_ID as Ot, setActionHandleMeta as P, SerializedValue as Pn, OpenGraphMetadata as Pt, registerLoader as Q, HandleError as Qt, setNavigateMeta as R, parseSerializedJSON as Rn, RouteMetadataResolver as Rt, getLazyMeta as S, runHandleError as Sn, getActionFormSubmissionId as St, getNavigateMeta as T, transformCurrentPublicError as Tn, primeActionState as Tt, LoaderMiddleware as U, Navigate as Un, resolveRouteMetadata as Ut, LoaderHandle as V, GetStaticPaths as Vn, composeRouteMetadata as Vt, __eclipsaLoader as W, NavigateOptions as Wn, APP_HOOKS_ELEMENT_ID as Wt, markPendingSsrLoader as X, BaseAppVariables as Xt, loader as Y, AppVariables as Yt, primeLoaderState as Z, Handle as Zt, __eclipsaWatch as _, getCurrentServerRequestContext as _n, StandardSchemaV1 as _t, EventDescriptor as a, RequestFetch as an, ActionHandle as at, getComponentMeta as b, resetClientHooks as bn, executeAction as bt, LoaderHandleMeta as c, ServerHooksModule as cn, ActionOpaqueRef as ct, SignalMeta as d, TransportHook as dn, InferStandardSchemaInput as dt, HandleFetch as en, ACTION_CONTENT_TYPE as et, WatchMeta as f, WithAppEnv as fn, InferStandardSchemaOutput as ft, __eclipsaLazy as g, getClientHooks as gn, StandardSchemaResult as gt, __eclipsaEvent as h, deserializePublicValue as hn, StandardSchemaIssue as ht, ComponentOptions as i, PublicErrorShape as in, ActionFormProps as it, getWatchMeta as j, SerializedReference as jn, RuntimeContextToken as jt, getRegisteredLoaderHookIds as k, SerializedMap as kn, ResumePayload as kt, LoaderHookMeta as l, ServerInit as ln, ActionSubmission as lt, __eclipsaComponent as m, createRequestFetch as mn, OpaqueSignalRef as mt, ActionHookMeta as n, HandleResolveOptions as nn, ACTION_FORM_FIELD as nt, LazyMeta as o, Reroute as on, ActionHandler as ot, WatchReference as p, attachRequestFetch as pn, OpaqueDomRef as pt, hasLoader as q, StaticPath as qn, AppHooksManifest as qt, ComponentMeta as r, PublicError as rn, ActionFactory as rt, LazyReference as s, ResolvedHooks as sn, ActionMiddleware as st, ActionHandleMeta as t, HandleResolve as tn, ACTION_FORM_ATTR as tt, NavigateMeta as u, Transport as un, ActionValidatorMiddleware as ut, getActionHandleMeta as v, markPublicError as vn, __eclipsaAction as vt, getLoaderHookMeta as w, toPublicError as wn, hasAction as wt, getEventMeta as x, resolveReroute as xn, executeActionSubmission as xt, getActionHookMeta as y, registerClientHooks as yn, action as yt, setSignalMeta as z, serializeJSONScriptContent as zn, RouteMetadataValue as zt };
+//# sourceMappingURL=internal-Dmvt_AGE.d.mts.map