@askrjs/askr 0.0.52 → 0.0.54

package/dist/{runtime/runtime.d.ts → index-Zb31mCiU.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-BI4RMD2z.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,9 +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 };
+//#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 };

package/dist/index.d.ts

@@ -1,13 +1,8 @@
-import { Props } from "./common/props.js";
-import { Fragment } from "./common/jsx.js";
-import { jsx, jsxs } from "./jsx-runtime.js";
-import { State, StateSetter, StateTuple, state } from "./runtime/state.js";
-import { Context, defineContext, readContext } from "./runtime/context.js";
-import { getSignal } from "./runtime/component-scope.js";
-import { AskrRuntime, AskrRuntimeOptions, RuntimeKeyedReorderDecision, RuntimeRendererHost, createRuntime, getDefaultRuntime } from "./runtime/runtime.js";
-import { Derived, derive } from "./runtime/derive.js";
-import { Selector, selector } from "./runtime/selector.js";
-import { For, ForProps } from "./control/for.js";
-import { Show, ShowProps } from "./control/show.js";
-import { Case, CaseProps, Match, MatchProps } from "./control/case.js";
-export { AskrRuntime, type AskrRuntimeOptions, Case, type CaseProps, type Context, type Derived, For, type ForProps, Fragment, Match, type MatchProps, type Props, type RuntimeKeyedReorderDecision, type RuntimeRendererHost, type Selector, Show, type ShowProps, type State, type StateSetter, type StateTuple, createRuntime, defineContext, derive, getDefaultRuntime, getSignal, jsx, jsxs, readContext, selector, state };
+import { _ as state, a as defineScope, g as StateTuple, h as StateSetter, i as Scope, m as State, o as readScope } from "./control-BI4RMD2z.js";
+import { s as Props, t as Fragment } from "./jsx-CP0gmYwJ.js";
+import { t as getSignal } from "./component-scope-CvPba6O6.js";
+import { a as AskrRuntime, c as RuntimeRendererHost, i as derive, l as createRuntime, n as selector, o as AskrRuntimeOptions, r as Derived, s as RuntimeKeyedReorderDecision, t as Selector, u as getDefaultRuntime } from "./index-Zb31mCiU.js";
+import { a as Show, c as ForProps, i as MatchProps, n as CaseProps, o as ShowProps, r as Match, s as For, t as Case } from "./index-DwxdIA-t.js";
+import { i as jsxs, n as jsx } from "./jsx-runtime-92bV2hSa.js";
+import { A as ServerQueryHandler, D as QueryPrefetchContext, T as QueryDefinition, a as defineServerQueries, c as prefetchQuery, g as createQuery, i as defineQuery, l as serveQuery, o as dehydrateDataRuntime, s as hydrateDataRuntime, v as DataRuntime } from "./index-Bki2rqcr.js";
+export { AskrRuntime, type AskrRuntimeOptions, Case, type CaseProps, type DataRuntime, type Derived, For, type ForProps, Fragment, Match, type MatchProps, type Props, type QueryDefinition, type QueryPrefetchContext, type RuntimeKeyedReorderDecision, type RuntimeRendererHost, type Scope, type Selector, type ServerQueryHandler, Show, type ShowProps, type State, type StateSetter, type StateTuple, createQuery, createRuntime, defineQuery, defineScope, defineServerQueries, dehydrateDataRuntime, derive, getDefaultRuntime, getSignal, hydrateDataRuntime, jsx, jsxs, prefetchQuery, readScope, selector, serveQuery, state };

package/dist/index.js

