@askrjs/askr 0.0.51 → 0.0.53

package/dist/index-31Uoz_NS.d.ts

@@ -0,0 +1,239 @@
+import { c as RenderableChild } from "./control-BQvNVfAd.js";
+import { r as JSXElement } from "./jsx-CP0gmYwJ.js";
+//#region src/runtime/portal.d.ts
+interface Portal<T extends RenderableChild = RenderableChild> {
+  (): unknown;
+  render(props: {
+    children?: T;
+  }): unknown;
+}
+interface PortalProps {
+  children?: RenderableChild;
+}
+declare function definePortal<T extends RenderableChild = RenderableChild>(): Portal<T>;
+declare const DefaultPortal: Portal<RenderableChild>;
+declare function Portal(props: PortalProps): null;
+//#endregion
+//#region src/foundations/structures/layout.d.ts
+/**
+ * Layout helper.
+ *
+ * A layout is just a normal component that wraps children.
+ * Persistence and reuse are handled by the runtime via component identity.
+ *
+ * This helper exists purely for readability and convention.
+ *
+ * POLICY DECISIONS (LOCKED):
+ *
+ * 1. Return Type is Opaque (unknown)
+ *    Layout components return `unknown` to remain runtime-agnostic.
+ *    The runtime owns concrete JSX element types.
+ *
+ * 2. Children Positioning
+ *    Layout receives children as first argument (router-friendly).
+ *    Props come second. This matches route layout conventions where
+ *    children represent the nested route content.
+ *
+ * 3. Props Spreading
+ *    Props are spread into the layout component. This is intentional
+ *    and deterministic — no merging or composition.
+ */
+type LayoutComponent<P = object> = (props: P & {
+  children?: RenderableChild;
+}) => unknown;
+declare function layout<P = object>(Layout: LayoutComponent<P>): (children?: RenderableChild, props?: P) => unknown;
+//#endregion
+//#region src/foundations/structures/slot.d.ts
+type SlotProps = {
+  asChild: true;
+  children: JSXElement;
+  [key: string]: unknown;
+} | {
+  asChild?: false;
+  children?: RenderableChild;
+};
+/**
+ * Slot
+ *
+ * Structural primitive for prop forwarding patterns.
+ *
+ * POLICY DECISIONS (LOCKED):
+ *
+ * 1. asChild Pattern
+ *    When asChild=true, merges props into the single child element.
+ *    Child must be a valid JSXElement; non-element children return null.
+ *    **Slot props override child props** (injection pattern).
+ *
+ * 2. Fallback Behavior
+ *    When asChild=false, returns a Fragment (structural no-op).
+ *    No DOM element is introduced.
+ *
+ * 3. Type Safety
+ *    asChild=true requires exactly one JSXElement child (enforced by type).
+ *    Runtime validates with isElement() check.
+ */
+declare function Slot(props: SlotProps): JSXElement | null;
+//#endregion
+//#region src/foundations/structures/presence.d.ts
+interface PresenceProps {
+  present: boolean | (() => boolean);
+  children?: RenderableChild;
+}
+/**
+ * Presence
+ *
+ * Structural policy primitive for conditional mount/unmount.
+ * - No timers
+ * - No animation coupling
+ * - No DOM side-effects
+ *
+ * POLICY DECISIONS (LOCKED):
+ *
+ * 1. Present as Function
+ *    Accepts boolean OR function to support lazy evaluation patterns.
+ *    Function is called once per render. Use boolean form for static values.
+ *
+ * 2. Children Type
+ *    Presence forwards normal renderable child content only.
+ *    Imperative DOM nodes are not part of the public contract.
+ *
+ * 3. Immediate Mount/Unmount
+ *    No exit animations or transitions. When `present` becomes false,
+ *    children are removed immediately. Animation must be layered above
+ *    this primitive.
+ */
+declare function Presence({
+  present,
+  children
+}: PresenceProps): JSXElement | null;
+//#endregion
+//#region src/foundations/structures/collection.d.ts
+/**
+ * createCollection
+ *
+ * Ordered descendant registry for coordinating items without DOM queries.
+ *
+ * INVARIANTS:
+ * 1. Registration order determines item order (no DOM queries)
+ * 2. Stable ordering across renders (insertion order preserved)
+ * 3. Each item may have metadata (type-safe, user-defined)
+ * 4. No implicit global state (explicit collection instances)
+ * 5. No automatic cleanup (caller controls lifecycle)
+ *
+ * DESIGN:
+ * - Returns a registry API ({ register, items, clear })
+ * - Items are stored in insertion order
+ * - Registration returns an unregister function
+ * - No side effects on registration (pure data structure)
+ *
+ * USAGE:
+ *   const collection = createCollection<HTMLElement, { disabled: boolean }>();
+ *   const unregister = collection.register(element, { disabled: false });
+ *   const allItems = collection.items();
+ *   unregister();
+ */
+type CollectionItem<TNode, TMetadata = unknown> = {
+  node: TNode;
+  metadata: TMetadata;
+};
+interface Collection<TNode, TMetadata = unknown> {
+  /**
+   * Register a node with optional metadata.
+   * Returns an unregister function.
+   */
+  register(node: TNode, metadata: TMetadata): () => void;
+  /**
+   * Get all registered items in insertion order.
+   */
+  items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;
+  /**
+   * Clear all registered items.
+   */
+  clear(): void;
+  /**
+   * Get the count of registered items.
+   */
+  size(): number;
+}
+declare function createCollection<TNode, TMetadata = unknown>(): Collection<TNode, TMetadata>;
+//#endregion
+//#region src/foundations/structures/layer.d.ts
+/**
+ * createLayer
+ *
+ * Manages stacking order and coordination for overlays (modals, popovers, etc).
+ *
+ * INVARIANTS:
+ * 1. Layers are ordered by registration time (FIFO)
+ * 2. Only the top layer handles Escape key
+ * 3. Only the top layer handles outside pointer events
+ * 4. Nested layers are supported
+ * 5. Does not implement portals (orthogonal concern)
+ * 6. No automatic DOM insertion (caller controls mounting)
+ *
+ * DESIGN:
+ * - Returns a layer manager with register/unregister API
+ * - Each layer has a unique ID and can query if it's the top layer
+ * - Escape and outside pointer coordination via callbacks
+ * - No z-index management (CSS concern)
+ *
+ * USAGE:
+ *   const manager = createLayer();
+ *
+ *   const layer = manager.register({
+ *     onEscape: () => { ... },
+ *     onOutsidePointer: () => { ... }
+ *   });
+ *
+ *   layer.isTop(); // true if this is the topmost layer
+ *   layer.unregister();
+ */
+interface LayerOptions {
+  /**
+   * Called when Escape is pressed and this is the top layer
+   */
+  onEscape?: () => void;
+  /**
+   * Called when pointer event occurs outside and this is the top layer
+   */
+  onOutsidePointer?: (e: PointerEvent) => void;
+  /**
+   * Optional node reference for outside pointer detection
+   */
+  node?: Node | null;
+}
+interface Layer {
+  /**
+   * Unique layer ID
+   */
+  id: number;
+  /**
+   * Check if this layer is the topmost
+   */
+  isTop(): boolean;
+  /**
+   * Remove this layer from the stack
+   */
+  unregister(): void;
+}
+interface LayerManager {
+  /**
+   * Register a new layer
+   */
+  register(options: LayerOptions): Layer;
+  /**
+   * Get all active layers in order
+   */
+  layers(): ReadonlyArray<Layer>;
+  /**
+   * Manually trigger escape handling on the top layer
+   */
+  handleEscape(): void;
+  /**
+   * Manually trigger outside pointer handling on the top layer
+   */
+  handleOutsidePointer(e: PointerEvent): void;
+}
+declare function createLayer(): LayerManager;
+//#endregion
+export { definePortal as _, Collection as a, Presence as c, SlotProps as d, LayoutComponent as f, PortalProps as g, Portal as h, createLayer as i, PresenceProps as l, DefaultPortal as m, LayerManager as n, CollectionItem as o, layout as p, LayerOptions as r, createCollection as s, Layer as t, Slot as u };

