@askrjs/askr 0.0.52 → 0.0.53

package/dist/control-BQvNVfAd.d.ts

@@ -0,0 +1,436 @@
+import { i as JSXElementType, r as JSXElement, s as Props } from "./jsx-CP0gmYwJ.js";
+
+//#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>;
+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;
+}
+interface DocumentRenderArgs {
+  appHtml: string;
+  context: DocumentRenderContext;
+}
+type DocumentRenderer = (args: DocumentRenderArgs) => string;
+/** 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;
+  _forState?: ForState<unknown>;
+}
+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/app-render-runtime.d.ts
+interface AppRenderRuntime {
+  framework: Readonly<Record<string, unknown>>;
+  route: unknown;
+  hasRoute: boolean;
+}
+//#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;
+  _vnodeOwner?: object;
+  _vnodeParent?: ComponentInstance | null;
+  _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/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;
+}
+//#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> = T[] | (() => 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';
+  currentItems: T[];
+  _committedItems: 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<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: 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 {
+  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
+export { state as _, defineScope as a, RenderableChild as c, DocumentRenderContext as d, DocumentRenderer as f, StateTuple as g, StateSetter as h, Scope as i, VNode as l, State as m, ReadableSource as n, readScope as o, SSRData as p, ComponentInstance as r, ComponentFunction as s, ForEachSource as t, DocumentRenderArgs as u };

package/dist/control-BYyLTFyw.js

@@ -0,0 +1,165 @@
+import { r as markEagerControlPrimitive, t as __CONTROL_BOUNDARY__ } from "./control-DhFRTIoE.js";
+import { b as isDevelopmentEnvironment } from "./access-Bg4RJNC8.js";
+import { n as Fragment } from "./jsx-CUpRxrLH.js";
+import { m as createShowState, p as createCaseState, s as useForState } from "./for-internal-BKf_Tnv1.js";
+import { t as createFineGrainedEffect } from "./effect-BwnIvLah.js";
+import { t as state } from "./state-DPl8lffD.js";
+//#region src/control/shared.ts
+function normalizeBoundaryChild(value) {
+	if (Array.isArray(value)) {
+		if (value.length === 0) return null;
+		if (value.length === 1) return normalizeBoundaryChild(value[0]);
+		return {
+			type: Fragment,
+			props: { children: value }
+		};
+	}
+	return value ?? null;
+}
+function resolveMaybeAccessor(value) {
+	return typeof value === "function" ? value() : value;
+}
+//#endregion
+//#region src/control/for.ts
+/**
+* For JSX primitive
+*
+* Creates a keyed child-scope boundary for efficient list rendering.
+*/
+function resolveEach(each) {
+	const resolved = typeof each === "function" ? each() : each;
+	if (!Array.isArray(resolved)) throw new Error("For each must resolve to an array.");
+	return resolved;
+}
+function resolveKeyFn(props) {
+	if ("by" in props && typeof props.by === "function") return props.by;
+	if ("byIndex" in props && props.byIndex === true) return (_item, index) => index;
+	throw new Error("[askr] <For> requires a stable `by` key function. Use `byIndex` only as an explicit positional escape hatch.");
+}
+function createForBoundary(props) {
+	if ("by" in props && typeof props.by === "function" && "byIndex" in props) throw new Error("[askr] <For> accepts either `by` or `byIndex`, not both.");
+	const byFn = resolveKeyFn(props);
+	const fallback = normalizeBoundaryChild(props.fallback);
+	const forState = useForState(props.each, byFn, props.children, fallback);
+	const computeItems = () => resolveEach(forState.eachSource);
+	if (!forState._sourceEffect) {
+		forState._suspendSourceCommit = true;
+		forState._sourceEffect = createFineGrainedEffect({
+			lane: "reactive",
+			compute: computeItems,
+			commit: (items) => {
+				forState.currentItems = items;
+				if (forState._suspendSourceCommit) return;
+				forState._needsSourceReconcile = true;
+				if (forState._enqueueBoundaryCommit) {
+					forState._enqueueBoundaryCommit();
+					return;
+				}
+				forState.parentInstance?._enqueueRun?.();
+			}
+		});
+		forState._suspendSourceCommit = false;
+	} else {
+		forState._suspendSourceCommit = true;
+		forState._sourceEffect.updateCompute(computeItems);
+		forState._suspendSourceCommit = false;
+	}
+	return {
+		type: __CONTROL_BOUNDARY__,
+		_controlState: forState,
+		_forState: forState
+	};
+}
+function ForPrimitive(props) {
+	return createForBoundary(props);
+}
+const For = markEagerControlPrimitive(ForPrimitive);
+//#endregion
+//#region src/control/show.ts
+function createTruthyRenderer(props) {
+	if (typeof props.children === "function") return (value) => normalizeBoundaryChild(props.children(value));
+	const staticChild = normalizeBoundaryChild(props.children);
+	return () => staticChild;
+}
+function createFallbackRenderer(fallback) {
+	const normalizedFallback = normalizeBoundaryChild(fallback);
+	if (normalizedFallback == null || normalizedFallback === false) return null;
+	return () => normalizedFallback;
+}
+function ShowPrimitive(props) {
+	const selectedValue = resolveMaybeAccessor(props.when);
+	const renderTruthy = createTruthyRenderer(props);
+	const renderFallback = createFallbackRenderer(props.fallback);
+	const showState = state(createShowState(selectedValue, renderTruthy, renderFallback))();
+	showState.selectedValue = selectedValue;
+	showState.renderTruthy = renderTruthy;
+	showState.renderFallback = renderFallback;
+	return {
+		type: __CONTROL_BOUNDARY__,
+		_controlState: showState
+	};
+}
+const Show = markEagerControlPrimitive(ShowPrimitive);
+//#endregion
+//#region src/control/case.ts
+function flattenChildren(children) {
+	if (!Array.isArray(children)) return children == null || children === false ? [] : [children];
+	const result = [];
+	for (const child of children) {
+		if (Array.isArray(child)) {
+			result.push(...flattenChildren(child));
+			continue;
+		}
+		result.push(child);
+	}
+	return result;
+}
+function Match(_props) {
+	if (isDevelopmentEnvironment()) throw new Error("[askr] <Match> may only be used as a direct child of <Case>.");
+	return null;
+}
+function createCaseFallbackRenderer(fallback) {
+	const normalizedFallback = normalizeBoundaryChild(fallback);
+	if (normalizedFallback == null || normalizedFallback === false) return null;
+	return () => normalizedFallback;
+}
+function createMatchBranchKey(key, index) {
+	if (key == null) return index;
+	return `match:${index}:${typeof key}:${String(key)}`;
+}
+function readMatchBranches(children) {
+	const branches = [];
+	const flatChildren = flattenChildren(children);
+	for (let index = 0; index < flatChildren.length; index += 1) {
+		const child = flatChildren[index];
+		if (child == null || child === false) continue;
+		if (typeof child === "object" && child !== null && "type" in child && child.type === Match) {
+			const element = child;
+			const props = element.props ?? {};
+			const key = createMatchBranchKey(element.key, index);
+			const render = typeof props.children === "function" ? () => normalizeBoundaryChild(props.children()) : () => normalizeBoundaryChild(props.children);
+			branches.push({
+				key,
+				render,
+				when: props.when
+			});
+			continue;
+		}
+		if (isDevelopmentEnvironment()) throw new Error("[askr] <Case> only accepts <Match> children.");
+	}
+	return branches;
+}
+function CasePrimitive(props) {
+	const matches = readMatchBranches(props.children);
+	const fallback = createCaseFallbackRenderer(props.fallback);
+	const caseState = state(createCaseState(matches, fallback))();
+	caseState.matches = matches;
+	caseState.fallback = fallback;
+	return {
+		type: __CONTROL_BOUNDARY__,
+		_controlState: caseState
+	};
+}
+const Case = markEagerControlPrimitive(CasePrimitive);
+//#endregion
+export { For as i, Match as n, Show as r, Case as t };