@@ -1,18 +1,153 @@
-import { AskrRuntime, createRuntime, getDefaultRuntime } from "./runtime/runtime.js";
-import { Fragment } from "./common/jsx.js";
-import { defineContext, readContext } from "./runtime/context.js";
-import { getSignal } from "./runtime/component-scope.js";
-import { derive } from "./runtime/derive.js";
-import { state } from "./runtime/state.js";
-import { selector } from "./runtime/selector.js";
-import "./runtime/index.js";
+import { a as getRuntimeFlushVersion, d as AskrRuntime, m as getDefaultRuntime, p as createRuntime, t as enqueueRuntimeLane } from "./access-Bg4RJNC8.js";
+import { f as notifyReadableReaders, g as withDerivedReadTracking, h as syncDerivedDependencySubscriptions, l as markReactivePropsDirtySource, o as clearDerivedDependencySubscriptions, p as recordReadableRead, u as markReadableDerivedSubscribersDirty } from "./fastlane-Dw8SOBr9.js";
+import { n as Fragment } from "./jsx-CUpRxrLH.js";
+import { h as readScope, u as defineScope } from "./component-internal-D9PLuFUc.js";
+import { g as getSignal, i as claimHookIndex, p as getCurrentInstance } from "./component-scope-CC3cojX9.js";
+import { n as isSnapshotSource } from "./snapshot-source-BB42xgwb.js";
+import { t as installRendererBridge } from "./renderer-DrLRAD5y.js";
+import { t as state } from "./state-DPl8lffD.js";
+import { t as selector } from "./selector-DafVYzV4.js";
 import { jsx, jsxs } from "./jsx-runtime.js";
-import { installRendererBridge } from "./renderer/index.js";
-import { For } from "./control/for.js";
-import { Show } from "./control/show.js";
-import { Case, Match } from "./control/case.js";
-import "./control/index.js";
-import "./jsx-runtime2.js";
+import { i as For, n as Match, r as Show, t as Case } from "./control-mXROCjL3.js";
+import { t as createQuery } from "./data-B9dauyDn.js";
+import { a as hydrateDataRuntime, i as dehydrateDataRuntime, n as defineQuery, o as prefetchQuery, r as defineServerQueries, s as serveQuery } from "./query-registry-CQIT4mXr.js";
+//#region src/runtime/derive.ts
+const deriveCells = /* @__PURE__ */ new WeakMap();
+const dirtyDerivedCells = /* @__PURE__ */ new Set();
+let hasPendingDerivedFlush = false;
+function getDeriveStore(instance) {
+	const generation = instance._ownershipGeneration;
+	let store = deriveCells.get(generation);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		deriveCells.set(generation, store);
+	}
+	return store;
+}
+function markDerivedCellDirty(cell) {
+	cell._dirty = true;
+	if (cell._scheduled) return;
+	cell._scheduled = true;
+	dirtyDerivedCells.add(cell);
+	if (!hasPendingDerivedFlush) {
+		hasPendingDerivedFlush = true;
+		enqueueRuntimeLane("derived", flushDirtyDerivedCells);
+	}
+}
+function flushDirtyDerivedCells() {
+	hasPendingDerivedFlush = false;
+	if (dirtyDerivedCells.size === 0) return;
+	const pending = dirtyDerivedCells.values();
+	let next = pending.next();
+	while (!next.done) {
+		const cell = next.value;
+		dirtyDerivedCells.delete(cell);
+		cell._scheduled = false;
+		if (!cell._dirty) {
+			next = pending.next();
+			continue;
+		}
+		recomputeDerivedCell(cell, true);
+		next = pending.next();
+	}
+}
+function recomputeDerivedCell(cell, notifyDownstream) {
+	if (!cell._dirty && cell._hasValue) return cell._value;
+	if (cell._evaluating) throw new Error("derive() cannot read itself recursively");
+	cell._evaluating = true;
+	cell._dirty = false;
+	cell._pendingDependencySources = /* @__PURE__ */ new Set();
+	const prevSources = cell._sources;
+	let nextValue;
+	try {
+		nextValue = withDerivedReadTracking(cell, cell._compute);
+	} catch (error) {
+		cell._dirty = true;
+		cell._pendingDependencySources = void 0;
+		throw error;
+	} finally {
+		cell._evaluating = false;
+	}
+	const nextSources = cell._pendingDependencySources ?? /* @__PURE__ */ new Set();
+	cell._pendingDependencySources = void 0;
+	syncDerivedDependencySubscriptions(cell, prevSources, nextSources);
+	cell._sources = nextSources;
+	const valueChanged = !cell._hasValue || !Object.is(cell._value, nextValue);
+	cell._hasValue = true;
+	cell._value = nextValue;
+	cell._lastRecomputeFlushVersion = getRuntimeFlushVersion();
+	if (valueChanged && notifyDownstream) {
+		markReadableDerivedSubscribersDirty(cell);
+		markReactivePropsDirtySource(cell);
+		notifyReadableReaders(cell);
+	}
+	return cell._value;
+}
+function createDerivedCell(instance, generation, store, hookIndex, compute) {
+	const cell = function derivedGetter() {
+		recordReadableRead(cell);
+		return recomputeDerivedCell(cell, cell._scheduled);
+	};
+	cell._owner = instance;
+	cell._hookIndex = hookIndex;
+	cell._compute = compute;
+	cell._value = void 0;
+	cell._hasValue = false;
+	cell._dirty = true;
+	cell._scheduled = false;
+	cell._evaluating = false;
+	cell._lastRecomputeFlushVersion = -1;
+	cell._sources = /* @__PURE__ */ new Set();
+	cell._markDirty = () => {
+		markDerivedCellDirty(cell);
+	};
+	cell._cleanup = () => {
+		cell._scheduled = false;
+		cell._dirty = false;
+		cell._hasValue = false;
+		dirtyDerivedCells.delete(cell);
+		clearDerivedDependencySubscriptions(cell, cell._sources);
+		cell._derivedSubscribers?.clear();
+		cell._readers?.size;
+		cell._readers?.clear();
+	};
+	(instance.cleanupFns ??= []).push(() => {
+		cell._cleanup();
+		store.delete(hookIndex);
+		if (store.size === 0 && deriveCells.get(generation) === store) deriveCells.delete(generation);
+	});
+	return cell;
+}
+function getOrCreateDerivedCell(instance, hookIndex, compute) {
+	const store = getDeriveStore(instance);
+	const existing = store.get(hookIndex);
+	if (existing) {
+		existing._compute = compute;
+		if (existing._lastRecomputeFlushVersion !== getRuntimeFlushVersion()) existing._dirty = true;
+		return existing;
+	}
+	const created = createDerivedCell(instance, instance._ownershipGeneration, store, hookIndex, compute);
+	store.set(hookIndex, created);
+	return created;
+}
+function createMappedSelector(source, map) {
+	return () => {
+		let value;
+		if (typeof source === "function") value = source();
+		else if (isSnapshotSource(source)) value = source.value ?? source;
+		else value = source;
+		if (value == null) return null;
+		return map(value);
+	};
+}
+function derive(source, map) {
+	const instance = getCurrentInstance();
+	if (!instance) throw new Error("derive() can only be called during component render execution. Move derive() calls to the top level of your component function.");
+	const cell = getOrCreateDerivedCell(instance, claimHookIndex(instance, "derive"), map === void 0 ? () => source() : createMappedSelector(source, map));
+	recomputeDerivedCell(cell, false);
+	return cell;
+}
+//#endregion
 //#region src/index.ts
 /**
 * Askr: Actor-backed deterministic UI framework
@@ -21,4 +156,4 @@ import "./jsx-runtime2.js";
 */
 installRendererBridge();
 //#endregion