package/dist/index-Bki2rqcr.d.ts

@@ -0,0 +1,233 @@
+//#region src/data/types.d.ts
+type QueryConsistency = 'fresh' | 'stale' | 'refreshing' | 'pending-write';
+type QueryStaleReason = 'aborted' | 'error' | 'inconsistent';
+interface DataRuntime {
+  readonly queryCache: Map<string, unknown>;
+  readonly queryData: Map<string, unknown>;
+}
+interface DataRuntimeOptions {
+  queryCache?: Map<string, unknown>;
+  queryData?: Map<string, unknown>;
+}
+interface QueryDefinition<TInput, TResult extends {}> {
+  readonly key: (input: TInput) => string;
+  readonly fetch: (context: TInput & {
+    signal: AbortSignal;
+  }) => Promise<TResult>;
+  readonly isConsistent?: (data: TResult) => boolean;
+  readonly reconcile?: (data: TResult, context: {
+    key: string;
+  }) => Promise<boolean> | boolean;
+}
+interface QueryPrefetchContext {
+  readonly runtime: DataRuntime;
+  readonly request?: Request;
+  readonly signal: AbortSignal;
+  readonly mode: 'ssr' | 'spa';
+  prefetch<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>, input: TInput): Promise<boolean>;
+}
+type ServerQueryHandler<TInput, TResult extends {}> = (context: {
+  input: TInput;
+  request?: Request;
+  signal: AbortSignal;
+}) => Promise<TResult> | TResult;
+interface InvalidateOptions {
+  markPendingWrite?: boolean;
+  runtime?: DataRuntime;
+}
+interface InvalidateOnIntervalOptions extends InvalidateOptions {
+  intervalMs: number;
+  activeOn?: string | readonly string[];
+  visibleOnly?: boolean;
+  focusedOnly?: boolean;
+}
+type QueryKeyPart = string | number | boolean | null | undefined | readonly QueryKeyPart[] | {
+  readonly [key: string]: QueryKeyPart;
+};
+interface QueryScope {
+  key(...parts: QueryKeyPart[]): string;
+  prefix(...parts: QueryKeyPart[]): string;
+  invalidate(parts: readonly QueryKeyPart[], options?: InvalidateOptions): void;
+}
+type QueryControls = {
+  refresh(): Promise<void>;
+};
+type QueryLoading = {
+  data: null;
+  error: null;
+  loading: true;
+  refreshing: false;
+  stale: false;
+  consistency: 'fresh';
+  staleReason: null;
+};
+type QueryFresh<T> = {
+  data: T;
+  error: null;
+  loading: false;
+  refreshing: false;
+  stale: false;
+  consistency: 'fresh';
+  staleReason: null;
+};
+type QueryRefreshing<T> = {
+  data: T;
+  error: null;
+  loading: false;
+  refreshing: true;
+  stale: true;
+  consistency: 'refreshing';
+  staleReason: null;
+};
+type QueryPendingWrite<T> = {
+  data: T;
+  error: null;
+  loading: false;
+  refreshing: true;
+  stale: true;
+  consistency: 'pending-write';
+  staleReason: null;
+};
+type QueryStaleValue<T> = {
+  data: T;
+  error: null;
+  loading: false;
+  refreshing: false;
+  stale: true;
+  consistency: 'stale';
+  staleReason: 'aborted' | 'inconsistent';
+};
+type QueryStaleErrorWithValue<T> = {
+  data: T;
+  error: {};
+  loading: false;
+  refreshing: false;
+  stale: true;
+  consistency: 'stale';
+  staleReason: 'error';
+};
+type QueryStaleError = {
+  data: null;
+  error: {};
+  loading: false;
+  refreshing: false;
+  stale: true;
+  consistency: 'stale';
+  staleReason: 'error';
+};
+type Query<T extends {}> = QueryControls & (QueryLoading | QueryFresh<T> | QueryRefreshing<T> | QueryPendingWrite<T> | QueryStaleValue<T> | QueryStaleErrorWithValue<T> | QueryStaleError);
+type MutationControls<TInput, TResult> = {
+  execute(input: TInput): Promise<TResult>;
+  abort(): void;
+  reset(): void;
+};
+type MutationIdle = {
+  status: 'idle';
+  pending: false;
+  error: null;
+  result: null;
+};
+type MutationPending = {
+  status: 'pending';
+  pending: true;
+  error: null;
+  result: null;
+};
+type MutationSuccess<TResult> = {
+  status: 'success';
+  pending: false;
+  error: null;
+  result: TResult;
+};
+type MutationError = {
+  status: 'error';
+  pending: false;
+  error: {};
+  result: null;
+};
+type Mutation<TInput, TResult> = MutationControls<TInput, TResult> & (MutationIdle | MutationPending | MutationSuccess<TResult> | MutationError);
+type QueryOptions<T> = {
+  key: string;
+  fetch: (ctx: {
+    signal: AbortSignal;
+  }) => Promise<T>;
+  isConsistent?: (data: T) => boolean;
+  reconcile?: (data: T, ctx: {
+    key: string;
+  }) => Promise<boolean> | boolean;
+  runtime?: DataRuntime;
+  initialData?: T;
+  skipInitialFetch?: boolean;
+};
+type MutationOptions<TInput, TResult> = {
+  action: (input: TInput, ctx: {
+    signal: AbortSignal;
+  }) => Promise<TResult>;
+  affects?: (input: TInput, result: TResult) => string[];
+  afterSuccess?: 'invalidate';
+  runtime?: DataRuntime;
+};
+//#endregion
+//#region src/data/mutation-cell.d.ts
+declare function createMutation<TInput, TResult>(options: MutationOptions<TInput, TResult>): Mutation<TInput, TResult>;
+//#endregion
+//#region src/data/query-cell.d.ts
+declare function createQuery<T extends {}>(options: QueryOptions<T>): Query<T>;
+declare function createQuery<TInput, TResult extends {}>(definition: QueryDefinition<TInput, TResult>, input: TInput, options?: Omit<QueryOptions<TResult>, 'key' | 'fetch'>): Query<TResult>;
+//#endregion
+//#region src/data/data-runtime.d.ts
+declare function createDataRuntime(options?: DataRuntimeOptions): DataRuntime;
+declare function getDefaultDataRuntime(): DataRuntime;
+//#endregion
+//#region src/data/invalidation.d.ts
+declare function invalidate(prefix: string, options?: InvalidateOptions): void;
+declare function queryScope(namespace: string): QueryScope;
+declare function invalidateOnInterval(prefix: string, options: InvalidateOnIntervalOptions): void;
+//#endregion
+//#region src/common/telemetry.d.ts
+interface TelemetryFields {
+  requestId?: string;
+  traceId?: string;
+  route?: string;
+  action?: string;
+  operation?: string;
+  status?: number;
+  durationMs?: number;
+}
+type TelemetrySpan = <T>(fields: TelemetryFields, work: () => T) => T;
+/**
+ * Structural subset implemented by `createTelemetry()` from `@askrjs/otel`.
+ * Core does not install an OpenTelemetry SDK, backend, or exporter.
+ */
+interface CoreTelemetry {
+  routeMatch?: TelemetrySpan;
+  loader?: TelemetrySpan;
+  queryPrefetch?: TelemetrySpan;
+  ssrRender?: TelemetrySpan;
+}
+//#endregion
+//#region src/data/query-registry.d.ts
+interface ServerQueryRegistry {
+  readonly entries: readonly ServerQueryEntry<unknown, {}>[];
+  get<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>): ServerQueryHandler<TInput, TResult> | undefined;
+}
+interface ServerQueryEntry<TInput, TResult extends {}> {
+  readonly query: QueryDefinition<TInput, TResult>;
+  readonly handler: ServerQueryHandler<TInput, TResult>;
+}
+declare function serveQuery<TInput, TResult extends {}>(query: QueryDefinition<TInput, TResult>, handler: ServerQueryHandler<TInput, TResult>): ServerQueryEntry<TInput, TResult>;
+declare function defineServerQueries(...entries: readonly ServerQueryEntry<any, any>[]): ServerQueryRegistry;
+declare function defineQuery<TInput, TResult extends {}>(definition: QueryDefinition<TInput, TResult>): QueryDefinition<TInput, TResult>;
+declare function createQueryPrefetchContext(options?: {
+  runtime?: DataRuntime;
+  registry?: ServerQueryRegistry;
+  request?: Request;
+  signal?: AbortSignal;
+  mode?: 'ssr' | 'spa';
+  telemetry?: CoreTelemetry;
+}): QueryPrefetchContext;
+declare function prefetchQuery<TInput, TResult extends {}>(context: QueryPrefetchContext, query: QueryDefinition<TInput, TResult>, input: TInput): Promise<boolean>;
+declare function dehydrateDataRuntime(runtime: DataRuntime): Record<string, unknown>;
+declare function hydrateDataRuntime(runtime: DataRuntime, data: unknown): void;
+//#endregion
+export { ServerQueryHandler as A, Query as C, QueryPrefetchContext as D, QueryKeyPart as E, QueryScope as O, Mutation as S, QueryDefinition as T, createMutation as _, defineServerQueries as a, InvalidateOnIntervalOptions as b, prefetchQuery as c, invalidate as d, invalidateOnInterval as f, createQuery as g, getDefaultDataRuntime as h, defineQuery as i, QueryStaleReason as k, serveQuery as l, createDataRuntime as m, ServerQueryRegistry as n, dehydrateDataRuntime as o, queryScope as p, createQueryPrefetchContext as r, hydrateDataRuntime as s, ServerQueryEntry as t, CoreTelemetry as u, DataRuntime as v, QueryConsistency as w, InvalidateOptions as x, DataRuntimeOptions as y };

