@askrjs/askr 0.3.0 → 0.4.0

package/dist/domains/telemetry.d.ts

@@ -1,7 +1,5 @@
 import { JSXElementType, JSXElement, Props } from '../elements.js';
 import '../jsx-globals.js';
-import { AuthContext, AuthRequirement } from '@askrjs/auth';
-import { InferSchema, ObjectSchema } from '@askrjs/schema';
 import { action } from './actions.js';
 
 interface TelemetryFields {

package/dist/elements.d.ts

@@ -25,6 +25,8 @@ type IntrinsicDataValue = string | number | boolean | null | undefined;
 type IntrinsicBooleanValue = boolean | null | undefined;
 type IntrinsicNumberValue = number | null | undefined;
 type IntrinsicTextValue = string | null | undefined;
+/** Enumerated attributes where `false` renders `"false"` (see keepsFalseValue). */
+type IntrinsicEnumeratedValue = string | boolean | null | undefined;
 type IntrinsicTextLikeValue = string | number | null | undefined;
 type IntrinsicStyleEntryValue = string | number | null | undefined | false;
 type IntrinsicStyleObject = Record<string, IntrinsicStyleEntryValue>;
@@ -40,57 +42,154 @@ type IntrinsicFormValue =
   | readonly string[]
   | null
   | undefined;
-type IntrinsicRefTarget = Element | null;
-type IntrinsicRef =
-  | BivariantHandler<IntrinsicRefTarget>
+type IntrinsicRef<T extends Element = Element> =
+  | BivariantHandler<T | null>
   | {
-      current: IntrinsicRefTarget;
+      current: T | null;
     }
   | null
   | undefined;
+/** MathML elements that lib.dom's MathMLElementTagNameMap does not list. */
+type MathMLExtraTag = 'mglyph' | 'menclose' | 'mlabeledtr' | 'none';
+type IntrinsicElementForTag<Tag extends string> =
+  Tag extends keyof HTMLElementTagNameMap
+    ? HTMLElementTagNameMap[Tag]
+    : Tag extends keyof SVGElementTagNameMap
+      ? SVGElementTagNameMap[Tag]
+      : Tag extends keyof MathMLElementTagNameMap | MathMLExtraTag
+        ? MathMLElement
+        : Element;
 interface IntrinsicEventProps {
-  onAbort?: BivariantHandler<Event>;
-  onBlur?: BivariantHandler<FocusEvent>;
-  onChange?: BivariantHandler<Event>;
-  onClick?: BivariantHandler<MouseEvent>;
-  onDblClick?: BivariantHandler<MouseEvent>;
-  onFocus?: BivariantHandler<FocusEvent>;
-  onInput?: BivariantHandler<InputEvent>;
-  onKeyDown?: BivariantHandler<KeyboardEvent>;
-  onKeyUp?: BivariantHandler<KeyboardEvent>;
-  onMouseDown?: BivariantHandler<MouseEvent>;
-  onMouseEnter?: BivariantHandler<MouseEvent>;
-  onMouseLeave?: BivariantHandler<MouseEvent>;
-  onMouseMove?: BivariantHandler<MouseEvent>;
-  onMouseOut?: BivariantHandler<MouseEvent>;
-  onMouseOver?: BivariantHandler<MouseEvent>;
-  onMouseUp?: BivariantHandler<MouseEvent>;
-  onPointerDown?: BivariantHandler<PointerEvent>;
-  onPointerDownCapture?: BivariantHandler<PointerEvent>;
-  onPointerEnter?: BivariantHandler<PointerEvent>;
-  onPointerLeave?: BivariantHandler<PointerEvent>;
-  onPointerMove?: BivariantHandler<PointerEvent>;
-  onPointerUp?: BivariantHandler<PointerEvent>;
-  onScroll?: BivariantHandler<Event>;
-  onSubmit?: BivariantHandler<SubmitEvent>;
-  onTouchEnd?: BivariantHandler<TouchEvent>;
-  onTouchStart?: BivariantHandler<TouchEvent>;
-  onWheel?: BivariantHandler<WheelEvent>;
+  onAbort?: BivariantHandler<Event> | null;
+  onAnimationCancel?: BivariantHandler<AnimationEvent> | null;
+  onAnimationEnd?: BivariantHandler<AnimationEvent> | null;
+  onAnimationIteration?: BivariantHandler<AnimationEvent> | null;
+  onAnimationStart?: BivariantHandler<AnimationEvent> | null;
+  onAuxClick?: BivariantHandler<PointerEvent> | null;
+  onBeforeInput?: BivariantHandler<InputEvent> | null;
+  onBeforeMatch?: BivariantHandler<Event> | null;
+  onBeforeToggle?: BivariantHandler<ToggleEvent> | null;
+  onBlur?: BivariantHandler<FocusEvent> | null;
+  onCancel?: BivariantHandler<Event> | null;
+  onCanPlay?: BivariantHandler<Event> | null;
+  onCanPlayThrough?: BivariantHandler<Event> | null;
+  onChange?: BivariantHandler<Event> | null;
+  onClick?: BivariantHandler<MouseEvent> | null;
+  onClose?: BivariantHandler<Event> | null;
+  onCommand?: BivariantHandler<Event> | null;
+  onCompositionEnd?: BivariantHandler<CompositionEvent> | null;
+  onCompositionStart?: BivariantHandler<CompositionEvent> | null;
+  onCompositionUpdate?: BivariantHandler<CompositionEvent> | null;
+  onContextLost?: BivariantHandler<Event> | null;
+  onContextMenu?: BivariantHandler<PointerEvent> | null;
+  onContextRestored?: BivariantHandler<Event> | null;
+  onCopy?: BivariantHandler<ClipboardEvent> | null;
+  onCueChange?: BivariantHandler<Event> | null;
+  onCut?: BivariantHandler<ClipboardEvent> | null;
+  onDblClick?: BivariantHandler<MouseEvent> | null;
+  onDrag?: BivariantHandler<DragEvent> | null;
+  onDragEnd?: BivariantHandler<DragEvent> | null;
+  onDragEnter?: BivariantHandler<DragEvent> | null;
+  onDragLeave?: BivariantHandler<DragEvent> | null;
+  onDragOver?: BivariantHandler<DragEvent> | null;
+  onDragStart?: BivariantHandler<DragEvent> | null;
+  onDrop?: BivariantHandler<DragEvent> | null;
+  onDurationChange?: BivariantHandler<Event> | null;
+  onEmptied?: BivariantHandler<Event> | null;
+  onEnded?: BivariantHandler<Event> | null;
+  onError?: BivariantHandler<ErrorEvent> | null;
+  onFocus?: BivariantHandler<FocusEvent> | null;
+  onFocusIn?: BivariantHandler<FocusEvent> | null;
+  onFocusOut?: BivariantHandler<FocusEvent> | null;
+  onFormData?: BivariantHandler<FormDataEvent> | null;
+  onGotPointerCapture?: BivariantHandler<PointerEvent> | null;
+  onInput?: BivariantHandler<InputEvent> | null;
+  onInvalid?: BivariantHandler<Event> | null;
+  onKeyDown?: BivariantHandler<KeyboardEvent> | null;
+  onKeyPress?: BivariantHandler<KeyboardEvent> | null;
+  onKeyUp?: BivariantHandler<KeyboardEvent> | null;
+  onLoad?: BivariantHandler<Event> | null;
+  onLoadedData?: BivariantHandler<Event> | null;
+  onLoadedMetadata?: BivariantHandler<Event> | null;
+  onLoadStart?: BivariantHandler<Event> | null;
+  onLostPointerCapture?: BivariantHandler<PointerEvent> | null;
+  onMouseDown?: BivariantHandler<MouseEvent> | null;
+  onMouseEnter?: BivariantHandler<MouseEvent> | null;
+  onMouseLeave?: BivariantHandler<MouseEvent> | null;
+  onMouseMove?: BivariantHandler<MouseEvent> | null;
+  onMouseOut?: BivariantHandler<MouseEvent> | null;
+  onMouseOver?: BivariantHandler<MouseEvent> | null;
+  onMouseUp?: BivariantHandler<MouseEvent> | null;
+  onPaste?: BivariantHandler<ClipboardEvent> | null;
+  onPause?: BivariantHandler<Event> | null;
+  onPlay?: BivariantHandler<Event> | null;
+  onPlaying?: BivariantHandler<Event> | null;
+  onPointerCancel?: BivariantHandler<PointerEvent> | null;
+  onPointerDown?: BivariantHandler<PointerEvent> | null;
+  onPointerEnter?: BivariantHandler<PointerEvent> | null;
+  onPointerLeave?: BivariantHandler<PointerEvent> | null;
+  onPointerMove?: BivariantHandler<PointerEvent> | null;
+  onPointerOut?: BivariantHandler<PointerEvent> | null;
+  onPointerOver?: BivariantHandler<PointerEvent> | null;
+  onPointerRawUpdate?: BivariantHandler<Event> | null;
+  onPointerUp?: BivariantHandler<PointerEvent> | null;
+  onProgress?: BivariantHandler<ProgressEvent<EventTarget>> | null;
+  onRateChange?: BivariantHandler<Event> | null;
+  onReset?: BivariantHandler<Event> | null;
+  onResize?: BivariantHandler<UIEvent> | null;
+  onScroll?: BivariantHandler<Event> | null;
+  onScrollEnd?: BivariantHandler<Event> | null;
+  onSecurityPolicyViolation?: BivariantHandler<SecurityPolicyViolationEvent> | null;
+  onSeeked?: BivariantHandler<Event> | null;
+  onSeeking?: BivariantHandler<Event> | null;
+  onSelect?: BivariantHandler<Event> | null;
+  onSelectionChange?: BivariantHandler<Event> | null;
+  onSelectStart?: BivariantHandler<Event> | null;
+  onSlotChange?: BivariantHandler<Event> | null;
+  onStalled?: BivariantHandler<Event> | null;
+  onSubmit?: BivariantHandler<SubmitEvent> | null;
+  onSuspend?: BivariantHandler<Event> | null;
+  onTimeUpdate?: BivariantHandler<Event> | null;
+  onToggle?: BivariantHandler<ToggleEvent> | null;
+  onTouchCancel?: BivariantHandler<TouchEvent> | null;
+  onTouchEnd?: BivariantHandler<TouchEvent> | null;
+  onTouchMove?: BivariantHandler<TouchEvent> | null;
+  onTouchStart?: BivariantHandler<TouchEvent> | null;
+  onTransitionCancel?: BivariantHandler<TransitionEvent> | null;
+  onTransitionEnd?: BivariantHandler<TransitionEvent> | null;
+  onTransitionRun?: BivariantHandler<TransitionEvent> | null;
+  onTransitionStart?: BivariantHandler<TransitionEvent> | null;
+  onVolumeChange?: BivariantHandler<Event> | null;
+  onWaiting?: BivariantHandler<Event> | null;
+  onWebkitAnimationEnd?: BivariantHandler<Event> | null;
+  onWebkitAnimationIteration?: BivariantHandler<Event> | null;
+  onWebkitAnimationStart?: BivariantHandler<Event> | null;
+  onWebkitTransitionEnd?: BivariantHandler<Event> | null;
+  onWheel?: BivariantHandler<WheelEvent> | null;
 }
+type CapturedIntrinsicEventProps = {
+  [
+    Name in keyof IntrinsicEventProps as `${Name & string}Capture`
+  ]?: IntrinsicEventProps[Name];
+};
 /**
  * Props understood specially by intrinsic JSX elements.
  *
  * This stays separate from Props so component-level prop bags can remain
  * intentionally generic while JSX element usage gets stronger contracts.
  */
-interface IntrinsicProps extends IntrinsicEventProps {
-  key?: string | number | symbol;
+interface IntrinsicProps
+  extends IntrinsicEventProps, CapturedIntrinsicEventProps {
+  /** JSX keys are string or number; symbol keys stay in the generic Props bag. */
+  key?: string | number;
   children?: unknown;
   /**
    * Leaves descendant DOM ownership to an imperative widget after mount.
    * Askr will continue updating the host element's props, events, and ref.
    */
   imperativeChildren?: boolean;
+  /** Raw HTML for the element's content, written as given (not escaped). */
+  dangerouslySetInnerHTML?: { __html: string | null | undefined } | null;
   class?: ReactiveProp<IntrinsicClassValue>;
   className?: ReactiveProp<IntrinsicClassValue>;
   style?: ReactiveProp<IntrinsicStyleValue>;
@@ -102,13 +201,24 @@ interface IntrinsicProps extends IntrinsicEventProps {
   hidden?: ReactiveProp<IntrinsicBooleanValue>;
   dir?: ReactiveProp<IntrinsicTextValue>;
   lang?: ReactiveProp<IntrinsicTextValue>;
-  contentEditable?: ReactiveProp<IntrinsicTextValue>;
-  draggable?: ReactiveProp<IntrinsicTextValue>;
+  contentEditable?: ReactiveProp<IntrinsicEnumeratedValue>;
+  draggable?: ReactiveProp<IntrinsicEnumeratedValue>;
   enterKeyHint?: ReactiveProp<IntrinsicTextValue>;
   inputMode?: ReactiveProp<IntrinsicTextValue>;
-  spellCheck?: ReactiveProp<IntrinsicTextValue>;
+  spellCheck?: ReactiveProp<IntrinsicEnumeratedValue>;
+  writingSuggestions?: ReactiveProp<IntrinsicEnumeratedValue>;
   [attr: `aria-${string}`]: ReactiveProp<IntrinsicAriaValue>;
   [attr: `data-${string}`]: ReactiveProp<IntrinsicDataValue>;
+  /**
+   * Assigns the DOM property after the prefix, verbatim (`prop:srcObject`).
+   * Never written as an attribute, and never rendered by SSR.
+   */
+  [prop: `prop:${string}`]: unknown;
+  /**
+   * Writes the attribute after the prefix as named, where Askr would otherwise
+   * set a property (`attr:config` on a custom element).
+   */
+  [attr: `attr:${string}`]: ReactiveProp<IntrinsicDataValue>;
 }
 /**
  * Fallback intrinsic props for arbitrary tag names and dynamic prop spreads.
@@ -197,6 +307,11 @@ interface AnchorIntrinsicProps extends IntrinsicProps {
 }
 interface ButtonIntrinsicProps extends IntrinsicProps {
   disabled?: ReactiveProp<IntrinsicBooleanValue>;
+  formAction?: ReactiveProp<IntrinsicTextValue>;
+  formEncType?: ReactiveProp<IntrinsicTextValue>;
+  formMethod?: ReactiveProp<IntrinsicTextValue>;
+  formNoValidate?: ReactiveProp<IntrinsicBooleanValue>;
+  formTarget?: ReactiveProp<IntrinsicTextValue>;
   name?: ReactiveProp<IntrinsicTextValue>;
   type?: ReactiveProp<IntrinsicTextValue>;
   value?: ReactiveProp<IntrinsicFormValue>;
@@ -215,10 +330,17 @@ interface ImageIntrinsicProps extends IntrinsicProps {
   width?: ReactiveProp<IntrinsicTextLikeValue>;
 }
 interface InputIntrinsicProps extends IntrinsicProps {
+  formAction?: ReactiveProp<IntrinsicTextValue>;
+  formEncType?: ReactiveProp<IntrinsicTextValue>;
+  formMethod?: ReactiveProp<IntrinsicTextValue>;
+  formNoValidate?: ReactiveProp<IntrinsicBooleanValue>;
+  formTarget?: ReactiveProp<IntrinsicTextValue>;
   autoComplete?: ReactiveProp<IntrinsicTextValue>;
   autocomplete?: ReactiveProp<IntrinsicTextValue>;
   checked?: ReactiveProp<IntrinsicBooleanValue>;
   disabled?: ReactiveProp<IntrinsicBooleanValue>;
+  /** Sets the `indeterminate` property; there is no attribute to render. */
+  indeterminate?: ReactiveProp<IntrinsicBooleanValue>;
   maxLength?: ReactiveProp<IntrinsicNumberValue>;
   maxlength?: ReactiveProp<IntrinsicNumberValue>;
   minLength?: ReactiveProp<IntrinsicNumberValue>;
@@ -240,13 +362,56 @@ type OutputIntrinsicProps = StructuredContentIntrinsicProps<{
   name?: ReactiveProp<IntrinsicTextValue>;
 }>;
 type SvgPresentationIntrinsicAllowedProps = {
+  alignmentBaseline?: ReactiveProp<IntrinsicTextLikeValue>;
+  baselineShift?: ReactiveProp<IntrinsicTextLikeValue>;
+  clipPath?: ReactiveProp<IntrinsicTextLikeValue>;
   clipRule?: ReactiveProp<IntrinsicTextValue>;
+  colorInterpolation?: ReactiveProp<IntrinsicTextLikeValue>;
+  colorInterpolationFilters?: ReactiveProp<IntrinsicTextLikeValue>;
+  colorRendering?: ReactiveProp<IntrinsicTextLikeValue>;
+  dominantBaseline?: ReactiveProp<IntrinsicTextLikeValue>;
   fill?: ReactiveProp<IntrinsicTextValue>;
+  fillOpacity?: ReactiveProp<IntrinsicTextLikeValue>;
   fillRule?: ReactiveProp<IntrinsicTextValue>;
+  floodColor?: ReactiveProp<IntrinsicTextLikeValue>;
+  floodOpacity?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontFamily?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontSize?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontSizeAdjust?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontStretch?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontStyle?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontVariant?: ReactiveProp<IntrinsicTextLikeValue>;
+  fontWeight?: ReactiveProp<IntrinsicTextLikeValue>;
+  imageRendering?: ReactiveProp<IntrinsicTextLikeValue>;
+  letterSpacing?: ReactiveProp<IntrinsicTextLikeValue>;
+  lightingColor?: ReactiveProp<IntrinsicTextLikeValue>;
+  markerEnd?: ReactiveProp<IntrinsicTextLikeValue>;
+  markerMid?: ReactiveProp<IntrinsicTextLikeValue>;
+  markerStart?: ReactiveProp<IntrinsicTextLikeValue>;
+  maskType?: ReactiveProp<IntrinsicTextLikeValue>;
+  paintOrder?: ReactiveProp<IntrinsicTextLikeValue>;
+  pointerEvents?: ReactiveProp<IntrinsicTextLikeValue>;
+  shapeRendering?: ReactiveProp<IntrinsicTextLikeValue>;
+  stopColor?: ReactiveProp<IntrinsicTextLikeValue>;
+  stopOpacity?: ReactiveProp<IntrinsicTextLikeValue>;
   stroke?: ReactiveProp<IntrinsicTextValue>;
+  strokeDasharray?: ReactiveProp<IntrinsicTextLikeValue>;
+  strokeDashoffset?: ReactiveProp<IntrinsicTextLikeValue>;
   strokeLinecap?: ReactiveProp<IntrinsicTextValue>;
   strokeLinejoin?: ReactiveProp<IntrinsicTextValue>;
+  strokeMiterlimit?: ReactiveProp<IntrinsicTextLikeValue>;
+  strokeOpacity?: ReactiveProp<IntrinsicTextLikeValue>;
   strokeWidth?: ReactiveProp<IntrinsicTextLikeValue>;
+  textAnchor?: ReactiveProp<IntrinsicTextLikeValue>;
+  textDecoration?: ReactiveProp<IntrinsicTextLikeValue>;
+  textOverflow?: ReactiveProp<IntrinsicTextLikeValue>;
+  textRendering?: ReactiveProp<IntrinsicTextLikeValue>;
+  transformOrigin?: ReactiveProp<IntrinsicTextLikeValue>;
+  unicodeBidi?: ReactiveProp<IntrinsicTextLikeValue>;
+  vectorEffect?: ReactiveProp<IntrinsicTextLikeValue>;
+  whiteSpace?: ReactiveProp<IntrinsicTextLikeValue>;
+  wordSpacing?: ReactiveProp<IntrinsicTextLikeValue>;
+  writingMode?: ReactiveProp<IntrinsicTextLikeValue>;
 };
 type SvgIntrinsicProps = StructuredContentIntrinsicProps<
   SvgPresentationIntrinsicAllowedProps & {
@@ -310,7 +475,7 @@ interface TextareaIntrinsicProps extends IntrinsicProps {
   rows?: ReactiveProp<IntrinsicNumberValue>;
   value?: ReactiveProp<IntrinsicTextValue>;
 }
-interface KnownIntrinsicElementProps {
+interface KnownIntrinsicElementPropsBase {
   a: AnchorIntrinsicProps;
   article: LayoutIntrinsicProps;
   aside: LayoutIntrinsicProps;
@@ -363,6 +528,15 @@ interface KnownIntrinsicElementProps {
   tr: LayoutIntrinsicProps;
   ul: LayoutIntrinsicProps;
 }
+type WithElementRef<Props, Target extends Element> = {
+  [Key in keyof Props]: Key extends 'ref' ? IntrinsicRef<Target> : Props[Key];
+};
+type KnownIntrinsicElementProps = {
+  [Tag in keyof KnownIntrinsicElementPropsBase]: WithElementRef<
+    KnownIntrinsicElementPropsBase[Tag],
+    IntrinsicElementForTag<Tag>
+  >;
+};
 /** 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`. */
@@ -382,22 +556,11 @@ interface JSXElement {
   /** Optional key (normalized by runtime) */
   key?: string | number | null;
 }
-declare global {
-  namespace JSX {
-    interface Element extends JSXElement {
-      readonly __askrJsxElementBrand?: never;
-    }
-    interface IntrinsicElements extends KnownIntrinsicElementProps {}
-    interface ElementAttributesProperty {
-      props: Props;
-    }
-    interface ElementChildrenAttribute {
-      children: unknown;
-    }
-  }
-}
 export {
   IntrinsicFallbackProps,
+  MathMLExtraTag,
+  IntrinsicRef,
+  IntrinsicElementForTag,
   JSXElementType,
   JSXComponent,
   KnownIntrinsicElementProps,

package/dist/error-boundary-Bpwofwps.js

@@ -0,0 +1,293 @@
+import { F as logger, I as isDevelopmentEnvironment, d as recordUndo, s as requireInstance } from "./instance-BAnfmXOR.js";
+import { i as isFragmentType, n as Fragment, r as STATIC_CHILDREN, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
+import { c as onCommit, o as hookSlot } from "./hooks-BimKStr4.js";
+/** Explicitly adopted DOM node, used by an error-boundary fallback. */
+const NATIVE_TYPE = Symbol.for("askr.core.native");
+/**
+* Element type rendering its children in place but owned by `props.owner`:
+* portal content lives at its host's position and in its writer's lifetime.
+*/
+const OWNED_TYPE = Symbol.for("askr.core.owned");
+function propsOf(vnode) {
+	const props = vnode.props ?? {};
+	if (props.children === void 0 && vnode.children !== void 0) return {
+		...props,
+		children: vnode.children
+	};
+	return props;
+}
+function keyOf(vnode) {
+	const key = vnode.key ?? vnode.props?.key;
+	return key === null || key === void 0 ? void 0 : key;
+}
+function isHostNode(value) {
+	return typeof Node !== "undefined" && value instanceof Node;
+}
+/** A function child's result treats nested functions as values. */
+function functionChildOutput(value) {
+	if (typeof value === "function") return null;
+	if (Array.isArray(value)) {
+		const mapped = value.map(functionChildOutput);
+		if (value[STATIC_CHILDREN]) Object.defineProperty(mapped, STATIC_CHILDREN, { value: true });
+		return mapped;
+	}
+	if (value && typeof value === "object") {
+		const vnode = value;
+		if (isFragmentType(vnode.type)) {
+			const props = propsOf(vnode);
+			return {
+				...vnode,
+				props: {
+					...props,
+					children: functionChildOutput(props.children)
+				}
+			};
+		}
+	}
+	return value;
+}
+/** The descriptor's identity for matching against a previous render. */
+function descriptorType(child) {
+	switch (child.kind) {
+		case 0: return child.tag;
+		case 2: return child.fn;
+		case 7: return child.node;
+		default: return child.kind;
+	}
+}
+function normalizeChildren(value, out = []) {
+	if (value === null || value === void 0 || typeof value === "boolean") return out;
+	switch (typeof value) {
+		case "string":
+			out.push({
+				kind: 1,
+				key: void 0,
+				text: value
+			});
+			return out;
+		case "number":
+		case "bigint":
+			out.push({
+				kind: 1,
+				key: void 0,
+				text: String(value)
+			});
+			return out;
+		case "function":
+			out.push({
+				kind: 4,
+				key: void 0,
+				fn: value
+			});
+			return out;
+		case "object": break;
+		default:
+			out.push({
+				kind: 1,
+				key: void 0,
+				text: String(value)
+			});
+			return out;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) normalizeChildren(item, out);
+		return out;
+	}
+	if (isHostNode(value)) return out;
+	const vnode = value;
+	const type = vnode.type;
+	if (type === void 0) {
+		if (Symbol.iterator in value) {
+			for (const item of value) normalizeChildren(item, out);
+			return out;
+		}
+		return out;
+	}
+	const key = keyOf(vnode);
+	if (typeof type === "string") out.push({
+		kind: 0,
+		key,
+		tag: type,
+		props: propsOf(vnode)
+	});
+	else if (typeof type === "function") out.push({
+		kind: 2,
+		key,
+		fn: type,
+		props: propsOf(vnode)
+	});
+	else if (type === OWNED_TYPE) {
+		const props = propsOf(vnode);
+		out.push({
+			kind: 3,
+			key,
+			children: props.children,
+			owner: props.owner
+		});
+	} else if (isFragmentType(type)) out.push({
+		kind: 3,
+		key,
+		children: propsOf(vnode).children
+	});
+	else if (type === NATIVE_TYPE) out.push({
+		kind: 7,
+		key: void 0,
+		node: propsOf(vnode).node
+	});
+	else throw new Error(`[Askr] Unknown element type: ${String(type)}`);
+	return out;
+}
+//#endregion
+//#region src/core/api/error-boundary.ts
+function boundaryState(slot) {
+	return {
+		caught: slot.caught,
+		error: slot.error,
+		resetKey: slot.resetKey
+	};
+}
+function restoreBoundaryState(slot, previous) {
+	slot.caught = previous.caught;
+	slot.error = previous.error;
+	slot.resetKey = previous.resetKey;
+}
+const boundarySlots = /* @__PURE__ */ new WeakMap();
+const recoveryHolds = /* @__PURE__ */ new WeakMap();
+/** The nearest ErrorBoundary above `owner`, or null. */
+function nearestErrorBoundary(owner) {
+	for (let current = owner?.parent ?? null; current; current = current.parent) if (boundarySlots.has(current)) return current;
+	return null;
+}
+/**
+* While `boundary` shows its fallback, defer `release` until the boundary
+* commits a recovery or ends. Returns false (and does not call `release`)
+* when the boundary is not showing a fallback.
+*/
+function holdUntilBoundaryRecovers(boundary, release) {
+	if (boundary.disposed || !boundarySlots.get(boundary)?.caught) return false;
+	let holds = recoveryHolds.get(boundary);
+	if (!holds) {
+		holds = /* @__PURE__ */ new Set();
+		recoveryHolds.set(boundary, holds);
+		boundary.onCleanup(() => releaseHolds(boundary));
+	}
+	holds.add(release);
+	return true;
+}
+function releaseHolds(boundary) {
+	const holds = recoveryHolds.get(boundary);
+	if (!holds) return;
+	recoveryHolds.delete(boundary);
+	for (const release of holds) release();
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message || error.name;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+function element(type, props) {
+	if (Array.isArray(props.children)) Object.defineProperty(props.children, STATIC_CHILDREN, { value: true });
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type,
+		props,
+		key: null
+	};
+}
+function defaultFallback(error, reset) {
+	return element("div", {
+		role: "alert",
+		"data-askr-error-boundary": "true",
+		style: {
+			boxSizing: "border-box",
+			padding: "1rem",
+			border: "1px solid currentColor",
+			borderRadius: "0.75rem",
+			display: "grid",
+			gap: "0.75rem",
+			maxWidth: "100%"
+		},
+		children: [
+			element("strong", { children: "Something went wrong while rendering this view." }),
+			element("p", {
+				style: { margin: "0" },
+				children: "The app recovered into a visible fallback so the error is not hidden in the console."
+			}),
+			element("details", {
+				open: isDevelopmentEnvironment(),
+				children: [element("summary", { children: "Error details" }), element("pre", {
+					style: {
+						margin: "0",
+						whiteSpace: "pre-wrap",
+						wordBreak: "break-word"
+					},
+					children: errorMessage(error)
+				})]
+			}),
+			element("button", {
+				type: "button",
+				onClick: reset,
+				children: "Try again"
+			})
+		]
+	});
+}
+function ErrorBoundary(props) {
+	const instance = requireInstance("ErrorBoundary()");
+	const slot = hookSlot(instance, "errorBoundary", () => ({
+		caught: false,
+		error: void 0,
+		resetKey: props.resetKey
+	}));
+	if (!Object.is(slot.resetKey, props.resetKey)) {
+		const previous = boundaryState(slot);
+		recordUndo(() => restoreBoundaryState(slot, previous));
+		slot.resetKey = props.resetKey;
+		slot.caught = false;
+		slot.error = void 0;
+	}
+	const previousBoundary = instance.boundary;
+	instance.boundary = (error) => {
+		if (slot.caught && Object.is(slot.resetKey, props.resetKey)) return false;
+		const previous = boundaryState(slot);
+		recordUndo(() => restoreBoundaryState(slot, previous));
+		slot.resetKey = props.resetKey;
+		slot.caught = true;
+		slot.error = error;
+		try {
+			props.onError?.(error);
+		} catch (hookError) {
+			logger.error("[Askr] ErrorBoundary onError handler threw:", hookError);
+		}
+		logger.error("[Askr] ErrorBoundary caught render error:", error);
+		return true;
+	};
+	recordUndo(() => {
+		instance.boundary = previousBoundary;
+	});
+	boundarySlots.set(instance, slot);
+	if (!slot.caught) {
+		if (recoveryHolds.has(instance)) onCommit(instance, () => releaseHolds(instance));
+		return {
+			$$typeof: ELEMENT_TYPE,
+			type: Fragment,
+			props: { children: props.children },
+			key: null
+		};
+	}
+	const reset = () => {
+		if (!slot.caught) return;
+		slot.caught = false;
+		slot.error = void 0;
+		instance.computation.invalidate();
+	};
+	const fallback = props.fallback;
+	const output = typeof fallback === "function" ? fallback(slot.error, reset) : fallback ?? defaultFallback(slot.error, reset);
+	return typeof Node !== "undefined" && output instanceof Node ? element(NATIVE_TYPE, { node: output }) : output;
+}
+//#endregion
+export { descriptorType as a, OWNED_TYPE as i, holdUntilBoundaryRecovers as n, functionChildOutput as o, nearestErrorBoundary as r, normalizeChildren as s, ErrorBoundary as t };