@async/framework 0.7.0 → 0.9.0

package/server.d.ts

@@ -0,0 +1,690 @@
+// Generated by scripts/build-framework-bundle.js. Do not edit by hand.
+// Server-capable 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 type SchedulerStrategy = "microtask" | "manual";
+export type SchedulerPhase = "binding" | "lifecycle" | "effect" | "async" | "post" | string;
+export interface SchedulerJob {
+  id: number;
+  phase: SchedulerPhase;
+  scope?: unknown;
+  boundary?: string;
+  key?: string;
+  canceled: boolean;
+  cancel(): void;
+}
+export interface SchedulerOptions {
+  strategy?: SchedulerStrategy;
+  phases?: SchedulerPhase[];
+  maxDepth?: number;
+  onError?(error: unknown, job: SchedulerJob): void;
+}
+export interface SchedulerInspection {
+  strategy: SchedulerStrategy;
+  phases: SchedulerPhase[];
+  pending: Record<string, number>;
+  scopesDestroyed: number;
+  flushing: boolean;
+  scheduled: boolean;
+}
+export interface Scheduler {
+  strategy: SchedulerStrategy;
+  phases: SchedulerPhase[];
+  batch<T>(fn: () => T): T;
+  enqueue(phase: SchedulerPhase, job: () => MaybePromise<unknown>, options?: { scope?: unknown; boundary?: string; key?: string }): Cleanup;
+  flush(): Promise<void>;
+  flushScope(scope: unknown): Promise<void>;
+  afterFlush(job: () => MaybePromise<unknown>, options?: { scope?: unknown; boundary?: string; key?: string }): Cleanup;
+  cancelScope(scope: unknown): this;
+  markScopeDestroyed(scope: unknown): this;
+  isScopeDestroyed(scope: unknown): boolean;
+  destroy(): void;
+  inspect(): SchedulerInspection;
+}
+
+export interface RequestContextStore {
+  run<T>(context: Record<string, unknown> | undefined, fn: () => T): T;
+  get(): Record<string, unknown> | undefined;
+  snapshot(): Record<string, 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;
+  scheduler?: Scheduler;
+  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;
+  scheduler?: Scheduler;
+  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;
+  scheduler?: Scheduler;
+  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;
+  scheduler?: Scheduler;
+  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;
+  abort?: AbortSignal;
+  scheduler?: Scheduler;
+  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;
+  scheduler?: Scheduler;
+}
+
+export interface Router {
+  mode: RouterMode;
+  root: Document | Element;
+  boundary: string;
+  routes: RouteRegistry;
+  loader: LoaderInstance;
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  server?: ServerNamespace;
+  cache?: CacheRegistry;
+  partials?: PartialRegistry;
+  scheduler: Scheduler;
+  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;
+  scheduler?: Scheduler;
+  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;
+  scheduler?: Scheduler;
+  attributes?: AttributeConfig;
+}
+
+export interface LoaderInstance {
+  root: Document | Element | DocumentFragment;
+  signals: SignalRegistry;
+  handlers: HandlerRegistry;
+  server?: ServerNamespace;
+  router?: Router;
+  cache?: CacheRegistry;
+  scheduler: Scheduler;
+  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 BoundaryPatch {
+  boundary: string;
+  seq: number;
+  html?: TemplateLike;
+  signals?: Record<string, unknown>;
+  cache?: { browser?: Record<string, unknown> };
+  redirect?: string;
+  error?: unknown;
+  parentScope?: string;
+  scope?: string;
+  meta?: Record<string, unknown>;
+}
+
+export type BoundaryApplyResult =
+  | { status: "applied"; boundary: string; seq: number }
+  | { status: "ignored-stale"; boundary: string; seq: number; lastSeq: number }
+  | { status: "ignored-destroyed"; boundary: string; seq: number; parentScope?: string }
+  | { status: "redirected"; boundary: string; seq: number; redirect: string }
+  | { status: "errored"; boundary: string; seq: number; error: Error };
+
+export interface BoundaryReceiverInspection {
+  destroyed: boolean;
+  boundaries: Record<string, { lastSeq: number; applied: number; ignored: number; errored?: number; lastStatus?: BoundaryApplyResult["status"] }>;
+  recent: Array<{ boundary: string; seq: number; status: BoundaryApplyResult["status"]; lastSeq?: number; parentScope?: string; redirect?: string }>;
+}
+
+export interface BoundaryReceiverOptions {
+  loader: LoaderInstance;
+  signals?: SignalRegistry;
+  cache?: CacheRegistry;
+  scheduler?: Scheduler;
+  router?: Router;
+  onApply?(result: BoundaryApplyResult, patch: BoundaryPatch): void;
+  onIgnore?(result: BoundaryApplyResult, patch: BoundaryPatch): void;
+  onError?(error: Error, result: BoundaryApplyResult, patch: BoundaryPatch): void;
+  throwOnError?: boolean;
+  recentLimit?: number;
+  isScopeDestroyed?(scope: string): boolean;
+}
+
+export interface BoundaryReceiver {
+  apply(patch: BoundaryPatch): Promise<BoundaryApplyResult>;
+  inspect(): BoundaryReceiverInspection;
+  reset(boundary?: string): this;
+  destroy(): void;
+}
+
+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;
+  requestContext?: RequestContextStore;
+  scheduler?: Scheduler;
+}
+
+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;
+  scheduler: Scheduler;
+  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;
+  readSnapshot: typeof readSnapshot;
+  attributeName: typeof attributeName;
+  defineAttributeConfig: typeof defineAttributeConfig;
+  createBoundaryReceiver: typeof createBoundaryReceiver;
+  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;
+  createScheduler: typeof createScheduler;
+  defineRoute: typeof defineRoute;
+  route: typeof route;
+  applyServerResult: typeof applyServerResult;
+  createServerProxy: typeof createServerProxy;
+  createServerRegistry: typeof createServerRegistry;
+  createRequestContextStore: typeof createRequestContextStore;
+  resolveServerCommandArguments: typeof resolveServerCommandArguments;
+  unwrapServerResult: typeof unwrapServerResult;
+  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 readSnapshot(root?: Document | Element, options?: { attributes?: AttributeConfig }): { signals?: Record<string, unknown>; cache?: { browser?: Record<string, unknown> } };
+export declare function attributeName(attributes: AttributeConfig | undefined, type: keyof NormalizedAttributeConfig, name: string): string;
+export declare function defineAttributeConfig(config?: AttributeConfig): NormalizedAttributeConfig;
+export declare function createBoundaryReceiver(options: BoundaryReceiverOptions): BoundaryReceiver;
+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 createScheduler(options?: SchedulerOptions): Scheduler;
+export declare function defineRoute(partial: string, options?: Omit<RouteDefinition, "partial">): RouteDefinition;
+export declare const route: typeof defineRoute;
+export declare function applyServerResult(result: unknown, context?: Record<string, unknown>): Promise<unknown>;
+export declare function createServerProxy(options?: ServerProxyOptions): ServerNamespace;
+export declare function createServerRegistry(initialMap?: Record<string, ServerFunction>, options?: { registry?: RegistryStore; type?: "server" }): ServerNamespace;
+export declare function createRequestContextStore(): RequestContextStore;
+export declare function resolveServerCommandArguments(args: Array<{ type: "local"; name: string } | { type: "signal"; path: string }>, context?: Record<string, unknown>): { args: unknown[]; signalValues: Record<string, unknown>; signalPaths: string[] };
+export declare function unwrapServerResult<T = unknown>(result: ServerResult<T>): T | ServerResult<T>;
+export declare function computed<T = unknown>(fn: (this: { signals: SignalRegistry; id: string; server?: ServerNamespace; router?: Router; loader?: LoaderInstance; cache?: CacheRegistry; scheduler?: Scheduler }) => 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;
+}