package/dist/index-BnU0NPwM.d.ts

@@ -0,0 +1,101 @@
+//#region src/foundations/utilities/event-types.d.ts
+interface DefaultPreventable {
+  defaultPrevented?: boolean;
+  preventDefault?: () => void;
+}
+interface PropagationStoppable {
+  stopPropagation?: () => void;
+}
+interface KeyboardLikeEvent extends DefaultPreventable, PropagationStoppable {
+  key: string;
+}
+interface PointerLikeEvent extends DefaultPreventable, PropagationStoppable {
+  target?: unknown;
+}
+interface FocusLikeEvent extends DefaultPreventable, PropagationStoppable {
+  relatedTarget?: unknown;
+}
+//#endregion
+//#region src/foundations/utilities/compose-handlers.d.ts
+/**
+ * composeHandlers
+ *
+ * Compose two event handlers into one. The first handler runs, and unless it
+ * calls `event.preventDefault()` (or sets `defaultPrevented`), the second
+ * handler runs. This prevents accidental clobbering of child handlers when
+ * injecting props.
+ *
+ * POLICY DECISIONS (LOCKED):
+ *
+ * 1. Execution Order
+ *    First handler runs before second (injected before base).
+ *    This allows injected handlers to prevent default behavior.
+ *
+ * 2. Default Prevention Check
+ *    By default, checks `defaultPrevented` on first argument.
+ *    Can be disabled via options.checkDefaultPrevented = false.
+ *
+ * 3. Undefined Handler Support
+ *    Undefined handlers are skipped (no-op). This simplifies usage
+ *    where handlers are optional.
+ *
+ * 4. Type Safety
+ *    Args are readonly to prevent mutation. Return type matches input.
+ */
+interface ComposeHandlersOptions {
+  /**
+   * When true (default), do not run the second handler if the first prevented default.
+   * When false, always run both handlers.
+   */
+  checkDefaultPrevented?: boolean;
+}
+declare function composeHandlers<A extends readonly unknown[]>(first?: (...args: A) => void, second?: (...args: A) => void, options?: ComposeHandlersOptions): (...args: A) => void;
+//#endregion
+//#region src/foundations/utilities/merge-props.d.ts
+declare function mergeProps<TBase extends object, TInjected extends object>(base: TBase, injected: TInjected): TInjected & TBase;
+//#endregion
+//#region src/foundations/utilities/aria.d.ts
+/**
+ * Tiny aria helpers
+ */
+declare function ariaDisabled(disabled?: boolean): {
+  'aria-disabled'?: 'true';
+};
+declare function ariaExpanded(expanded?: boolean): {
+  'aria-expanded'?: 'true' | 'false';
+};
+declare function ariaSelected(selected?: boolean): {
+  'aria-selected'?: 'true' | 'false';
+};
+//#endregion
+//#region src/foundations/utilities/use-id.d.ts
+interface FormatIdOptions {
+  /** Defaults to 'askr' */
+  prefix?: string;
+  /** Stable, caller-provided identity */
+  id: string | number;
+}
+/**
+ * formatId
+ *
+ * Formats a stable ID from a caller-provided identity.
+ * - Pure and deterministic (no time/randomness/global counters)
+ * - SSR-safe
+ *
+ * POLICY DECISIONS (LOCKED):
+ *
+ * 1. No Auto-Generation
+ *    Caller must provide the `id`. No random/sequential generation.
+ *    This ensures determinism and SSR safety.
+ *
+ * 2. Format Convention
+ *    IDs are formatted as `{prefix}-{id}`.
+ *    Default prefix is "askr".
+ *
+ * 3. Type Coercion
+ *    Numbers are coerced to strings via String().
+ *    This is deterministic and consistent.
+ */
+declare function formatId(options: FormatIdOptions): string;
+//#endregion
+export { ariaSelected as a, composeHandlers as c, KeyboardLikeEvent as d, PointerLikeEvent as f, ariaExpanded as i, DefaultPreventable as l, formatId as n, mergeProps as o, PropagationStoppable as p, ariaDisabled as r, ComposeHandlersOptions as s, FormatIdOptions as t, FocusLikeEvent as u };