package/dist/control-Bf4Wkdvv.d.ts

@@ -0,0 +1,9 @@
+import { s as Props } from "./jsx-CP0gmYwJ.js";
+
+//#region src/common/control.d.ts
+declare const EAGER_CONTROL_PRIMITIVE: unique symbol;
+type EagerControlPrimitive<P extends Props = Props> = ((props: P) => unknown) & {
+  [EAGER_CONTROL_PRIMITIVE]?: true;
+};
+//#endregion
+export { EagerControlPrimitive as t };

package/dist/{common/control.js → control-DhFRTIoE.js}

@@ -9,4 +9,4 @@ function isEagerControlPrimitive(value) {
 	return typeof value === "function" && Boolean(value[EAGER_CONTROL_PRIMITIVE]);
 }
 //#endregion
-export { __CONTROL_BOUNDARY__, isEagerControlPrimitive, markEagerControlPrimitive };
+export { isEagerControlPrimitive as n, markEagerControlPrimitive as r, __CONTROL_BOUNDARY__ as t };

package/dist/data/index.d.ts

@@ -1,6 +1,2 @@
-import { DataRuntime, DataRuntimeOptions, InvalidateOnIntervalOptions, InvalidateOptions, Mutation, Query, QueryConsistency, QueryKeyPart, QueryScope, QueryStaleReason } from "./types.js";
-import { createMutation } from "./mutation-cell.js";
-import { createQuery } from "./query-cell.js";
-import { createDataRuntime, getDefaultDataRuntime } from "./data-runtime.js";
-import { invalidate, invalidateOnInterval, queryScope } from "./invalidation.js";
-export { type DataRuntime, type DataRuntimeOptions, type InvalidateOnIntervalOptions, type InvalidateOptions, type Mutation, type Query, type QueryConsistency, type QueryKeyPart, type QueryScope, type QueryStaleReason, createDataRuntime, createMutation, createQuery, getDefaultDataRuntime, invalidate, invalidateOnInterval, queryScope };
+import { A as ServerQueryHandler, C as Query, D as QueryPrefetchContext, E as QueryKeyPart, O as QueryScope, S as Mutation, T as QueryDefinition, _ as createMutation, a as defineServerQueries, b as InvalidateOnIntervalOptions, c as prefetchQuery, d as invalidate, f as invalidateOnInterval, g as createQuery, h as getDefaultDataRuntime, i as defineQuery, k as QueryStaleReason, l as serveQuery, m as createDataRuntime, n as ServerQueryRegistry, o as dehydrateDataRuntime, p as queryScope, r as createQueryPrefetchContext, s as hydrateDataRuntime, t as ServerQueryEntry, v as DataRuntime, w as QueryConsistency, x as InvalidateOptions, y as DataRuntimeOptions } from "../index-Bki2rqcr.js";
+export { type DataRuntime, type DataRuntimeOptions, type InvalidateOnIntervalOptions, type InvalidateOptions, type Mutation, type Query, type QueryConsistency, type QueryDefinition, type QueryKeyPart, type QueryPrefetchContext, type QueryScope, type QueryStaleReason, type ServerQueryEntry, type ServerQueryHandler, type ServerQueryRegistry, createDataRuntime, createMutation, createQuery, createQueryPrefetchContext, defineQuery, defineServerQueries, dehydrateDataRuntime, getDefaultDataRuntime, hydrateDataRuntime, invalidate, invalidateOnInterval, prefetchQuery, queryScope, serveQuery };

