@askrjs/askr 0.0.90 → 0.0.92

package/dist/index-DA3g8lm8.d.ts

@@ -0,0 +1,955 @@
+import { i as JSXElementType, r as JSXElement, s as Props } from "./types-BA9FJtfR.js";
+import { O as QueryPrefetchContext, _ as CoreTelemetry, v as DataRuntime } from "./index-2bk8nldG.js";
+import { t as Scheduler } from "./scheduler-CmLO4Dfm.js";
+import "./jsx-runtime-C_0v1pMN.js";
+import { AuthContext, AuthRequirement } from "@askrjs/auth";
+import { InferSchema, ObjectSchema } from "@askrjs/schema";
+//#region src/runtime/state.d.ts
+/**
+ * State value holder - callable to read, has set method to update
+ * @example
+ * const count = state(0);
+ * count();           // read: 0
+ * count.set(1);      // write: triggers re-render
+ */
+interface State<T> extends ReadableSource<T> {
+  (): T;
+  set(...args: StateSetterArgs<T>): void;
+  [Symbol.iterator](): IterableIterator<StateTuple<T>[number]>;
+}
+type StateUpdater<T> = (prev: T) => T;
+type StateSetterArgs<T> = [Extract<T, (...args: any[]) => unknown>] extends [never] ? [value: T] | [updater: StateUpdater<T>] : [updater: StateUpdater<T>];
+/**
+ * Public setter type for state cells.
+ */
+type StateSetter<T> = (...args: StateSetterArgs<T>) => void;
+/**
+ * Tuple-first state handle returned by `state()`.
+ */
+type StateTuple<T> = [get: State<T>, set: StateSetter<T>] & State<T>;
+/**
+ * Creates a local state value for a component
+ * Optimized for:
+ * - O(1) read performance
+ * - Minimal allocation per state
+ * - Fast scheduler integration
+ *
+ * IMPORTANT: state() must be called during component render execution.
+ * It captures the current component instance from context.
+ * Calling outside a component function will throw an error.
+ *
+ * @example
+ * ```ts
+ * // ✅ Correct: called during render
+ * export function Counter() {
+ *   const [count, setCount] = state(0);
+ *   return { type: 'button', children: [count()] };
+ * }
+ *
+ * // ❌ Wrong: called outside component
+ * const count = state(0);
+ * export function BadComponent() {
+ *   return { type: 'div' };
+ * }
+ * ```
+ */
+declare function state<T>(initialValue: T): StateTuple<T>;
+//#endregion
+//#region src/common/ssr.d.ts
+/**
+ * Common call contracts: SSR types
+ */
+type SSRData = Record<string, unknown>;
+/** Styles produced while rendering a request, kept with that request's SSR context. */
+interface SSRStyleRegistration {
+  id: string;
+  cssText: string;
+}
+interface DocumentRenderRoute {
+  path: string;
+  namespace?: string;
+}
+interface DocumentRenderContext {
+  mode: 'ssr' | 'ssg';
+  url: string;
+  pathname: string;
+  search: string;
+  hash: string;
+  params: Record<string, string>;
+  data?: SSRData;
+  seed: number;
+  route: DocumentRenderRoute;
+  cspNonce?: string;
+  styles?: readonly SSRStyleRegistration[];
+}
+interface DocumentRenderArgs {
+  appHtml: string;
+  context: DocumentRenderContext;
+}
+type DocumentRenderer = (args: DocumentRenderArgs) => string;
+type SSRStyleRegistrationValidation = 'warn' | 'error' | 'off';
+/** Full context for sink-based streaming SSR */
+type SSRContext = {
+  url: string;
+  seed: number;
+  data?: SSRData;
+  params?: Record<string, string>;
+  signal?: AbortSignal;
+};
+//#endregion
+//#region src/common/vnode.d.ts
+interface DOMElement {
+  type: JSXElementType;
+  props?: Props;
+  children?: VNode[];
+  key?: string | number | null;
+  [Symbol.iterator]?: never;
+  _controlState?: ControlBoundaryState;
+}
+type VNode = DOMElement | string | number | boolean | null | undefined;
+type RenderableChild = VNode | JSXElement | readonly RenderableChild[];
+//#endregion
+//#region src/common/component.d.ts
+type ComponentContext = {
+  signal: AbortSignal;
+  ssr?: SSRContext;
+};
+type ComponentFunction = (props: Props, context?: ComponentContext) => JSXElement | VNode;
+//#endregion
+//#region src/runtime/context.d.ts
+type ContextKey = symbol;
+type Renderable = RenderableChild;
+type ContextScopeChildren = Renderable | (() => Renderable);
+interface Scope<T> {
+  (props: {
+    value: T;
+    children?: ContextScopeChildren;
+  }): JSXElement;
+  readonly key: ContextKey;
+  readonly defaultValue: T;
+}
+interface ContextFrame {
+  parent: ContextFrame | null;
+  values: Map<ContextKey, unknown> | null;
+}
+declare function defineScope<T>(defaultValue: T): Scope<T>;
+declare function readScope<T>(context: Scope<T>): T;
+//#endregion
+//#region src/runtime/component-cleanup.d.ts
+type OwnedChildScope = {
+  key: string | number;
+  dispose(): void;
+};
+//#endregion
+//#region src/common/router.d.ts
+/**
+ * Common call contracts: Router types
+ */
+type RouteParams = Record<string, string>;
+type StripRoutePathSuffix<Path extends string> = Path extends `${infer Base}?${string}` ? StripRoutePathSuffix<Base> : Path extends `${infer Base}#${string}` ? StripRoutePathSuffix<Base> : Path;
+type TrimRoutePathSlashes<Path extends string> = Path extends `/${infer Rest}` ? TrimRoutePathSlashes<Rest> : Path extends `${infer Rest}/` ? TrimRoutePathSlashes<Rest> : Path;
+type TrimRoutePathWhitespace<Path extends string> = Path extends `${' ' | '\n' | '\t' | '\r'}${infer Rest}` ? TrimRoutePathWhitespace<Rest> : Path extends `${infer Rest}${' ' | '\n' | '\t' | '\r'}` ? TrimRoutePathWhitespace<Rest> : Path;
+type ExtractRouteSegmentParam<Segment extends string> = Segment extends `{${infer Param}}` ? TrimRoutePathWhitespace<Param> extends `*${infer SplatParam}` ? TrimRoutePathWhitespace<SplatParam> extends '' ? never : TrimRoutePathWhitespace<SplatParam> extends '*' ? never : TrimRoutePathWhitespace<SplatParam> : TrimRoutePathWhitespace<Param> extends '' ? never : TrimRoutePathWhitespace<Param> : Segment extends '*' ? '*' : never;
+type ExtractRoutePathParamNames<Path extends string> = TrimRoutePathSlashes<StripRoutePathSuffix<Path>> extends `${infer Segment}/${infer Rest}` ? ExtractRouteSegmentParam<Segment> | ExtractRoutePathParamNames<Rest> : ExtractRouteSegmentParam<TrimRoutePathSlashes<StripRoutePathSuffix<Path>>>;
+type RoutePathParams<Path extends string> = [ExtractRoutePathParamNames<Path>] extends [never] ? Record<never, string> : { [Key in ExtractRoutePathParamNames<Path>]: string; };
+/**
+ * A route page component: a regular component that receives route params as
+ * props derived from the URL pattern.
+ *
+ * Components may accept no params at all — zero-argument components are still
+ * assignable.
+ */
+type RouteComponent<TParams extends RouteParams = RouteParams> = (props: TParams) => RenderableChild;
+type RouteMode = 'spa' | 'ssr' | 'ssg';
+type AccessRedirectStatus = 301 | 302 | 303 | 307 | 308;
+type AccessDenyStatus = 401 | 403 | 404;
+interface AccessAllowDecision {
+  kind: 'allow';
+}
+interface AccessRedirectDecision {
+  kind: 'redirect';
+  to: string;
+  status?: AccessRedirectStatus;
+  replace?: boolean;
+}
+interface AccessDenyDecision {
+  kind: 'deny';
+  status: AccessDenyStatus;
+}
+type AccessDecision = AccessAllowDecision | AccessRedirectDecision | AccessDenyDecision;
+interface RouteContext<TParams extends RouteParams = RouteParams> {
+  mode: RouteMode;
+  params: TParams;
+  pathname: string;
+  search: string;
+  hash: string;
+  href: string;
+  auth: AuthContext;
+  signal: AbortSignal;
+}
+type RoutePolicy = (context: RouteContext) => AccessDecision | PromiseLike<AccessDecision>;
+type RouteAuthResolver = (context: Omit<RouteContext, 'auth'>) => AuthContext | PromiseLike<AuthContext>;
+interface RouteAuthOptions {
+  resolve: RouteAuthResolver;
+  loginPath?: string | ((context: RouteContext) => string | PromiseLike<string>);
+  authenticatedRedirectTo?: string | ((context: RouteContext) => string | PromiseLike<string>);
+}
+interface CommonAccessOptions {
+  auth?: AuthRequirement;
+  policies?: readonly RoutePolicy[];
+}
+type RouteMetaSource<TParams extends RouteParams = RouteParams> = RouteMeta | ((context: RouteContext<TParams>) => RouteMeta | PromiseLike<RouteMeta>);
+/**
+ * Options for `route()` declarations.
+ *
+ * - `loader`: server data loader called before render, result passed as SSR data
+ * - `entries`: SSG entry generator — returns one param map per static page
+ * - `title`: page title hint used by SSG and document-meta integrations
+ * - `namespace`: MFE namespace key for grouped route management
+ */
+interface RouteOptions<TParams extends RouteParams = RouteParams, TSearchSchema extends ObjectSchema<RouteSearch> | undefined = ObjectSchema<RouteSearch> | undefined, TLoaderData = unknown, TDehydratedData = TLoaderData> extends CommonAccessOptions {
+  loader?: (context: RouteContext<TParams> & {
+    request?: Request;
+  }) => TLoaderData | PromiseLike<TLoaderData>;
+  /**
+   * Select the loader data transported to the browser for initial hydration.
+   *
+   * Server rendering still receives the complete loader value. The selector
+   * must be synchronous; client navigations rerun the loader and receive its
+   * complete result.
+   */
+  dehydrate?: (data: TLoaderData, context: RouteContext<TParams> & {
+    request?: Request;
+  }) => TDehydratedData extends PromiseLike<unknown> ? never : TDehydratedData;
+  preload?: (context: RouteContext<TParams> & {
+    request?: Request;
+    data: QueryPrefetchContext;
+  }) => unknown;
+  entries?: () => Array<TParams> | Promise<Array<TParams>>;
+  /** Optional invalidation keys used by incremental SSG generation. */
+  invalidationKeys?: readonly string[];
+  title?: string;
+  namespace?: string;
+  search?: TSearchSchema;
+  meta?: RouteMetaSource<TParams>;
+  actions?: readonly ActionDescriptor[];
+}
+interface RouteMeta {
+  title?: string;
+  description?: string;
+  canonical?: string;
+  robots?: string;
+  openGraph?: Record<string, string>;
+  links?: readonly {
+    rel: string;
+    href: string;
+    [key: string]: string;
+  }[];
+  jsonLd?: unknown | readonly unknown[];
+  html?: {
+    lang?: string;
+    dir?: 'ltr' | 'rtl' | 'auto';
+  };
+}
+/** A stable, typed reference returned by route() for destination construction. */
+type RouteSearchValue = string | number | boolean | null | undefined | readonly (string | number | boolean | null)[];
+type RouteSearch = Record<string, RouteSearchValue>;
+interface RouteRef<TParams extends RouteParams = RouteParams, TSearch = RouteSearch> {
+  readonly path: string;
+  /** @internal Executable schema retained for destination validation. */
+  readonly searchSchema?: ObjectSchema<TSearch & RouteSearch>;
+  /** @internal Public mount point captured by createRouteRegistry(). */
+  readonly basePath?: string;
+  readonly __params?: TParams;
+  readonly __search?: TSearch;
+}
+type RouteRefSearch<TSchema extends ObjectSchema<RouteSearch> | undefined> = TSchema extends ObjectSchema<RouteSearch> ? InferSchema<TSchema> : RouteSearch;
+interface RouteDestination {
+  readonly href: string;
+}
+interface PageHelperOptions extends CommonAccessOptions {
+  preload?: (context: RouteContext & {
+    request?: Request;
+    data: QueryPrefetchContext;
+  }) => unknown;
+  meta?: RouteMetaSource;
+}
+/**
+ * A single parsed segment from a route path.
+ *
+ * - `static`:   a literal path segment, e.g. `"users"` in `/users/{id}`
+ * - `param`:    a `{name}` capture group — `value` holds the param name
+ * - `wildcard`: a bare `*` segment that captures exactly one segment
+ * - `splat`:    a `{*name}` capture group that captures the remaining path
+ * - `catchall`: the `/*` catch-all that matches any depth
+ */
+interface ParsedSegment {
+  kind: 'static' | 'param' | 'wildcard' | 'splat' | 'catchall';
+  /** For static/wildcard/catchall: the literal text; for param: the param name. */
+  value: string;
+}
+/** Resolved layout component as stored in a route record's layout chain. */
+interface LayoutScopeRecord {
+  component: (props: {
+    children?: RenderableChild;
+  }) => RenderableChild;
+}
+/** Resolved page host component as stored in a route record's page chain. */
+interface PageScopeRecord {
+  component: RouteComponent;
+}
+interface RouteRegistryOptions {
+  auth?: RouteAuthOptions;
+  /** Public pathname prefix for applications mounted below the origin root. */
+  basePath?: string;
+}
+type RouteDefinition = () => void;
+interface RouteRequestOptions {
+  /** Explicit route source shared by the application renderers. */
+  registry: RouteRegistry;
+  mode?: RouteMode;
+  /** @internal Hydration adopts server loader data instead of rerunning it. */
+  load?: boolean;
+  auth?: RouteAuthOptions;
+  authContext?: AuthContext;
+  signal?: AbortSignal;
+  request?: Request;
+  telemetry?: CoreTelemetry;
+}
+interface RouteRenderResult<TParams extends RouteParams = RouteParams> {
+  kind: 'render';
+  handler: RouteHandler<TParams>;
+  params: TParams;
+  record?: RouteRecord;
+}
+type RouteRequestResult<TParams extends RouteParams = RouteParams> = RouteRenderResult<TParams> | AccessRedirectDecision | AccessDenyDecision | null;
+interface GroupHelperOptions extends CommonAccessOptions {
+  layout?: (props: {
+    children?: RenderableChild;
+  }) => RenderableChild;
+  meta?: RouteMetaSource;
+}
+/**
+ * A fully normalized route record produced by `route(path, Component, options?)`.
+ *
+ * This is the canonical representation shared by:
+ *   - SPA matching and navigation
+ *   - SSR request resolution
+ *   - SSG manifest expansion
+ */
+interface RouteRecord {
+  /** Canonical normalized absolute path, e.g. `/posts/{slug}` */
+  path: string;
+  /** The page component to render when this route is active */
+  component: RouteComponent;
+  /** Pre-parsed segment list for fast matching and typed param extraction */
+  segments: ParsedSegment[];
+  /** Pre-computed specificity rank (higher = more specific) */
+  rank: number;
+  /** Layout chain from outermost to innermost, applied automatically on render */
+  layoutChain: LayoutScopeRecord[];
+  /** Page chain from outermost to innermost, composed through Outlet before layouts apply */
+  pageChain: PageScopeRecord[];
+  /** Route metadata: loader, entries, policies, title, namespace */
+  options: RouteOptions;
+  /** Metadata sources ordered from outermost group/page to the route leaf. */
+  metaChain?: readonly RouteMetaSource[];
+  /** True when this is the `/*` catch-all fallback route */
+  isFallback: boolean;
+  /**
+   * Runtime-ready handler with layout composition baked in.
+   * Compatible with the low-level `RouteHandler` signature so that navigation
+   * and SSR rendering do not need to know about layout chains.
+   */
+  handler: RouteHandler;
+}
+/**
+ * The normalized route manifest produced by registered route definitions.
+ * declarations.  Pass it to `createSPA`, `hydrateSPA`, or `renderToString`
+ * instead of assembling plain `Route[]` arrays.
+ *
+ * ```ts
+ * import { createRouteRegistry } from '@askrjs/askr/router';
+ * const registry = createRouteRegistry(() => { ... });
+ * await createSPA({ root: '#app', registry });
+ * ```
+ */
+interface RouteManifest {
+  records: RouteRecord[];
+  auth?: RouteAuthOptions;
+  /** Normalized public pathname prefix. Empty and root mounts omit it. */
+  basePath?: string;
+}
+declare const routeRegistryBrand: unique symbol;
+interface RouteHandler<TParams extends RouteParams = RouteParams> {
+  (params: TParams, context?: {
+    signal: AbortSignal;
+  }): RenderableChild;
+}
+interface Route<TParams extends RouteParams = RouteParams> {
+  path: string;
+  handler: RouteHandler<TParams>;
+  namespace?: string;
+}
+interface RouteRegistry {
+  /** Internal brand: registries must come from createRouteRegistry(). */
+  readonly [routeRegistryBrand]: true;
+  manifest: RouteManifest;
+  routes: readonly Route[];
+}
+interface RouteMatch<TParams extends RouteParams = RouteParams> {
+  path: string;
+  params: Readonly<TParams>;
+  name?: string;
+  namespace?: string;
+}
+interface RouteQuery {
+  get(key: string): string | null;
+  getAll(key: string): string[];
+  has(key: string): boolean;
+  toJSON(): Record<string, string | string[]>;
+}
+interface RouteSnapshot<TParams extends RouteParams = RouteParams> {
+  path: string;
+  params: Readonly<TParams>;
+  query: Readonly<RouteQuery>;
+  hash: string | null;
+  name?: string;
+  namespace?: string;
+  matches: readonly RouteMatch<TParams>[];
+}
+//#endregion
+//#region src/common/app-render-runtime.d.ts
+interface AppRenderRuntime {
+  framework: Readonly<Record<string, unknown>>;
+  route: unknown;
+  hasRoute: boolean;
+  dataRuntime?: DataRuntime;
+  routeRegistry?: RouteRegistry;
+  routeAuth?: RouteAuthOptions;
+}
+//#endregion
+//#region src/runtime/component-internal.d.ts
+interface ComponentInstance {
+  id: string;
+  fn: ComponentFunction;
+  props: Props;
+  target: Element | null;
+  parentInstance: ComponentInstance | null;
+  portalScope: object | null;
+  mounted: boolean;
+  abortController: AbortController | null;
+  ssr?: boolean;
+  cleanupStrict?: boolean;
+  /** @internal Private resource-ownership identity for the active mount. */
+  _ownershipGeneration: object;
+  stateValues?: State<unknown>[];
+  evaluationGeneration: number;
+  notifyUpdate: (() => void) | null;
+  _pendingFlushTask?: () => void;
+  _pendingRunTask?: () => void;
+  _enqueueRun?: () => void;
+  stateIndexCheck: number;
+  expectedStateIndices?: number[];
+  firstRenderComplete: boolean;
+  mountOperations?: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
+  commitOperations?: Array<() => void | (() => void) | PromiseLike<void | (() => void)>>;
+  cleanupFns?: Array<() => void>;
+  lifecycleSlots?: unknown[];
+  lifecycleGeneration: number;
+  hasPendingUpdate: boolean;
+  ownerFrame: ContextFrame | null;
+  isRoot?: boolean;
+  _rootComponentFn?: ComponentFunction;
+  /** @internal Browser-owned hydration and route state for this app root. */
+  _appRenderRuntime?: AppRenderRuntime;
+  /** @internal CSP nonce retained across browser route navigation. */
+  _cspNonce?: string;
+  _vnodeOwner?: object;
+  _vnodeParent?: ComponentInstance | null;
+  _vnodeParentGeneration?: object;
+  _vnodeKey?: string | number;
+  _vnodePosition?: number;
+  _wrapperDepth?: number;
+  _currentRenderToken?: number;
+  lastRenderToken?: number;
+  _pendingReadSources?: Set<ReadableSource<unknown>>;
+  _pendingReadSourceVersions?: Map<ReadableSource<unknown>, number>;
+  _lastReadSources?: Set<ReadableSource<unknown>>;
+  devWarningsEmitted?: Set<string>;
+  _placeholder?: Comment;
+  _ownedChildScopes?: Set<OwnedChildScope>;
+  errorBoundaryState?: {
+    error: unknown | null;
+    resetKey: unknown;
+    notified: boolean;
+  };
+}
+//#endregion
+//#region src/runtime/component-scope.d.ts
+/**
+ * Get the abort signal for the current component.
+ *
+ * The signal is guaranteed to be aborted when:
+ * - Component unmounts
+ * - Navigation occurs (different route)
+ * - Parent is destroyed
+ */
+declare function getSignal(): AbortSignal;
+//#endregion
+//#region src/runtime/readable.d.ts
+interface DerivedSubscriber {
+  _markDirty(): void;
+  _pendingDependencySources?: Set<ReadableSource<unknown>>;
+}
+interface ReadableSource<T = unknown> {
+  (): T;
+  _hasBeenRead?: boolean;
+  _hasEverBeenRead?: boolean;
+  _readers?: Map<ComponentInstance, {
+    token: number;
+    generation: object;
+  }>;
+  _derivedSubscribers?: Set<DerivedSubscriber>;
+  _version?: number;
+}
+//#endregion
+//#region src/common/dom-range.d.ts
+/**
+ * Internal DOM range shape shared by runtime ownership records and the
+ * renderer. A singleton range uses the node itself for both anchors; a
+ * multi-node or empty range uses deterministic comment anchors.
+ */
+interface DOMRange {
+  start: Node;
+  end: Node;
+  single: boolean;
+}
+//#endregion
+//#region src/runtime/child-scope.d.ts
+interface ChildScope {
+  key: string | number;
+  componentInstance: ComponentInstance;
+  previousVnode: VNode | undefined;
+  vnode: VNode | undefined;
+  dom?: Node;
+  /** @internal Fast singleton node plus an anchor-backed multi-node range. */
+  range?: DOMRange;
+  needsDomUpdate: boolean;
+  hydrationPending: boolean;
+  /** @internal Stable owner for validated intrinsic blueprints in list items. */
+  blueprintOwner?: object;
+  render(renderFn: () => VNode): VNode;
+  markDirty(): void;
+  dispose(): void;
+}
+interface ChildScopeOwnership {
+  add(scope: ChildScope): void;
+  delete(scope: ChildScope): void;
+  bulkDispose(run: () => void): void;
+}
+/** @internal Snapshot used to restore a child scope after a failed commit. */
+interface ChildScopeTransactionSnapshot {
+  previousVnode: VNode | undefined;
+  vnode: VNode | undefined;
+  dom: Node | undefined;
+  range: DOMRange | undefined;
+  domTextData: string | undefined;
+  needsDomUpdate: boolean;
+  hydrationPending: boolean;
+  renderFn: (() => VNode) | undefined;
+  renderedOwnerFrame: ContextFrame | null;
+}
+//#endregion
+//#region src/runtime/runtime.d.ts
+interface RuntimeKeyedReorderDecision {
+  useFastPath: boolean;
+  totalKeyed: number;
+  totalChildren: number;
+  currentKeyCount: number;
+  moveCount: number;
+  lisLen: number;
+  hasPropChanges: boolean;
+  isWholeKeyedList: boolean;
+}
+interface RuntimeRendererHost {
+  evaluate(node: unknown, target: Element | null, context?: object, retainedOwner?: ComponentInstance): void;
+  cleanupInstancesUnder(node: Node): void;
+  replaceComponentRange(instance: ComponentInstance, result: unknown, host: Element | Comment): Node | null;
+  resolveChildScopeRange?(scope: ChildScope): DOMRange | null;
+  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;
+  markReactivePropsDirtySource(source: ReadableSource<unknown>): void;
+}
+interface AskrRuntimeOptions {
+  scheduler?: Scheduler;
+  renderer?: RuntimeRendererHost;
+}
+declare class AskrRuntime {
+  readonly scheduler: Scheduler;
+  private rendererHost;
+  constructor(options?: AskrRuntimeOptions);
+  get renderer(): RuntimeRendererHost;
+  configureRenderer(renderer: RuntimeRendererHost): void;
+}
+declare function createRuntime(options?: AskrRuntimeOptions): AskrRuntime;
+declare function getDefaultRuntime(): AskrRuntime;
+//#endregion
+//#region src/runtime/for-signals.d.ts
+type ForItemSignal<T> = ReadableSource<T> & (() => T) & {
+  peek(): T;
+  set(newValue: T, notifyReaders?: boolean): void;
+};
+type ForItemPropertySignal = ReadableSource<unknown> & (() => unknown) & {
+  peek(): unknown;
+  set(newValue: unknown, notifyReaders?: boolean): void;
+};
+type ForIndexSignal = ReadableSource<number> & (() => number) & {
+  peek(): number;
+  set(newValue: number | ((prev: number) => number), notifyReaders?: boolean): void;
+};
+interface ReactiveForItemState<T> {
+  currentItem: T;
+  itemSignal: ForItemSignal<T> | null;
+  propertySignals: Map<PropertyKey, ForItemPropertySignal> | null;
+  coalescedProperties: PropertyKey | PropertyKey[] | null;
+  coalescedProperty2: PropertyKey | null;
+  wholeItemRead: boolean;
+  proxy: T;
+}
+//#endregion
+//#region src/runtime/for-scopes.d.ts
+interface ForItemInstance<T> {
+  key: string | number;
+  item: T;
+  reactiveItem: T;
+  reactiveItemState: ReactiveForItemState<T> | null;
+  indexSignal: ForIndexSignal;
+  scope: ChildScope;
+}
+//#endregion
+//#region src/runtime/effect.d.ts
+interface FineGrainedEffectHandle<T> {
+  cleanup(): void;
+  updateCompute(nextCompute: () => T): void;
+  flush(): void;
+}
+//#endregion
+//#region src/runtime/for-types.d.ts
+type ForEachSource<T> = readonly T[] | (() => readonly T[]);
+type ForKeySelector<T> = (item: T, index: number) => string | number;
+type ForRenderItem<T> = (item: T, index: () => number) => VNode;
+//#endregion
+//#region src/runtime/for-internal.d.ts
+type ForCommitStrategy = 'APPEND' | 'INSERT_ONE' | 'REMOVE_ONE' | 'TRUNCATE' | 'NO_REORDER' | 'SWAP' | 'FULL_KEYED';
+interface ForState<T> {
+  kind: 'for';
+  _contextFrame: ContextFrame | null;
+  _contextFrameChanged: boolean;
+  currentItems: readonly T[];
+  _committedItems: readonly T[];
+  eachSource: ForEachSource<T>;
+  fallback: VNode | null;
+  fallbackScope: ChildScope | null;
+  items: Map<string | number, ForItemInstance<T>>;
+  orderedKeys: Array<string | number>;
+  orderedItems: ForItemInstance<T>[];
+  orderedVNodes: VNode[];
+  byFn: ForKeySelector<T>;
+  renderFn: ForRenderItem<T>;
+  parentInstance: ComponentInstance | null;
+  lastCommitStrategy: ForCommitStrategy;
+  lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
+  pendingDirtyIndices: number[] | null;
+  pendingSwapIndices: [number, number] | null;
+  pendingMoveOnly: boolean;
+  pendingInsertedIndex: number | null;
+  pendingRemovedKey: string | number | null;
+  pendingAppendStart: number | null;
+  _hasResolvedItemDom: boolean;
+  _needsSourceReconcile: boolean;
+  _sourceEffect: FineGrainedEffectHandle<readonly T[]> | null;
+  _suspendSourceCommit: boolean;
+  _enqueueBoundaryCommit?: (() => void) | null;
+  _hasPendingBoundaryCommit?: boolean;
+  devKeyKinds?: Map<string | number, 'number' | 'string'>;
+  _transaction?: ForTransaction<T> | null;
+  _scopeOwnership: ChildScopeOwnership;
+}
+interface ForItemTransactionSnapshot<T> {
+  item: T;
+  itemSignalExists: boolean;
+  itemSignalValue: T | undefined;
+  itemSignalHasBeenRead: boolean;
+  indexValue: number;
+  indexHasBeenRead: boolean;
+  propertySignalStore: Map<PropertyKey, ForItemPropertySignal> | null;
+  propertySignals: Map<PropertyKey, {
+    signal: ForItemPropertySignal;
+    value: unknown;
+    hasBeenRead: boolean;
+  }> | null;
+  scope: ChildScopeTransactionSnapshot;
+}
+interface ForTransaction<T> {
+  collectionSnapshotMode: 'copy' | 'reset-empty' | 'preserve-clear' | 'reuse';
+  currentItems: readonly T[];
+  items: Map<string | number, ForItemInstance<T>>;
+  orderedKeys: Array<string | number>;
+  orderedItems: ForItemInstance<T>[];
+  orderedVNodes: VNode[];
+  fallbackScope: ChildScope | null;
+  lastCommitStrategy: ForCommitStrategy;
+  lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
+  pendingDirtyIndices: number[] | null;
+  pendingSwapIndices: [number, number] | null;
+  pendingMoveOnly: boolean;
+  pendingInsertedIndex: number | null;
+  pendingRemovedKey: string | number | null;
+  pendingAppendStart: number | null;
+  hasResolvedItemDom: boolean;
+  needsSourceReconcile: boolean;
+  devKeyKinds?: Map<string | number, 'number' | 'string'>;
+  itemSnapshots: Map<ForItemInstance<T>, ForItemTransactionSnapshot<T>> | null;
+  unreadIndexSnapshots: Map<ForIndexSignal, number> | null;
+  fallbackScopeSnapshot: ChildScopeTransactionSnapshot | null;
+  removedScopes: ChildScope[] | null;
+  removedScopeNodes: Node[] | null;
+  removeAllItems: boolean;
+  signalEffects: Map<ReadableSource<unknown>, {
+    parentInstance: ComponentInstance | null;
+    notify: boolean;
+    skipInstance: ComponentInstance | null;
+    skipOwnedBy: ComponentInstance | null;
+  }> | null;
+  shouldClearDomUpdateState: boolean;
+}
+//#endregion
+//#region src/runtime/control.d.ts
+interface MatchBranch {
+  key: string | number;
+  render: () => VNode;
+  when: unknown;
+}
+interface BranchControlStateBase {
+  _contextFrame: ContextFrame | null;
+  activeKey: string | number | null;
+  activeScope: ChildScope | null;
+  activeVNodes: VNode[];
+  lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
+  parentInstance: ComponentInstance | null;
+  _enqueueBoundaryCommit?: (() => void) | null;
+  _hasPendingBoundaryCommit?: boolean;
+  _transaction?: ControlTransaction | null;
+}
+interface ShowState extends BranchControlStateBase {
+  kind: 'show';
+  fallbackScope: ChildScope | null;
+  renderFallback: (() => VNode) | null;
+  renderTruthy: ((value: unknown) => VNode) | (() => VNode);
+  selectedValue: unknown;
+  truthyScope: ChildScope | null;
+}
+interface CaseState extends BranchControlStateBase {
+  kind: 'case';
+  fallback: (() => VNode) | null;
+  matches: MatchBranch[];
+}
+type ControlBoundaryState = ForState<unknown> | ShowState | CaseState;
+type BranchStateSnapshot = {
+  activeKey: string | number | null;
+  activeScope: ChildScope | null;
+  activeVNodes: VNode[];
+  lastRemovedNodes: Node[];
+  lastRemovedRanges: DOMRange[];
+  scopeSnapshots: Map<ChildScope, ChildScopeTransactionSnapshot>;
+  fallbackScope?: ChildScope | null;
+  truthyScope?: ChildScope | null;
+};
+interface ControlTransaction {
+  state: ShowState | CaseState;
+  snapshot: BranchStateSnapshot;
+  removedScopes: ChildScope[];
+  shouldClearDomUpdateState: boolean;
+  registered: boolean;
+}
+//#endregion
+//#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;
+/** Creates a render-scoped derived value; must be called during component render. */
+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/render-diagnostics.d.ts
+interface RenderDiagnosticsOptions {
+  /** Emit one warning per component instance when a render exceeds the threshold. */
+  slowRenderWarnings?: boolean;
+  /** Slow-render threshold in milliseconds. The default is 5. */
+  slowRenderThresholdMs?: number;
+}
+/**
+ * Configure development render diagnostics and return a function that restores
+ * the previous configuration. Component counters and timing remain enabled
+ * when warning output is disabled.
+ */
+declare function configureRenderDiagnostics(options: RenderDiagnosticsOptions): () => void;
+//#endregion
+//#region src/runtime/selector.d.ts
+interface Selector<T> {
+  (candidate: T): boolean;
+}
+type SelectorEquals<T> = {
+  bivarianceHack(a: T, b: T): boolean;
+}['bivarianceHack'];
+/**
+ * Creates a render-scoped predicate for keyed membership in reactive list rows.
+ *
+ * Use this when a `<For>` child needs to compare each stable item with a
+ * changing selected value. Unlike a plain closure capture, the predicate
+ * subscribes the affected rows and updates them without rebuilding the list.
+ * Must be called during component render.
+ */
+declare function selector<T>(source: () => T, equals?: SelectorEquals<T>): Selector<T>;
+//#endregion
+//#region src/control/shared.d.ts
+type BoundaryChild = RenderableChild;
+//#endregion
+//#region src/control/for.d.ts
+type ForBaseProps<T> = {
+  each: ForEachSource<T>;
+  fallback?: BoundaryChild;
+  /**
+   * Row renderer. Parent reactive reads must use `selector()` or thunk props;
+   * closure-captured values are snapshotted when the row is created or
+   * reconciled; changing the parent source does not rerun an existing row.
+   */
+  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
+//#region src/csp-nonce.d.ts
+declare const CspNonceScope: Scope<string | undefined>;
+declare function cspNonce(): string | undefined;
+//#endregion
+//#region src/common/render-context.d.ts
+interface DeferredBoundaryRegistration {
+  id: string;
+  promise: Promise<unknown>;
+  fulfilled(value: unknown): RenderableChild;
+  rejected(error: unknown): RenderableChild;
+}
+interface SSRPortalHostRegistration {
+  token: string;
+  automatic: boolean;
+}
+interface SSRPortalSlot {
+  hasValue: boolean;
+  value: RenderableChild | undefined;
+  hosts: SSRPortalHostRegistration[];
+}
+interface SSRPortalState {
+  slots: Map<object, SSRPortalSlot>;
+  nextHostId: number;
+}
+/** Register request-local CSS produced during SSR without importing the SSR renderer in clients. */
+declare function registerSSRStyle(id: string, cssText: string): void;
+//#endregion
+//#region src/ref.d.ts
+/**
+ * Creates a stable holder for an intrinsic element ref.
+ *
+ * The renderer mutates `current` during commit and clears it during cleanup.
+ * Updating the holder never schedules a render.
+ */
+interface Ref<T extends Element = Element> {
+  current: T | null;
+}
+declare function createRef<T extends Element = Element>(): Ref<T>;
+//#endregion
+//#region src/actions/index.d.ts
+interface ActionDescriptor<TInput extends Record<string, unknown> = Record<string, unknown>> {
+  readonly id: string;
+  readonly input: ObjectSchema<TInput>;
+  readonly invalidates: readonly string[];
+}
+declare function defineAction<TInput extends Record<string, unknown>>(options: {
+  readonly id: string;
+  readonly input: ObjectSchema<TInput>;
+  readonly invalidates?: readonly string[];
+}): ActionDescriptor<TInput>;
+/** A native form bound to a declared action; it is not a synthetic event API. */
+declare function ActionForm<TInput extends Record<string, unknown>>({ action, children, ...props }: {
+  readonly action: ActionDescriptor<TInput>;
+  readonly children?: RenderableChild;
+  readonly [key: string]: unknown;
+}): JSXElement;
+interface ActionValidationError {
+  readonly kind: 'invalid';
+  readonly action: string;
+  readonly values: Readonly<Record<string, unknown>>;
+  readonly issues: readonly unknown[];
+  readonly fieldErrors: Readonly<Record<string, readonly string[]>>;
+}
+interface ActionStatus<TResult = unknown> {
+  readonly pending: boolean;
+  readonly result?: TResult;
+  readonly error?: unknown;
+}
+/** Returns a command handle, rather than a hook. */
+declare function action<TInput extends Record<string, unknown>, TResult = unknown>(descriptor: ActionDescriptor<TInput>): {
+  state: StateTuple<ActionStatus<TResult>>;
+  submit(input: TInput): Promise<TResult>;
+};
+//#endregion
+export { RouteHandler as $, RuntimeKeyedReorderDecision as A, SSRData as At, AccessRedirectStatus as B, selector as C, readScope as Ct, derive as D, DocumentRenderArgs as Dt, Derived as E, VNode as Et, AccessAllowDecision as F, StateTuple as Ft, ParsedSegment as G, LayoutScopeRecord as H, AccessDecision as I, state as It, RouteAuthResolver as J, Route as K, AccessDenyDecision as L, createRuntime as M, SSRStyleRegistrationValidation as Mt, getDefaultRuntime as N, State as Nt, AskrRuntime as O, DocumentRenderContext as Ot, getSignal as P, StateSetter as Pt, RouteDestination as Q, AccessDenyStatus as R, Selector as S, defineScope as St, configureRenderDiagnostics as T, RenderableChild as Tt, PageHelperOptions as U, GroupHelperOptions as V, PageScopeRecord as W, RouteContext as X, RouteComponent as Y, RouteDefinition as Z, MatchProps as _, RouteRequestResult as _t, action as a, RouteOptions as at, For as b, RouteSnapshot as bt, createRef as c, RoutePolicy as ct, registerSSRStyle as d, RouteRef as dt, RouteManifest as et, CspNonceScope as f, RouteRefSearch as ft, Match as g, RouteRequestOptions as gt, CaseProps as h, RouteRenderResult as ht, ActionValidationError as i, RouteMode as it, RuntimeRendererHost as j, SSRStyleRegistration as jt, AskrRuntimeOptions as k, DocumentRenderer as kt, DeferredBoundaryRegistration as l, RouteQuery as lt, Case as m, RouteRegistryOptions as mt, ActionForm as n, RouteMeta as nt, defineAction as o, RouteParams as ot, cspNonce as p, RouteRegistry as pt, RouteAuthOptions as q, ActionStatus as r, RouteMetaSource as rt, Ref as s, RoutePathParams as st, ActionDescriptor as t, RouteMatch as tt, SSRPortalState as u, RouteRecord as ut, Show as v, RouteSearch as vt, RenderDiagnosticsOptions as w, ComponentFunction as wt, ForProps as x, Scope as xt, ShowProps as y, RouteSearchValue as yt, AccessRedirectDecision as z };