-export { AskrRuntime, Case, For, Fragment, Match, Show, createRuntime, defineContext, derive, getDefaultRuntime, getSignal, jsx, jsxs, readContext, selector, state };
+export { AskrRuntime, Case, For, Fragment, Match, Show, createQuery, createRuntime, defineQuery, defineScope, defineServerQueries, dehydrateDataRuntime, derive, getDefaultRuntime, getSignal, hydrateDataRuntime, jsx, jsxs, prefetchQuery, readScope, selector, serveQuery, state };

package/dist/interactions-w7gQN4ha.js

@@ -0,0 +1,280 @@
+import { o as mergeProps, r as ariaDisabled, s as composeHandlers, t as composeRefs } from "./compose-ref-Cc_YkUpM.js";
+//#region src/foundations/interactions/pressable.ts
+function pressable({ disabled, onPress, isNativeButton = false }) {
+	const props = { onClick: (e) => {
+		if (disabled) {
+			e.preventDefault?.();
+			e.stopPropagation?.();
+			return;
+		}
+		onPress?.(e);
+	} };
+	if (isNativeButton) {
+		if (disabled) {
+			props.disabled = true;
+			Object.assign(props, ariaDisabled(disabled));
+		}
+		return props;
+	}
+	props.role = "button";
+	props.tabIndex = disabled ? -1 : 0;
+	props.onKeyDown = (e) => {
+		if (disabled) {
+			e.preventDefault?.();
+			e.stopPropagation?.();
+			return;
+		}
+		if (e.key === "Enter") {
+			e.preventDefault?.();
+			onPress?.(e);
+			return;
+		}
+		if (e.key === " ") e.preventDefault?.();
+	};
+	props.onKeyUp = (e) => {
+		if (disabled) {
+			e.preventDefault?.();
+			e.stopPropagation?.();
+			return;
+		}
+		if (e.key === " ") {
+			e.preventDefault?.();
+			onPress?.(e);
+		}
+	};
+	if (disabled) Object.assign(props, ariaDisabled(disabled));
+	return props;
+}
+//#endregion
+//#region src/foundations/interactions/dismissable.ts
+function dismissable({ node, disabled, onDismiss }) {
+	function handleKeyDown(e) {
+		if (disabled) return;
+		if (e.key === "Escape") {
+			e.preventDefault?.();
+			e.stopPropagation?.();
+			onDismiss?.("escape");
+		}
+	}
+	function handlePointerDownCapture(e) {
+		if (disabled) return;
+		const target = e.target;
+		if (!(target instanceof Node)) return;
+		if (!node) return;
+		if (!node.contains(target)) onDismiss?.("outside");
+	}
+	return {
+		onKeyDown: handleKeyDown,
+		onPointerDownCapture: handlePointerDownCapture
+	};
+}
+//#endregion
+//#region src/foundations/interactions/focusable.ts
+/**
+* focusable
+*
+* Normalize focus-related props for hosts.
+* - No DOM manipulation here; returns props that the runtime may attach.
+*/
+function focusable({ disabled, tabIndex }) {
+	return {
+		tabIndex: disabled ? -1 : tabIndex === void 0 ? 0 : tabIndex,
+		...ariaDisabled(disabled)
+	};
+}
+//#endregion
+//#region src/foundations/interactions/hoverable.ts
+function hoverable({ disabled, onEnter, onLeave }) {
+	return {
+		onPointerEnter: disabled ? void 0 : (e) => {
+			onEnter?.(e);
+		},
+		onPointerLeave: disabled ? void 0 : (e) => {
+			onLeave?.(e);
+		}
+	};
+}
+//#endregion
+//#region src/foundations/interactions/roving-focus.ts
+function rovingFocus(options) {
+	const { currentIndex, itemCount, orientation = "horizontal", loop = false, onNavigate, isDisabled } = options;
+	function findNextIndex(from, direction) {
+		let next = from;
+		for (let steps = 0; steps < itemCount; steps += 1) {
+			next += direction;
+			if (loop) {
+				if (next < 0) next = itemCount - 1;
+				if (next >= itemCount) next = 0;
+			} else if (next < 0 || next >= itemCount) return;
+			if (next === from) return void 0;
+			if (!isDisabled?.(next)) return next;
+		}
+	}
+	function handleKeyDown(e) {
+		const { key } = e;
+		let direction;
+		if (orientation === "horizontal" || orientation === "both") {
+			if (key === "ArrowRight") direction = 1;
+			if (key === "ArrowLeft") direction = -1;
+		}
+		if (orientation === "vertical" || orientation === "both") {
+			if (key === "ArrowDown") direction = 1;
+			if (key === "ArrowUp") direction = -1;
+		}
+		if (direction === void 0) return;
+		const nextIndex = findNextIndex(currentIndex, direction);
+		if (nextIndex === void 0) return;
+		e.preventDefault?.();
+		e.stopPropagation?.();
+		onNavigate?.(nextIndex);
+	}
+	return {
+		container: { onKeyDown: handleKeyDown },
+		item: (index) => ({
+			tabIndex: index === currentIndex ? 0 : -1,
+			"data-roving-index": index
+		})
+	};
+}
+/**
+* USAGE EXAMPLE:
+*
+* function Menu() {
+*   const [focusIndex, setFocusIndex] = state(0);
+*   const items = ['File', 'Edit', 'View'];
+*
+*   const navigation = rovingFocus({
+*     currentIndex: focusIndex(),
+*     itemCount: items.length,
+*     orientation: 'horizontal',
+*     loop: true,
+*     onNavigate: setFocusIndex,
+*   });
+*
+*   return (
+*     <div {...navigation.container}>
+*       {items.map((label, index) => (
+*         <button {...navigation.item(index)}>
+*           {label}
+*         </button>
+*       ))}
+*     </div>
+*   );
+* }
+*/
+//#endregion
+//#region src/foundations/interactions/interaction-policy.ts
+/**
+* INTERACTION POLICY (FRAMEWORK LAW)
+*
+* This is THE ONLY way to create interactive elements. Components MUST NOT
+* implement interaction logic directly.
+*
+* INVARIANTS (ENFORCED):
+* 1. "Press" is the semantic. Click/touch/Enter/Space are implementation details.
+* 2. Disabled is enforced exactly once, here. Components may not check disabled.
+* 3. Keyboard handling is automatic. Components may not add onKeyDown for activation.
+* 4. Native elements opt out of polyfills, not semantics.
+* 5. asChild may replace the host element, not interaction behavior.
+* 6. This policy is the SINGLE SOURCE OF TRUTH for interactive behavior.
+*
+* DESIGN:
+* - Single public function: applyInteractionPolicy
+* - Returns props that compose via mergeProps
+* - Delegates to pressable for mechanics
+* - Enforces disabled once and only once
+* - No configuration beyond disabled and native element type
+*
+* PIT OF SUCCESS:
+* ✓ Can't bypass policy (only way to get interaction behavior)
+* ✓ Can't duplicate disabled checks (enforced once, here)
+* ✓ Can't write custom keyboard handlers for buttons (policy owns it)
+* ✓ Composes via mergeProps (standard props)
+* ✓ Wrong usage is impossible (no escape hatch)
+*
+* USAGE:
+*   function Button({ onPress, disabled }) {
+*     const interaction = applyInteractionPolicy({
+*       isNative: true,
+*       disabled,
+*       onPress
+*     });
+*
+*     return <button {...interaction}>Click me</button>;
+*   }
+*
+* MISUSE EXAMPLE (PREVENTED):
+*   ❌ Button checking disabled again:
+*      function Button({ disabled, onPress }) {
+*        if (disabled) return; // NO! Policy handles this
+*        const interaction = applyInteractionPolicy(...);
+*      }
+*
+*   ❌ Custom keyboard handler:
+*      function Button({ onPress }) {
+*        const interaction = applyInteractionPolicy(...);
+*        return <button {...interaction} onKeyDown={...}>; // NO! Policy owns this
+*      }
+*
+*   ❌ Direct event handler:
+*      <button onClick={onPress}>; // NO! Use applyInteractionPolicy
+*/
+/**
+* THE interaction policy. Components MUST use this, NEVER implement
+* interaction logic directly.
+*/
+function applyInteractionPolicy({ isNative, disabled, onPress, ref }) {
+	function invokePress(e) {
+		if (disabled) {
+			e.preventDefault?.();
+			return;
+		}
+		onPress?.(e);
+	}
+	if (isNative) return {
+		disabled: disabled || void 0,
+		onClick: (e) => invokePress(e),
+		ref
+	};
+	const interaction = pressable({
+		disabled,
+		isNativeButton: false,
+		onPress: (e) => invokePress(e)
+	});
+	return {
+		...interaction,
+		...ariaDisabled(disabled),
+		tabIndex: disabled ? -1 : interaction.tabIndex ?? 0,
+		ref
+	};
+}
+/**
+* Merge rule for Slot / asChild
+*
+* Precedence:
+*   policy → user → child
+*
+* Event handlers are composed (policy first).
+* Refs are always composed.
+* Policy props MUST take precedence to enforce invariants.
+*/
+function mergeInteractionProps(childProps, policyProps, userProps) {
+	const out = mergeProps(policyProps, userProps ? mergeProps(userProps, childProps) : childProps);
+	for (const k in out) {
+		if (!k.startsWith("on")) continue;
+		const policyHandler = policyProps?.[k];
+		const userHandler = userProps?.[k];
+		const childHandler = childProps?.[k];
+		if (policyHandler || userHandler || childHandler) {
+			const toHandler = (h) => typeof h === "function" ? h : void 0;
+			out[k] = composeHandlers(toHandler(policyHandler), composeHandlers(toHandler(userHandler), toHandler(childHandler)));
+		}
+	}
+	const childRef = childProps?.ref;
+	const userRef = userProps?.ref;
+	const policyRef = policyProps?.ref;
+	out.ref = composeRefs(childRef, userRef, policyRef);
+	return out;
+}
+//#endregion
+export { focusable as a, hoverable as i, mergeInteractionProps as n, dismissable as o, rovingFocus as r, pressable as s, applyInteractionPolicy as t };