package/dist/index-D73jgYx1.d.ts

@@ -0,0 +1,48 @@
+import { c as RenderableChild, l as VNode, t as ForEachSource } from "./control-BQvNVfAd.js";
+import { r as JSXElement } from "./jsx-CP0gmYwJ.js";
+
+//#region src/control/shared.d.ts
+type BoundaryChild = RenderableChild;
+//#endregion
+//#region src/control/for.d.ts
+type ForBaseProps<T> = {
+  each: ForEachSource<T>;
+  fallback?: BoundaryChild;
+  children: (item: T, index: () => number) => VNode;
+};
+type KeyedForProps<T, K extends string | number> = ForBaseProps<T> & {
+  by: (item: T, index: number) => K;
+  byIndex?: never;
+};
+type IndexedForProps<T> = ForBaseProps<T> & {
+  by?: never;
+  byIndex: true;
+};
+type ForProps<T, K extends string | number = string | number> = KeyedForProps<T, K> | IndexedForProps<T>;
+declare const For: <T, K extends string | number = string | number>(props: ForProps<T, K>) => JSXElement;
+//#endregion
+//#region src/control/show.d.ts
+type ShowSource<T> = T | (() => T);
+type Truthy<T> = T extends false | '' | 0 | 0n | null | undefined ? never : T;
+type ShowProps<T> = {
+  when: ShowSource<T>;
+  fallback?: BoundaryChild;
+  children: BoundaryChild | ((value: Truthy<T>) => BoundaryChild);
+};
+declare const Show: <T>(props: ShowProps<T>) => JSXElement;
+//#endregion
+//#region src/control/case.d.ts
+type MatchChild = BoundaryChild | (() => BoundaryChild);
+type MatchProps = {
+  key?: string | number | null;
+  when: unknown;
+  children: MatchChild;
+};
+type CaseProps = {
+  fallback?: BoundaryChild;
+  children?: unknown;
+};
+declare function Match(_props: MatchProps): null;
+declare const Case: (props: CaseProps) => JSXElement;
+//#endregion
+export { Show as a, ForProps as c, MatchProps as i, CaseProps as n, ShowProps as o, Match as r, For as s, Case as t };

