@async/framework 0.5.0 → 0.6.0

package/framework.d.ts

@@ -0,0 +1,569 @@
+// Generated by scripts/build-framework-bundle.js. Do not edit by hand.
+// Public type declarations for @async/framework.
+
+export type RuntimeTarget = "browser" | "server";
+export type RouterMode = "csr" | "spa" | "ssr" | "ssr-spa" | "mpa";
+export type AsyncSignalStatus = "idle" | "loading" | "ready" | "error";
+export type MaybePromise<T> = T | Promise<T>;
+export type Cleanup = () => void;
+export type RegistryType =
+  | "signal"
+  | "handler"
+  | "server"
+  | "partial"
+  | "route"
+  | "component"
+  | "cache.browser"
+  | "cache.server"
+  | "cache.browser.entries"
+  | "cache.server.entries";
+
+export interface AttributeConfig {
+  async?: string | string[];
+  class?: string | string[];
+  signal?: string | string[];
+  on?: string | string[];
+}
+
+export interface NormalizedAttributeConfig {
+  async: string[];
+  class: string[];
+  signal: string[];
+  on: string[];
+}
+
+export type TemplatePrimitive = string | number | boolean | null | undefined;
+export type TemplateLike = TemplateResult | TemplatePrimitive | Node | TemplateLike[];
+
+export interface TemplateResult {
+  readonly strings: TemplateStringsArray;
+  readonly values: readonly unknown[];
+}
+
+export interface Signal<T = unknown> {
+  readonly kind: "signal";
+  value: T;
+  set(value: T): T;
+  update(fn: (value: T) => T): T;
+  subscribe(fn: (value: T) => void): Cleanup;
+  snapshot(): T;
+}
+
+export interface ComputedSignal<T = unknown> extends Omit<Signal<T>, "kind"> {
+  readonly kind: "computed";
+}
+
+export interface EffectDefinition {
+  readonly kind: "effect";
+  readonly fn: () => unknown;
+}
+
+export interface AsyncSignalSnapshot<T = unknown> {
+  value: T | undefined;
+  loading: boolean;
+  error: unknown;
+  status: AsyncSignalStatus;
+  version: number;
+}
+
+export interface AsyncSignal<T = unknown> extends Omit<Signal<T | undefined>, "kind" | "snapshot"> {
+  readonly kind: "async-signal";
+  readonly id: string;
+  readonly loading: boolean;
+  readonly error: unknown;
+  readonly status: AsyncSignalStatus;
+  readonly version: number;
+  refresh(): Promise<T | undefined>;
+  cancel(reason?: unknown): void;
+  snapshot(): AsyncSignalSnapshot<T>;
+}
+
+export interface SignalRef<T = unknown> {
+  readonly kind: "signal-ref";
+  readonly id: string;
+  value: T;
+  readonly loading: boolean;
+  readonly error: unknown;
+  readonly status: AsyncSignalStatus;
+  readonly version: number;
+  get(): T;
+  set(value: T): T;
+  update(fn: (value: T) => T): T;
+  subscribe(fn: (value: T, info?: SignalSubscriptionInfo) => void): Cleanup;
+  refresh(): Promise<T | undefined>;
+  cancel(reason?: unknown): void;
+  toString(): string;
+}
+
+export interface SignalSubscriptionInfo {
+  id: string;
+  path: string;
+  signal: unknown;
+}
+
+export type SignalLike<T = unknown> = Signal<T> | AsyncSignal<T> | ComputedSignal<T>;
+export type SignalMap = Record<string, SignalLike | unknown>;
+
+export interface AsyncSignalContext {
+  signals: SignalRegistry;
+  id: string;
+  version: number;
+  abort: AbortSignal & { cancel?(reason?: unknown): void };
+  server?: ServerNamespace;
+  router?: Router;
+  loader?: LoaderInstance;
+  cache?: CacheRegistry;
+  refresh(): Promise<unknown>;
+}
+
+export type AsyncSignalFunction<T = unknown> = (this: AsyncSignalContext) => MaybePromise<T>;
+
+export interface RegistryInspection<T = unknown> {
+  registry: RegistryStore;
+  keys(): string[];
+  entries(): Array<[string, T]>;
+  inspect(): Array<[string, T]>;
+}
+
+export interface SignalRegistry extends RegistryInspection {
+  register<T = unknown>(id: string, signalLike: SignalLike<T> | T): SignalRef<T>;
+  registerMany(map?: SignalMap): this;
+  unregister(id: string): boolean;
+  ensure<T = unknown>(id: string, initial: T): SignalRef<T>;
+  has(id: string): boolean;
+  get<T = unknown>(path: string): T;
+  set<T = unknown>(path: string, value: T): T;
+  update<T = unknown>(path: string, fn: (value: T) => T): T;
+  ref<T = unknown>(id: string): SignalRef<T>;
+  subscribe<T = unknown>(path: string, fn: (value: T, info: SignalSubscriptionInfo) => void): Cleanup;
+  snapshot(): Record<string, unknown>;
+  asyncSignal<T = unknown>(id: string, fn: AsyncSignalFunction<T>): SignalRef<T>;
+  effect(fn: () => unknown): Cleanup;
+  destroy(): void;
+}
+
+export interface HandlerContext {
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  server?: ServerNamespace;
+  loader?: LoaderInstance;
+  router?: Router;
+  cache?: CacheRegistry;
+  event?: Event;
+  element?: Element;
+  el?: Element;
+  root?: Document | Element;
+  input?: unknown;
+  stop(): void;
+  [key: string]: unknown;
+}
+
+export type HandlerFunction = (this: HandlerContext, context: HandlerContext) => MaybePromise<unknown>;
+
+export interface HandlerRegistry extends RegistryInspection<HandlerFunction> {
+  register(id: string, fn: HandlerFunction): string;
+  registerMany(map?: Record<string, HandlerFunction>): this;
+  unregister(id: string): boolean;
+  resolve(id: string): HandlerFunction | undefined;
+  run(ref: string, context?: Partial<HandlerContext>): Promise<unknown[]>;
+}
+
+export interface ServerEnvelope<T = unknown> {
+  value?: T;
+  signals?: Record<string, unknown>;
+  boundary?: string;
+  html?: TemplateLike;
+  redirect?: string;
+  error?: unknown;
+  status?: number;
+  cache?: { browser?: Record<string, unknown>; server?: Record<string, unknown> };
+}
+
+export type ServerResult<T = unknown> = T | ServerEnvelope<T>;
+
+export interface ServerContext {
+  id: string;
+  args: unknown[];
+  input?: unknown;
+  signals?: SignalRegistry | { get(path: string): unknown; snapshot?(): Record<string, unknown> };
+  request?: Request;
+  headers?: Headers;
+  cookies?: unknown;
+  locals?: unknown;
+  abort?: AbortSignal;
+  cache?: CacheRegistry;
+  server: ServerNamespace;
+  [key: string]: unknown;
+}
+
+export type ServerFunction<T = unknown> = (this: ServerContext, ...args: unknown[]) => MaybePromise<ServerResult<T>>;
+
+export interface ServerNamespace {
+  run<T = unknown>(id: string, args?: unknown[], context?: Partial<ServerContext>): Promise<T>;
+  register?(id: string, fn: ServerFunction): string;
+  registerMany?(map?: Record<string, ServerFunction>): this;
+  unregister?(id: string): boolean;
+  resolve?(id: string): ServerFunction | undefined;
+  _setContext?(context?: Record<string, unknown>): this;
+  _withContext?(context?: Record<string, unknown>): ServerNamespace;
+  [key: string]: unknown;
+}
+
+export interface ServerProxyOptions {
+  endpoint?: string;
+  fetch?: typeof fetch;
+  signals?: SignalRegistry;
+  loader?: LoaderInstance;
+  router?: Router;
+  cache?: CacheRegistry;
+  headers?: Record<string, string>;
+}
+
+export interface CacheDefinition {
+  readonly kind: "cache-definition";
+  store: string;
+  ttl?: number;
+}
+
+export interface CacheRegistry extends RegistryInspection<CacheDefinition> {
+  register(id: string, definition?: CacheDefinition | CacheDefinitionOptions): string;
+  registerMany(map?: Record<string, CacheDefinition | CacheDefinitionOptions>): this;
+  unregister(id: string): boolean;
+  resolve(id: string): CacheDefinition | undefined;
+  get<T = unknown>(key: string): T | undefined;
+  set<T = unknown>(key: string, value: T, options?: CacheSetOptions): T;
+  getOrSet<T = unknown>(key: string, fn: () => MaybePromise<T>, options?: CacheSetOptions): Promise<T>;
+  delete(key: string): boolean;
+  clear(prefix?: string): this;
+  snapshot(): Record<string, unknown>;
+  restore(snapshot?: Record<string, unknown>): this;
+  entryKeys(): string[];
+  entryEntries(): Array<[string, unknown]>;
+}
+
+export interface CacheDefinitionOptions {
+  store?: string;
+  ttl?: number;
+}
+
+export interface CacheSetOptions {
+  ttl?: number;
+  cache?: string;
+}
+
+export interface PartialContext {
+  id: string;
+  props: Record<string, unknown>;
+  params?: Record<string, string>;
+  route?: RouteDefinition;
+  signals?: SignalRegistry;
+  handlers?: HandlerRegistry;
+  server?: ServerNamespace;
+  cache?: CacheRegistry;
+  browserCache?: CacheRegistry;
+  partials: PartialRegistry;
+  request?: Request;
+  locals?: unknown;
+  [key: string]: unknown;
+}
+
+export type PartialFunction = (this: PartialContext, props: Record<string, unknown>) => MaybePromise<TemplateLike | ServerEnvelope>;
+
+export interface PartialRegistry extends RegistryInspection<PartialFunction> {
+  register(id: string, fn: PartialFunction): string;
+  registerMany(map?: Record<string, PartialFunction>): this;
+  unregister(id: string): boolean;
+  resolve(id: string): PartialFunction | undefined;
+  render(id: string, props?: Record<string, unknown>, context?: Partial<PartialContext>): Promise<ServerEnvelope>;
+}
+
+export interface RouteDefinition {
+  partial?: string;
+  load?: string;
+  [key: string]: unknown;
+}
+
+export interface RouteMatch {
+  pattern: string;
+  params: Record<string, string>;
+  route: RouteDefinition;
+}
+
+export interface RouteRegistry {
+  registry: RegistryStore;
+  register(pattern: string, definition: RouteDefinition | string): RouteMatch;
+  registerMany(map?: Record<string, RouteDefinition | string>): this;
+  unregister(pattern: string): boolean;
+  match(url: string | URL): RouteMatch | null;
+  entries(): Array<{ pattern: string; route: RouteDefinition }>;
+  keys(): string[];
+  inspect(): Array<[string, RouteDefinition]>;
+}
+
+export interface RouterOptions {
+  mode?: RouterMode;
+  root?: Document | Element;
+  boundary?: string;
+  routes?: RouteRegistry;
+  loader?: LoaderInstance;
+  signals?: SignalRegistry;
+  handlers?: HandlerRegistry;
+  server?: ServerNamespace;
+  cache?: CacheRegistry;
+  partials?: PartialRegistry;
+  fetch?: typeof fetch;
+  routeEndpoint?: string;
+  attributes?: AttributeConfig;
+}
+
+export interface Router {
+  mode: RouterMode;
+  root: Document | Element;
+  boundary: string;
+  routes: RouteRegistry;
+  loader: LoaderInstance;
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  server?: ServerNamespace;
+  cache?: CacheRegistry;
+  partials?: PartialRegistry;
+  attributes: NormalizedAttributeConfig;
+  start(): this;
+  match(url: string | URL): RouteMatch | null;
+  prefetch(url: string | URL): Promise<unknown>;
+  navigate(url: string | URL, options?: { replace?: boolean; initial?: boolean; source?: string; history?: boolean }): Promise<unknown>;
+  destroy(): void;
+}
+
+export type LifecycleEventName = "attach" | "mount" | "visible" | "destroy";
+
+export interface ComponentContext {
+  scope: string;
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  loader: LoaderInstance;
+  server?: ServerNamespace;
+  router?: Router;
+  cache?: CacheRegistry;
+  signal<T = unknown>(initial: T): SignalRef<T>;
+  signal<T = unknown>(name: string, initial: T): SignalRef<T>;
+  computed<T = unknown>(name: string, fn: (this: ComponentContext) => T): SignalRef<T>;
+  asyncSignal<T = unknown>(name: string, fn: AsyncSignalFunction<T>): SignalRef<T>;
+  effect(fn: (this: ComponentContext) => unknown): Cleanup;
+  handler(fn: HandlerFunction): string;
+  handler(name: string, fn: HandlerFunction): string;
+  render<TProps extends Record<string, unknown> = Record<string, unknown>>(Child: ComponentFunction<TProps>, props?: TProps): TemplateLike;
+  suspense(signalRef: Pick<SignalRef, "id">, views: SuspenseViews | SuspenseReadyView): TemplateLike;
+  on(eventName: LifecycleEventName, fn: (this: ComponentContext, target?: Element) => unknown): void;
+  onMount(fn: (this: ComponentContext, target?: Element) => unknown): void;
+  onVisible(fn: (this: ComponentContext, target?: Element) => unknown): void;
+}
+
+export type ComponentFunction<TProps extends Record<string, unknown> = Record<string, unknown>> = (this: ComponentContext, props: TProps) => TemplateLike;
+export type SuspenseReadyView = (this: ComponentContext, signalRef: Pick<SignalRef, "id">) => TemplateLike;
+export interface SuspenseViews {
+  loading?: SuspenseReadyView;
+  ready?: SuspenseReadyView;
+  error?: SuspenseReadyView;
+}
+
+export interface ComponentRegistry extends RegistryInspection<ComponentFunction> {
+  register(id: string, Component: ComponentFunction): string;
+  registerMany(map?: Record<string, ComponentFunction>): this;
+  unregister(id: string): boolean;
+  resolve(id: string): ComponentFunction | undefined;
+}
+
+export interface LoaderOptions {
+  root?: Document | Element | DocumentFragment;
+  signals?: SignalRegistry;
+  handlers?: HandlerRegistry;
+  server?: ServerNamespace;
+  router?: Router;
+  cache?: CacheRegistry;
+  attributes?: AttributeConfig;
+}
+
+export interface LoaderInstance {
+  root: Document | Element | DocumentFragment;
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  server?: ServerNamespace;
+  router?: Router;
+  cache?: CacheRegistry;
+  attributes: NormalizedAttributeConfig;
+  start(): this;
+  scan(rootOrFragment?: Document | Element | DocumentFragment): this;
+  swap(boundaryId: string, fragmentOrTemplate: TemplateLike): Element;
+  mount<TProps extends Record<string, unknown> = Record<string, unknown>>(target: Element, Component: ComponentFunction<TProps>, props?: TProps): unknown;
+  destroy(): void;
+}
+
+export type AsyncLoaderOptions = LoaderOptions;
+export type AsyncLoaderInstance = LoaderInstance;
+
+export interface RegistryStore {
+  target: RuntimeTarget;
+  register(type: RegistryType, id: string, value: unknown): string;
+  registerMany(type: RegistryType, map?: Record<string, unknown>): this;
+  set(type: RegistryType, id: string, value: unknown): unknown;
+  unregister(type: RegistryType, id: string): boolean;
+  delete(type: RegistryType, id: string): boolean;
+  keys(type: RegistryType, options?: Record<string, unknown>): string[];
+  entries(type: RegistryType, options?: Record<string, unknown>): Array<[string, unknown]>;
+  has(type: RegistryType, id: string, options?: Record<string, unknown>): boolean;
+  get(type: RegistryType, id: string, options?: Record<string, unknown>): unknown;
+  snapshot(options?: { target?: RuntimeTarget }): RegistrySnapshot;
+  rawSnapshot(): AppDefinition;
+  view(options?: { target?: RuntimeTarget }): RegistryStore;
+}
+
+export interface RegistrySnapshot {
+  signal: Record<string, unknown>;
+  handler: Record<string, { id: string; kind: "handler" }>;
+  server: Record<string, { id: string; kind: "server" }>;
+  partial: Record<string, { id: string; kind: "partial" }>;
+  route: Record<string, RouteDefinition>;
+  component: Record<string, { id: string; kind: "component" }>;
+  cache: { browser: Record<string, CacheDefinition>; server: Record<string, CacheDefinition> };
+  entries: { browser: Record<string, unknown>; server: Record<string, unknown> };
+}
+
+export interface AppDefinition {
+  signal?: SignalMap;
+  handler?: Record<string, HandlerFunction>;
+  server?: Record<string, ServerFunction>;
+  partial?: Record<string, PartialFunction>;
+  route?: Record<string, RouteDefinition | string>;
+  component?: Record<string, ComponentFunction>;
+  cache?: {
+    browser?: Record<string, CacheDefinition | CacheDefinitionOptions>;
+    server?: Record<string, CacheDefinition | CacheDefinitionOptions>;
+  };
+  entries?: { browser?: Record<string, unknown>; server?: Record<string, unknown> };
+}
+
+export interface AppHub {
+  registry: RegistryStore;
+  runtime?: AppRuntime;
+  use(type: "signal", entries: SignalMap): this;
+  use(type: "handler", entries: Record<string, HandlerFunction>): this;
+  use(type: "server", entries: Record<string, ServerFunction>): this;
+  use(type: "partial", entries: Record<string, PartialFunction>): this;
+  use(type: "route", entries: Record<string, RouteDefinition | string>): this;
+  use(type: "component", entries: Record<string, ComponentFunction>): this;
+  use(moduleObject: AppDefinition): this;
+  snapshot(): AppDefinition;
+  start(options?: CreateAppOptions): AppRuntime;
+}
+
+export interface CreateAppOptions extends LoaderOptions {
+  target?: RuntimeTarget;
+  mode?: RouterMode;
+  boundary?: string;
+  snapshot?: { signals?: Record<string, unknown>; cache?: { browser?: Record<string, unknown> } };
+  registry?: RegistryStore;
+  loader?: LoaderInstance;
+  router?: Router | false;
+  routes?: RouteRegistry;
+  partials?: PartialRegistry;
+  components?: ComponentRegistry;
+  fetch?: typeof fetch;
+  routeEndpoint?: string;
+  request?: Request;
+  locals?: unknown;
+}
+
+export interface RenderResult {
+  html: string;
+  status: number;
+  signals: Record<string, unknown>;
+  cache: { browser: Record<string, unknown> };
+}
+
+export interface AppRuntime {
+  app: AppHub;
+  registry: RegistryStore;
+  target: RuntimeTarget;
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  server: ServerNamespace & { cache: CacheRegistry };
+  partials: PartialRegistry;
+  routes: RouteRegistry;
+  components: ComponentRegistry;
+  browser: { cache: CacheRegistry };
+  loader?: LoaderInstance;
+  router?: Router;
+  attributes: NormalizedAttributeConfig;
+  start(): this;
+  use(type: Parameters<AppHub["use"]>[0], entries?: unknown): this;
+  render(url: string | URL): Promise<RenderResult>;
+  destroy(): void;
+}
+
+export interface AsyncNamespace extends AppHub {
+  Async: AsyncNamespace;
+  asyncSignal: typeof asyncSignal;
+  createApp: typeof createApp;
+  defineApp: typeof defineApp;
+  attributeName: typeof attributeName;
+  defineAttributeConfig: typeof defineAttributeConfig;
+  createCacheRegistry: typeof createCacheRegistry;
+  defineCache: typeof defineCache;
+  component: typeof component;
+  createComponentRegistry: typeof createComponentRegistry;
+  defineComponent: typeof defineComponent;
+  delay: typeof delay;
+  createHandlerRegistry: typeof createHandlerRegistry;
+  html: typeof html;
+  Loader: typeof Loader;
+  AsyncLoader: typeof Loader;
+  createPartialRegistry: typeof createPartialRegistry;
+  createRegistryStore: typeof createRegistryStore;
+  createRouteRegistry: typeof createRouteRegistry;
+  createRouter: typeof createRouter;
+  defineRoute: typeof defineRoute;
+  route: typeof route;
+  createServerProxy: typeof createServerProxy;
+  createServerRegistry: typeof createServerRegistry;
+  computed: typeof computed;
+  createSignal: typeof createSignal;
+  createSignalRegistry: typeof createSignalRegistry;
+  effect: typeof effect;
+  signal: typeof signal;
+}
+
+export declare function asyncSignal<T = unknown>(id: string, fn: AsyncSignalFunction<T>): AsyncSignal<T>;
+export declare const Async: AppHub;
+export declare function createApp(appOrDefinition?: AppHub | AppDefinition, options?: CreateAppOptions): AppRuntime;
+export declare function defineApp(initial?: AppDefinition): AppHub;
+export declare function attributeName(attributes: AttributeConfig | undefined, type: keyof NormalizedAttributeConfig, name: string): string;
+export declare function defineAttributeConfig(config?: AttributeConfig): NormalizedAttributeConfig;
+export declare function createCacheRegistry(initialMap?: Record<string, CacheDefinition | CacheDefinitionOptions>, options?: { now?: () => number; registry?: RegistryStore; type?: "cache.browser" | "cache.server" }): CacheRegistry;
+export declare function defineCache(options?: CacheDefinitionOptions): CacheDefinition;
+export declare function component<TProps extends Record<string, unknown> = Record<string, unknown>>(fn: ComponentFunction<TProps>): ComponentFunction<TProps>;
+export declare function createComponentRegistry(initialMap?: Record<string, ComponentFunction>, options?: { registry?: RegistryStore; type?: "component" }): ComponentRegistry;
+export declare function defineComponent<TProps extends Record<string, unknown> = Record<string, unknown>>(fn: ComponentFunction<TProps>): ComponentFunction<TProps>;
+export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function createHandlerRegistry(initialMap?: Record<string, HandlerFunction>, options?: { registry?: RegistryStore; type?: "handler" }): HandlerRegistry;
+export declare function html(strings: TemplateStringsArray, ...values: unknown[]): TemplateResult;
+export declare function Loader(options?: LoaderOptions): LoaderInstance;
+export declare const AsyncLoader: typeof Loader;
+export declare function createPartialRegistry(initialMap?: Record<string, PartialFunction>, options?: { registry?: RegistryStore; type?: "partial" }): PartialRegistry;
+export declare function createRegistryStore(initial?: AppDefinition, options?: { target?: RuntimeTarget; backing?: unknown }): RegistryStore;
+export declare function createRouteRegistry(initialMap?: Record<string, RouteDefinition | string>, options?: { registry?: RegistryStore; type?: "route" }): RouteRegistry;
+export declare function createRouter(options?: RouterOptions): Router;
+export declare function defineRoute(partial: string, options?: Omit<RouteDefinition, "partial">): RouteDefinition;
+export declare const route: typeof defineRoute;
+export declare function createServerProxy(options?: ServerProxyOptions): ServerNamespace;
+export declare function createServerRegistry(initialMap?: Record<string, ServerFunction>, options?: { registry?: RegistryStore; type?: "server" }): ServerNamespace;
+export declare function computed<T = unknown>(fn: (this: { signals: SignalRegistry; id: string; server?: ServerNamespace; router?: Router; loader?: LoaderInstance; cache?: CacheRegistry }) => T): ComputedSignal<T>;
+export declare function createSignal<T = unknown>(initial: T): Signal<T>;
+export declare function createSignalRegistry(initialMap?: SignalMap, options?: { registry?: RegistryStore; type?: "signal" }): SignalRegistry;
+export declare function effect(fn: () => unknown): EffectDefinition;
+export declare const signal: typeof createSignal;
+
+declare global {
+  const Async: AsyncNamespace;
+  const AsyncFramework: AsyncNamespace;
+}