package/dist/{data/invalidation-listeners.js → invalidation-listeners-Des3AHYs.js}

@@ -10,4 +10,4 @@ function emitInvalidation(event) {
 	for (const listener of invalidationListeners) listener(event);
 }
 //#endregion
-export { addInvalidationListener, emitInvalidation };
+export { emitInvalidation as n, addInvalidationListener as t };

package/dist/{common/props.d.ts → jsx-CP0gmYwJ.d.ts}

@@ -301,10 +301,22 @@ interface KnownIntrinsicElementProps {
   tr: LayoutIntrinsicProps;
   ul: LayoutIntrinsicProps;
 }
-interface ComponentNode {
-  type: 'component' | 'element' | 'text';
-  value?: unknown;
-  children?: ComponentNode[];
+//#endregion
+//#region src/common/jsx.d.ts
+declare const Fragment: unique symbol;
+type JSXComponent<TProps extends object = Props> = {
+  bivarianceHack(props: TProps): unknown;
+}['bivarianceHack'];
+type JSXElementType = string | JSXComponent | symbol;
+interface JSXElement {
+  /** Internal element marker */
+  $$typeof: symbol;
+  /** Element type: string, component, Fragment, etc */
+  type: JSXElementType;
+  /** Props bag */
+  props: Props;
+  /** Optional key (normalized by runtime) */
+  key?: string | number | null;
 }
 //#endregion
-export { AnchorIntrinsicProps, ButtonIntrinsicProps, ComponentNode, FormIntrinsicProps, ImageIntrinsicProps, InputIntrinsicProps, IntrinsicFallbackProps, IntrinsicProps, KnownIntrinsicElementProps, LabelIntrinsicProps, LayoutIntrinsicProps, ListItemIntrinsicProps, OptionIntrinsicProps, OrderedListIntrinsicProps, OutputIntrinsicProps, Props, SelectIntrinsicProps, SvgCircleIntrinsicProps, SvgGroupIntrinsicProps, SvgIntrinsicProps, SvgPathIntrinsicProps, SvgRectIntrinsicProps, TableCellIntrinsicProps, TableHeaderIntrinsicProps, TextareaIntrinsicProps };
+export { IntrinsicFallbackProps as a, JSXElementType as i, JSXComponent as n, KnownIntrinsicElementProps as o, JSXElement as r, Props as s, Fragment as t };

package/dist/{common/jsx.js → jsx-CUpRxrLH.js}

@@ -3,4 +3,4 @@ const ELEMENT_TYPE = Symbol.for("askr.element");
 const Fragment = Symbol.for("askr.fragment");
 const STATIC_CHILDREN = Symbol.for("askr.static-children");
 //#endregion
-export { ELEMENT_TYPE, Fragment, STATIC_CHILDREN };
+export { Fragment as n, STATIC_CHILDREN as r, ELEMENT_TYPE as t };

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

@@ -1,7 +1,5 @@
-import { IntrinsicFallbackProps, KnownIntrinsicElementProps, Props } from "./common/props.js";
-import { Fragment, JSXComponent, JSXElement, JSXElementType } from "./common/jsx.js";
-import { EagerControlPrimitive } from "./common/control.js";
-
+import { a as IntrinsicFallbackProps, i as JSXElementType, n as JSXComponent, o as KnownIntrinsicElementProps, r as JSXElement, s as Props, t as Fragment } from "./jsx-CP0gmYwJ.js";
+import { t as EagerControlPrimitive } from "./control-Bf4Wkdvv.js";
 //#region src/jsx/jsx-dev-runtime.d.ts
 declare namespace JSX {
   interface Element extends JSXElement {

package/dist/jsx-dev-runtime.js

@@ -1,12 +1,14 @@
-import { isEagerControlPrimitive } from "./common/control.js";
-import { ELEMENT_TYPE, Fragment } from "./common/jsx.js";
-import "./runtime/readable.js";
-import "./runtime/index.js";
-import "./jsx/types.js";
+import { n as isEagerControlPrimitive } from "./control-DhFRTIoE.js";
+import { n as Fragment, r as STATIC_CHILDREN, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+//#region src/jsx/jsx-dev-runtime.ts
 function annotatePropsUsage(props) {
 	return props ?? {};
 }
 function markStaticChildren(props) {
+	if (Array.isArray(props.children)) Object.defineProperty(props.children, STATIC_CHILDREN, {
+		value: true,
+		configurable: true
+	});
 	return props;
 }
 function jsxDEV(type, props, key, isStaticChildren = false) {

package/dist/jsx-runtime-92bV2hSa.d.ts

@@ -0,0 +1,34 @@
+import { a as IntrinsicFallbackProps, o as KnownIntrinsicElementProps, r as JSXElement, s as Props } from "./jsx-CP0gmYwJ.js";
+import { t as EagerControlPrimitive } from "./control-Bf4Wkdvv.js";
+//#region src/jsx/jsx-runtime.d.ts
+declare namespace JSX {
+  interface Element extends JSXElement {
+    readonly __askrJsxElementBrand?: never;
+  }
+  interface IntrinsicElements extends KnownIntrinsicElementProps {
+    [elem: string]: IntrinsicFallbackProps | KnownIntrinsicElementProps[keyof KnownIntrinsicElementProps];
+  }
+  interface ElementAttributesProperty {
+    props: Props;
+  }
+  interface ElementChildrenAttribute {
+    children: unknown;
+  }
+}
+declare function jsxDEV(type: EagerControlPrimitive, props: Props | null, key?: string | number, isStaticChildren?: boolean): unknown;
+declare function jsxDEV<TTag extends keyof KnownIntrinsicElementProps>(type: TTag, props: KnownIntrinsicElementProps[TTag] | null, key?: string | number, isStaticChildren?: boolean): JSXElement;
+declare function jsxDEV<TTag extends string>(type: Exclude<TTag, keyof KnownIntrinsicElementProps>, props: IntrinsicFallbackProps | null, key?: string | number, isStaticChildren?: boolean): JSXElement;
+declare function jsxDEV<TProps extends object>(type: (props: TProps) => unknown, props: TProps | null, key?: string | number, isStaticChildren?: boolean): JSXElement;
+declare function jsxDEV(type: symbol, props: Props | null, key?: string | number, isStaticChildren?: boolean): JSXElement;
+declare function jsx(type: EagerControlPrimitive, props: Props | null, key?: string | number): unknown;
+declare function jsx<TTag extends keyof KnownIntrinsicElementProps>(type: TTag, props: KnownIntrinsicElementProps[TTag] | null, key?: string | number): JSXElement;
+declare function jsx<TTag extends string>(type: Exclude<TTag, keyof KnownIntrinsicElementProps>, props: IntrinsicFallbackProps | null, key?: string | number): JSXElement;
+declare function jsx<TProps extends object>(type: (props: TProps) => unknown, props: TProps | null, key?: string | number): JSXElement;
+declare function jsx(type: symbol, props: Props | null, key?: string | number): JSXElement;
+declare function jsxs(type: EagerControlPrimitive, props: Props | null, key?: string | number): unknown;
+declare function jsxs<TTag extends keyof KnownIntrinsicElementProps>(type: TTag, props: KnownIntrinsicElementProps[TTag] | null, key?: string | number): JSXElement;
+declare function jsxs<TTag extends string>(type: Exclude<TTag, keyof KnownIntrinsicElementProps>, props: IntrinsicFallbackProps | null, key?: string | number): JSXElement;
+declare function jsxs<TProps extends object>(type: (props: TProps) => unknown, props: TProps | null, key?: string | number): JSXElement;
+declare function jsxs(type: symbol, props: Props | null, key?: string | number): JSXElement;
+//#endregion
+export { jsxs as i, jsx as n, jsxDEV as r, JSX as t };

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

@@ -0,0 +1 @@
+export { };