package/dist/data/index.js

@@ -1,5 +1,4 @@
-import { createDataRuntime, getDefaultDataRuntime } from "./data-runtime.js";
-import { invalidate, invalidateOnInterval, queryScope } from "./invalidation.js";
-import { createMutation } from "./mutation-cell.js";
-import { createQuery } from "./query-cell.js";
-export { createDataRuntime, createMutation, createQuery, getDefaultDataRuntime, invalidate, invalidateOnInterval, queryScope };
+import { i as getDefaultDataRuntime, t as createDataRuntime } from "../data-runtime-SJ1BSUvk.js";
+import { a as queryScope, i as invalidateOnInterval, n as createMutation, r as invalidate, t as createQuery } from "../data-DnxnDxD-.js";
+import { a as hydrateDataRuntime, i as dehydrateDataRuntime, n as defineQuery, o as prefetchQuery, r as defineServerQueries, s as serveQuery, t as createQueryPrefetchContext } from "../query-registry-CQIT4mXr.js";
+export { createDataRuntime, createMutation, createQuery, createQueryPrefetchContext, defineQuery, defineServerQueries, dehydrateDataRuntime, getDefaultDataRuntime, hydrateDataRuntime, invalidate, invalidateOnInterval, prefetchQuery, queryScope, serveQuery };