@askrjs/askr 0.0.51 → 0.0.53

package/dist/index-SJXJkssx.d.ts

@@ -0,0 +1,44 @@
+import { c as RenderableChild, g as StateTuple } from "./control-BQvNVfAd.js";
+import { r as JSXElement } from "./jsx-CP0gmYwJ.js";
+import { ObjectSchema } from "@askrjs/schema";
+
+//#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 { action as a, ActionValidationError as i, ActionForm as n, defineAction as o, ActionStatus as r, ActionDescriptor as t };

package/dist/index.d.ts

@@ -1,13 +1,8 @@
-import { Props } from "./common/props.js";
-import { Fragment } from "./common/jsx.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";
-import { jsx, jsxs } from "./jsx-runtime.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-BQvNVfAd.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-R2JJIbM-.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-D73jgYx1.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-B3z7GXlD.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-DzPjeLby.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-BYyLTFyw.js";
+import { 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 } 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,6 +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 };
-
-//# sourceMappingURL=index.js.map
+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,6 +10,4 @@ function emitInvalidation(event) {
 	for (const listener of invalidationListeners) listener(event);
 }
 //#endregion
-export { addInvalidationListener, emitInvalidation };
-
-//# sourceMappingURL=invalidation-listeners.js.map
+export { emitInvalidation as n, addInvalidationListener as t };

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

@@ -301,11 +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 };
-//# sourceMappingURL=props.d.ts.map
+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,6 +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 };
-
-//# sourceMappingURL=jsx.js.map
+export { Fragment as n, STATIC_CHILDREN as r, ELEMENT_TYPE as t };

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

@@ -1,12 +1,24 @@
-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 {
+    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;
 //#endregion
-export { Fragment, type JSXComponent, type JSXElement, type JSXElementType, jsxDEV };
-//# sourceMappingURL=jsx-dev-runtime.d.ts.map
+export { Fragment, JSX, type JSXComponent, type JSXElement, type JSXElementType, jsxDEV };

package/dist/jsx-dev-runtime.js

@@ -1,13 +1,8 @@
-import { isEagerControlPrimitive } from "./common/control.js";
-import { ELEMENT_TYPE, Fragment, STATIC_CHILDREN } from "./common/jsx.js";
-import { markReadableUsage } from "./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) {
-	const normalizedProps = props ?? {};
-	for (const value of Object.values(normalizedProps)) markReadableUsage(value);
-	return normalizedProps;
+	return props ?? {};
 }
 function markStaticChildren(props) {
 	if (Array.isArray(props.children)) Object.defineProperty(props.children, STATIC_CHILDREN, {
@@ -29,5 +24,3 @@ function jsxDEV(type, props, key, isStaticChildren = false) {
 }
 //#endregion
 export { Fragment, jsxDEV };
-
-//# sourceMappingURL=jsx-dev-runtime.js.map

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 { };