@askrjs/askr 0.0.92 → 0.0.94

package/dist/testing/index.d.ts

@@ -1,6 +1,6 @@
-import { pt as RouteRegistry, q as RouteAuthOptions, tt as RouteMatch, wt as ComponentFunction } from "../index-DA3g8lm8.js";
-import { A as QueryStaleReason, S as Mutation, v as DataRuntime, w as Query } from "../index-2bk8nldG.js";
+import { At as RouteRegistry, Gt as Query, Ut as Mutation, Zt as QueryStaleReason, nn as ComponentFunction, ut as RouteAuthOptions, vt as RouteMatch, zt as DataRuntime } from "../index-KQ7Vl4-8.js";
 //#region src/testing/render.d.ts
+/** Options for {@link render} and {@link mount}. */
 interface RenderOptions {
   /**
    * Existing element to own for the duration of the render. When omitted, the
@@ -10,6 +10,7 @@ interface RenderOptions {
   /** Surface lifecycle cleanup errors during unmount. */
   cleanupStrict?: boolean;
 }
+/** Options for {@link renderRoute}. */
 interface RouteRenderOptions extends RenderOptions {
   registry: RouteRegistry;
   /** Initial path, query, and hash for the routed render. */
@@ -18,6 +19,7 @@ interface RouteRenderOptions extends RenderOptions {
   dataRuntime?: DataRuntime;
 }
 type DispatchEventInit = EventInit | UIEventInit | FocusEventInit | MouseEventInit | WheelEventInit | KeyboardEventInit | InputEventInit | CompositionEventInit | PointerEventInit | TouchEventInit | DragEventInit;
+/** Handle to a mounted test render, returned by {@link render}/{@link mount}/{@link renderRoute}. */
 interface RenderResult {
   readonly container: HTMLElement;
   readonly root: HTMLElement;
@@ -26,11 +28,17 @@ interface RenderResult {
   unmount(): void;
   cleanup(): void;
 }
+/** Synchronously flush the runtime's scheduled work (renders, effects). */
 declare function flush(): void;
+/** Dispatch an event (constructed from a type string, or given directly) on `target`. */
 declare function dispatch(target: EventTarget, event: Event | string, init?: DispatchEventInit): boolean;
+/** Tear down a test render, given either its {@link RenderResult} or container element. */
 declare function cleanup(target: RenderResult | HTMLElement): void;
+/** Mount `component` as an island into a test container and flush pending work. */
 declare function render(component: ComponentFunction, options?: RenderOptions): RenderResult;
+/** Alias for {@link render}. */
 declare function mount(component: ComponentFunction, options?: RenderOptions): RenderResult;
+/** Mount a routed app (via {@link createSPA}) into a test container for the given route registry. */
 declare function renderRoute(options: RouteRenderOptions): Promise<RenderResult>;
 //#endregion
 //#region src/testing/index.d.ts
@@ -40,6 +48,7 @@ declare function click(element: Element): boolean;
 declare function type(element: HTMLInputElement | HTMLTextAreaElement, text: string): void;
 /** Dispatch a cancelable bubbling submit event on a form. */
 declare function submit(form: HTMLFormElement): boolean;
+/** Keyed query fixture registry returned by {@link createQueryTestRegistry}. */
 interface QueryTestRegistry {
   readonly runtime: DataRuntime;
   set<T extends {}>(key: string, query: Query<T>): void;
@@ -48,6 +57,7 @@ interface QueryTestRegistry {
 }
 /** Create a keyed query fixture registry for a test render runtime. */
 declare function createQueryTestRegistry(): QueryTestRegistry;
+/** Keyed mutation fixture registry returned by {@link createMutationTestRegistry}. */
 interface MutationTestRegistry {
   readonly runtime: DataRuntime;
   set<TInput, TResult>(key: string, mutation: Mutation<TInput, TResult>): void;
@@ -56,11 +66,13 @@ interface MutationTestRegistry {
 }
 /** Create a keyed mutation fixture registry for a test render runtime. */
 declare function createMutationTestRegistry(): MutationTestRegistry;
+/** Initial state for {@link mutationState}; exactly one of `pending`/`error`/`result` may be set. */
 type MutationFixtureInitial<TResult> = {
   pending?: boolean;
   error?: {} | null;
   result?: TResult;
 };
+/** A {@link Mutation} whose state is driven manually via `setPending`/`succeed`/`fail`. */
 type MutationFixture<TInput, TResult> = Mutation<TInput, TResult> & {
   /** Inputs received by the fixture's execute method. */
   readonly inputs: readonly TInput[];
@@ -72,20 +84,28 @@ type MutationFixture<TInput, TResult> = Mutation<TInput, TResult> & {
   fail(error: {}): void;
 };
 declare function createMutationFixture<TInput = unknown, TResult = unknown>(initial?: MutationFixtureInitial<TResult>): MutationFixture<TInput, TResult>;
+/**
+ * Build a {@link MutationFixture} for tests: call directly with initial
+ * state, or use `.idle()`/`.pending()`/`.success(result)`/`.error(error)`.
+ */
 declare const mutationState: typeof createMutationFixture & {
   idle<TInput = unknown, TResult = unknown>(): MutationFixture<TInput, TResult>;
   pending<TInput = unknown, TResult = unknown>(): MutationFixture<TInput, TResult>;
   success<TInput = unknown, TResult = unknown>(result: TResult): MutationFixture<TInput, TResult>;
   error<TInput = unknown, TResult = unknown>(error: {}): MutationFixture<TInput, TResult>;
 };
+/** Refresh callback for a {@link mockQuery} fixture, invoked by the query's `refresh()`. */
 type MockRefresh = () => void | Promise<void>;
+/** Options for {@link mockQuery} fixtures. */
 interface MockQueryOptions {
   refresh?: MockRefresh;
 }
+/** A single recorded call to {@link invalidate}, captured by {@link createInvalidationRecorder}. */
 interface InvalidationRecord {
   prefix: string;
   markPendingWrite: boolean;
 }
+/** Recorder returned by {@link createInvalidationRecorder}. */
 interface InvalidationRecorder {
   readonly calls: readonly InvalidationRecord[];
   readonly prefixes: readonly string[];
@@ -95,6 +115,7 @@ interface InvalidationRecorder {
 interface MatchRouteOptions {
   registry: RouteRegistry;
 }
+/** A splat-route/static-route path collision reported by {@link getRouteWarnings}. */
 interface RoutePatternWarning {
   kind: 'route-collision';
   path: string;
@@ -105,6 +126,10 @@ interface RoutePatternWarning {
 }
 type StaleValueReason = Exclude<QueryStaleReason, 'error'>;
 declare function createFreshQuery<T extends {}>(data: T, options?: MockQueryOptions): Query<T>;
+/**
+ * Build a fresh {@link Query} fixture for tests: call directly with data, or
+ * use `.loading()`/`.error()`/`.refreshing()`/`.stale()`/`.pendingWrite()`.
+ */
 declare const mockQuery: typeof createFreshQuery & {
   loading<T extends {} = {}>(options?: MockQueryOptions): Query<T>;
   error<T extends {} = {}>(error: {}, previousData?: T, options?: MockQueryOptions): Query<T>;
@@ -112,6 +137,7 @@ declare const mockQuery: typeof createFreshQuery & {
   stale<T extends {}>(data: T, reason?: StaleValueReason, options?: MockQueryOptions): Query<T>;
   pendingWrite<T extends {}>(data: T, options?: MockQueryOptions): Query<T>;
 };
+/** Alias table mirroring {@link mockQuery}'s state builders (`fresh`, `loading`, `error`, ...). */
 declare const queryState: {
   fresh: typeof createFreshQuery;
   loading: <T extends {} = {}>(options?: MockQueryOptions) => Query<T>;
@@ -120,8 +146,11 @@ declare const queryState: {
   stale: <T extends {}>(data: T, reason?: StaleValueReason, options?: MockQueryOptions) => Query<T>;
   pendingWrite: <T extends {}>(data: T, options?: MockQueryOptions) => Query<T>;
 };
+/** Start recording {@link invalidate} calls for assertions; call `stop()` when done. */
 declare function createInvalidationRecorder(): InvalidationRecorder;
+/** Match `path` against a route registry for tests, without mounting the app. */
 declare function matchRoute(path: string, options: MatchRouteOptions): RouteMatch | null;
+/** Find named-splat routes whose reserved segments collide with sibling static routes. */
 declare function getRouteWarnings(options: MatchRouteOptions): RoutePatternWarning[];
 //#endregion
 export { InvalidationRecord, InvalidationRecorder, MockQueryOptions, MockRefresh, MutationFixture, MutationFixtureInitial, MutationTestRegistry, QueryTestRegistry, type RenderOptions, type RenderResult, RoutePatternWarning, type RouteRenderOptions, cleanup, click, createInvalidationRecorder, createMutationTestRegistry, createQueryTestRegistry, dispatch, flush, getRouteWarnings, matchRoute, mockQuery, mount, mutationState, queryState, render, renderRoute, submit, type };

package/dist/testing/index.js

@@ -1,9 +1,9 @@
-import { r as flushRuntimeScheduler } from "../access-DSkccuEI.js";
-import { u as recordReadableRead } from "../readable-B99wh5Z_.js";
-import { l as addInvalidationListener, t as createDataRuntime } from "../data-runtime-oIdQWnPW.js";
-import { a as notifySource, i as normalizeAsyncDataError, r as createReadableSource } from "../data-DcikEH9N.js";
+import { r as flushRuntimeScheduler } from "../access-d_DCdwqn.js";
+import { u as recordReadableRead } from "../readable-BsdGWsDE.js";
+import { l as addInvalidationListener, t as createDataRuntime } from "../data-runtime-JxoRgrrt.js";
+import { a as notifySource, i as normalizeAsyncDataError, r as createReadableSource } from "../data-DYqokZzc.js";
 import { r as computeRouteActivityMatches } from "../route-matching-Bo6UqG-5.js";
-import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-D71bjP4r.js";
+import { a as cleanupApp, r as createSPA, t as createIsland } from "../boot-BsMB_ySP.js";
 //#region src/testing/render.ts
 const renderStates = /* @__PURE__ */ new WeakMap();
 const eventConstructorNames = {
@@ -96,9 +96,11 @@ function isEventForTarget(target, value) {
 	if (value instanceof getBaseEventConstructor(target)) return true;
 	return typeof Event !== "undefined" && value instanceof Event;
 }
+/** Synchronously flush the runtime's scheduled work (renders, effects). */
 function flush() {
 	flushRuntimeScheduler();
 }
+/** Dispatch an event (constructed from a type string, or given directly) on `target`. */
 function dispatch(target, event, init = {}) {
 	if (!target || typeof target.dispatchEvent !== "function") throw new TypeError("@askrjs/askr/testing dispatch requires an EventTarget.");
 	if (typeof event !== "string" && !isEventForTarget(target, event)) throw new TypeError("@askrjs/askr/testing dispatch requires an Event instance or event type string.");
@@ -125,6 +127,7 @@ function cleanupContainer(container) {
 function isRenderResult(target) {
 	return "container" in target && "cleanup" in target;
 }
+/** Tear down a test render, given either its {@link RenderResult} or container element. */
 function cleanup(target) {
 	cleanupContainer(isRenderResult(target) ? target.container : target);
 }
@@ -138,6 +141,7 @@ function createRenderResult(container) {
 		cleanup: () => cleanupContainer(container)
 	};
 }
+/** Mount `component` as an island into a test container and flush pending work. */
 function render(component, options) {
 	if (typeof component !== "function") throw new TypeError("@askrjs/askr/testing render requires a component function.");
 	const { container } = prepareContainer(options);
@@ -154,9 +158,11 @@ function render(component, options) {
 		throw error;
 	}
 }
+/** Alias for {@link render}. */
 function mount(component, options) {
 	return render(component, options);
 }
+/** Mount a routed app (via {@link createSPA}) into a test container for the given route registry. */
 async function renderRoute(options) {
 	if (!options?.registry) throw new TypeError("@askrjs/askr/testing renderRoute requires a route registry.");
 	const currentWindow = requireWindow();
@@ -351,6 +357,10 @@ var MutableMutationFixture = class {
 function createMutationFixture(initial = {}) {
 	return new MutableMutationFixture(initial);
 }
+/**
+* Build a {@link MutationFixture} for tests: call directly with initial
+* state, or use `.idle()`/`.pending()`/`.success(result)`/`.error(error)`.
+*/
 const mutationState = Object.assign(createMutationFixture, {
 	idle() {
 		return createMutationFixture();
@@ -387,6 +397,10 @@ function createFreshQuery(data, options) {
 		staleReason: null
 	}, options);
 }
+/**
+* Build a fresh {@link Query} fixture for tests: call directly with data, or
+* use `.loading()`/`.error()`/`.refreshing()`/`.stale()`/`.pendingWrite()`.
+*/
 const mockQuery = Object.assign(createFreshQuery, {
 	loading(options) {
 		return makeQuery({
@@ -444,6 +458,7 @@ const mockQuery = Object.assign(createFreshQuery, {
 		}, options);
 	}
 });
+/** Alias table mirroring {@link mockQuery}'s state builders (`fresh`, `loading`, `error`, ...). */
 const queryState = {
 	fresh: createFreshQuery,
 	loading: mockQuery.loading,
@@ -452,6 +467,7 @@ const queryState = {
 	stale: mockQuery.stale,
 	pendingWrite: mockQuery.pendingWrite
 };
+/** Start recording {@link invalidate} calls for assertions; call `stop()` when done. */
 function createInvalidationRecorder() {
 	const records = [];
 	let active = true;
@@ -478,6 +494,7 @@ function createInvalidationRecorder() {
 		}
 	};
 }
+/** Match `path` against a route registry for tests, without mounting the app. */
 function matchRoute(path, options) {
 	if (!options?.registry) throw new TypeError("matchRoute requires options.registry.");
 	return computeRouteActivityMatches(path, { registry: options.registry })[0] ?? null;
@@ -499,6 +516,7 @@ function routePrefixMatches(splatPrefix, routeSegments) {
 	}
 	return true;
 }
+/** Find named-splat routes whose reserved segments collide with sibling static routes. */
 function getRouteWarnings(options) {
 	const records = getRoutePatternRecords(options);
 	const warnings = [];

package/dist/{types-BA9FJtfR.d.ts → types-DkVJhVs9.d.ts}

@@ -326,11 +326,15 @@ interface KnownIntrinsicElementProps {
 }
 //#endregion
 //#region src/common/jsx.d.ts
+/** The element type marker for JSX fragments (`<>...</>`), groups children without a wrapper element. */
 declare const Fragment: unique symbol;
+/** A component function accepting `TProps`, usable as a JSX element's `type`. */
 type JSXComponent<TProps extends object = Props> = {
   bivarianceHack(props: TProps): unknown;
 }['bivarianceHack'];
+/** Valid `type` values for a JSX element: a tag name, a component, or a symbol (e.g. `Fragment`). */
 type JSXElementType = string | JSXComponent | symbol;
+/** The vnode shape produced by JSX/`jsx()` calls. */
 interface JSXElement {
   /** Internal element marker */
   $$typeof: symbol;

package/dist/{verify-hydration-CcF-HJil.js → verify-hydration-jf8X2V3x.js}

@@ -1,6 +1,6 @@
 import { g as getHydrationRenderUrl, m as withHydrationVerificationRender } from "./render-context-B7ohlh6t.js";
 import { t as SSR_RENDER_DATA_ATTR } from "./ssr-DSHd_Q9K.js";
-import { a as renderResolvedToStringSync } from "./ssr-CaZfvQWn.js";
+import { a as renderResolvedToStringSync } from "./ssr-8_vHDWqV.js";
 //#region src/ssr/verify-hydration.ts
 function normalizeHydrationHtml(html) {
 	const template = document.createElement("template");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/askr",
-  "version": "0.0.92",
+  "version": "0.0.94",
   "description": "Actor-backed deterministic UI framework",
   "keywords": [
     "askr",

package/dist/index-2bk8nldG.d.ts

@@ -1,241 +0,0 @@
-//#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>;
-  /** Test-only query overrides keyed by the canonical query key. */
-  readonly queryTestOverrides: Map<string, unknown>;
-  /** Test-only mutation overrides keyed by the canonical mutation key. */
-  readonly mutationTestOverrides: Map<string, unknown>;
-}
-interface DataRuntimeOptions {
-  queryCache?: Map<string, unknown>;
-  queryData?: Map<string, unknown>;
-  queryTestOverrides?: Map<string, unknown>;
-  mutationTestOverrides?: 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> = {
-  /** Stable identity used by runtime-scoped mutation test overrides. */
-  key?: string;
-  action: (input: TInput, ctx: {
-    signal: AbortSignal;
-  }) => Promise<TResult>;
-  affects?: (input: TInput, result: TResult) => string[];
-  afterSuccess?: 'invalidate';
-  runtime?: DataRuntime;
-};
-//#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/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/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 { QueryStaleReason as A, MutationOptions as C, QueryKeyPart as D, QueryDefinition as E, QueryPrefetchContext as O, Mutation as S, QueryConsistency as T, CoreTelemetry as _, defineServerQueries as a, InvalidateOnIntervalOptions as b, prefetchQuery as c, invalidateOnInterval as d, queryScope as f, createMutation as g, createQuery as h, defineQuery as i, ServerQueryHandler as j, QueryScope as k, serveQuery as l, getDefaultDataRuntime as m, ServerQueryRegistry as n, dehydrateDataRuntime as o, createDataRuntime as p, createQueryPrefetchContext as r, hydrateDataRuntime as s, ServerQueryEntry as t, invalidate as u, DataRuntime as v, Query as w, InvalidateOptions as x, DataRuntimeOptions as y };

package/dist/jsx-runtime-C_0v1pMN.d.ts

@@ -1,2 +0,0 @@
-import "./types-BA9FJtfR.js";
-import "./jsx-runtime-Cfb2umb4.js";

package/dist/scheduler-CmLO4Dfm.d.ts

@@ -1,65 +0,0 @@
-//#region src/runtime/scheduler.d.ts
-/**
- * Serialized update scheduler — safer design (no inline execution, explicit flush)
- *
- * Key ideas:
- * - Never execute a task inline from `enqueue`.
- * - `flush()` is explicit and non-reentrant.
- * - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks
- *   inline; it runs `fn` and then does an explicit `flush()`.
- * - `waitForFlush()` is race-free with a monotonic `flushVersion`.
- */
-type Task = () => void;
-type SchedulerLane = 'derived' | 'component' | 'reactive' | 'post';
-type SchedulerBulkCommitProbe = () => boolean;
-declare class Scheduler {
-  private bulkCommitProbe;
-  private lanes;
-  private running;
-  private inHandler;
-  private depth;
-  private executionDepth;
-  private flushVersion;
-  private kickScheduled;
-  private allowSyncProgress;
-  private waiters;
-  private taskCount;
-  setBulkCommitProbe(probe: SchedulerBulkCommitProbe): void;
-  private isBulkCommitActive;
-  private hasPendingTasks;
-  private getPendingTaskCount;
-  private compactLane;
-  private scheduleFlushKick;
-  enqueue(task: Task): void;
-  enqueueInLane(lane: SchedulerLane, task: Task): void;
-  flush(): void;
-  runWithSyncProgress<T>(fn: () => T): T;
-  waitForFlush(targetVersion?: number, timeoutMs?: number): Promise<void>;
-  getState(): {
-    queueLength: number;
-    running: boolean;
-    depth: number;
-    executionDepth: number;
-    taskCount: number;
-    flushVersion: number;
-    laneQueues: {
-      derived: number;
-      component: number;
-      reactive: number;
-      post: number;
-    };
-    inHandler: boolean;
-    allowSyncProgress: boolean;
-  };
-  getFlushVersion(): number;
-  flushIfQueued(): void;
-  runInHandlerScope<T>(fn: () => T, flushMode?: 'defer' | 'sync'): T;
-  setInHandler(v: boolean): void;
-  isInHandler(): boolean;
-  isExecuting(): boolean;
-  clearPendingSyncTasks(): number;
-  private resolveWaiters;
-}
-declare function scheduleEventHandler(handler: EventListener): EventListener;
-//#endregion
-export { scheduleEventHandler as n, Scheduler as t };