package/dist/{runtime/runtime.d.ts → index-R2JJIbM-.d.ts}

@@ -1,7 +1,5 @@
-import { ComponentInstance } from "./component-internal.js";
-import { ReadableSource } from "./readable.js";
-import { Scheduler } from "./scheduler.js";
-
+import { n as ReadableSource, r as ComponentInstance } from "./control-BQvNVfAd.js";
+import { t as Scheduler } from "./scheduler-CmLO4Dfm.js";
 //#region src/runtime/runtime.d.ts
 interface RuntimeKeyedReorderDecision {
   useFastPath: boolean;
@@ -16,7 +14,7 @@ interface RuntimeKeyedReorderDecision {
 interface RuntimeRendererHost {
   evaluate(node: unknown, target: Element | null, context?: object, retainedOwner?: ComponentInstance): void;
   cleanupInstancesUnder(node: Node): void;
-  teardownNodeSubtree(root: Element): void;
+  teardownNodeSubtree(root: Node): void;
   populateKeyMapForElement(parent: Element): void;
   getKeyMapForElement(parent: Element): Map<string | number, Element> | undefined;
   isKeyedReorderFastPathEligible(parent: Element, children: unknown[], oldKeyMap: Map<string | number, Element> | undefined): RuntimeKeyedReorderDecision;
@@ -33,10 +31,34 @@ declare class AskrRuntime {
   get renderer(): RuntimeRendererHost;
   configureRenderer(renderer: RuntimeRendererHost): void;
 }
-declare const defaultRuntime: AskrRuntime;
 declare function createRuntime(options?: AskrRuntimeOptions): AskrRuntime;
 declare function getDefaultRuntime(): AskrRuntime;
-declare function configureRuntimeRenderer(renderer: RuntimeRendererHost, runtime?: AskrRuntime): void;
 //#endregion
-export { AskrRuntime, AskrRuntimeOptions, RuntimeKeyedReorderDecision, RuntimeRendererHost, createRuntime, getDefaultRuntime };
-//# sourceMappingURL=runtime.d.ts.map
+//#region src/runtime/snapshot-source.d.ts
+declare const SNAPSHOT_SOURCE_BRAND: unique symbol;
+type SnapshotSourceBrand = {
+  readonly [SNAPSHOT_SOURCE_BRAND]: true;
+};
+//#endregion
+//#region src/runtime/derive.d.ts
+interface Derived<T> extends ReadableSource<T> {
+  (): T;
+}
+type SnapshotSource<T> = {
+  value: T | null;
+  pending?: boolean;
+  error?: Error | null;
+} & SnapshotSourceBrand;
+declare function derive<TOut>(fn: () => TOut): Derived<TOut>;
+declare function derive<TIn, TOut>(source: SnapshotSource<TIn> | TIn | (() => TIn), map: (value: TIn) => TOut): Derived<TOut | null>;
+//#endregion
+//#region src/runtime/selector.d.ts
+interface Selector<T> {
+  (candidate: T): boolean;
+}
+type SelectorEquals<T> = {
+  bivarianceHack(a: T, b: T): boolean;
+}['bivarianceHack'];
+declare function selector<T>(source: () => T, equals?: SelectorEquals<T>): Selector<T>;
+//#endregion
+export { AskrRuntime as a, RuntimeRendererHost as c, derive as i, createRuntime as l, selector as n, AskrRuntimeOptions as o, Derived as r, RuntimeKeyedReorderDecision as s, Selector as t, getDefaultRuntime as u };