package/framework.js

@@ -1516,7 +1516,7 @@ const __componentModule = (() => {
       bind(value) {
         const id = runtime.loader?._registerBinding?.(value);
         if (!id) {
-          throw new Error("Inline template bindings require an AsyncLoader.");
+          throw new Error("Inline template bindings require a Loader.");
         }
         bindingIds.push(id);
         return id;
@@ -2356,7 +2356,7 @@ const __loaderModule = (() => {
   const { matchAttribute, normalizeAttributeConfig, readAttribute } = __attributesModule;
   const inlineBindingPrefix = "__async:inline:";
 
-  function AsyncLoader({ root, signals, handlers, server, router, cache, attributes } = {}) {
+  function Loader({ root, signals, handlers, server, router, cache, attributes } = {}) {
     const documentRef = root?.ownerDocument ?? root ?? globalThis.document;
     const rootNode = root ?? documentRef;
     const signalRegistry = signals ?? createSignalRegistry();
@@ -2798,7 +2798,7 @@ const __loaderModule = (() => {
 
     function assertActive() {
       if (destroyed) {
-        throw new Error("AsyncLoader has been destroyed.");
+        throw new Error("Loader has been destroyed.");
       }
     }
 
@@ -2862,6 +2862,8 @@ const __loaderModule = (() => {
     return api;
   }
 
+  const AsyncLoader = Loader;
+
   function normalizeClassTokens(value, tokens = new Set()) {
     if (value == null || value === false) {
       return tokens;
@@ -3062,7 +3064,7 @@ const __loaderModule = (() => {
       })
     );
   }
-  return { AsyncLoader };
+  return { Loader, AsyncLoader };
 })();
 
 const __partialsModule = (() => {
@@ -3185,7 +3187,7 @@ const __partialsModule = (() => {
 })();
 
 const __routerModule = (() => {
-  const { AsyncLoader } = __loaderModule;
+  const { Loader } = __loaderModule;
   const { createHandlerRegistry } = __handlersModule;
   const { createSignalRegistry } = __signalsModule;
   const { applyServerResult } = __serverModule;
@@ -3314,7 +3316,7 @@ const __routerModule = (() => {
     const attributeConfig = normalizeAttributeConfig(attributes ?? loader?.attributes);
     const loaderInstance =
       loader ??
-      AsyncLoader({
+      Loader({
         root: rootNode,
         signals: signalRegistry,
         handlers: handlerRegistry,
@@ -3665,7 +3667,7 @@ const __appModule = (() => {
   const { createCacheRegistry } = __cacheModule;
   const { createComponentRegistry } = __componentModule;
   const { createHandlerRegistry } = __handlersModule;
-  const { AsyncLoader } = __loaderModule;
+  const { Loader } = __loaderModule;
   const { createPartialRegistry } = __partialsModule;
   const { createRouteRegistry, createRouter } = __routerModule;
   const { createServerRegistry } = __serverModule;
@@ -3764,7 +3766,7 @@ const __appModule = (() => {
         started = true;
 
         if (target !== "server") {
-          loader = loader ?? AsyncLoader({
+          loader = loader ?? Loader({
             root: options.root,
             signals,
             handlers,
@@ -4115,6 +4117,7 @@ const { defineComponent: defineComponent } = __componentModule;
 const { delay: delay } = __delayModule;
 const { createHandlerRegistry: createHandlerRegistry } = __handlersModule;
 const { html: html } = __htmlModule;
+const { Loader: Loader } = __loaderModule;
 const { AsyncLoader: AsyncLoader } = __loaderModule;
 const { createPartialRegistry: createPartialRegistry } = __partialsModule;
 const { createRegistryStore: createRegistryStore } = __registryStoreModule;
@@ -4130,4 +4133,4 @@ const { createSignalRegistry: createSignalRegistry } = __signalsModule;
 const { effect: effect } = __signalsModule;
 const { signal: signal } = __signalsModule;
 
-export { asyncSignal, Async, createApp, defineApp, attributeName, defineAttributeConfig, createCacheRegistry, defineCache, component, createComponentRegistry, defineComponent, delay, createHandlerRegistry, html, AsyncLoader, createPartialRegistry, createRegistryStore, createRouteRegistry, createRouter, defineRoute, route, createServerProxy, createServerRegistry, computed, createSignal, createSignalRegistry, effect, signal };
+export { asyncSignal, Async, createApp, defineApp, attributeName, defineAttributeConfig, createCacheRegistry, defineCache, component, createComponentRegistry, defineComponent, delay, createHandlerRegistry, html, Loader, AsyncLoader, createPartialRegistry, createRegistryStore, createRouteRegistry, createRouter, defineRoute, route, createServerProxy, createServerRegistry, computed, createSignal, createSignalRegistry, effect, signal };