@askrjs/askr 0.0.28 → 0.0.30

package/dist/foundations/interactions/interaction-policy.js

@@ -1 +1,122 @@
-import{pressable as v}from"./pressable.js";import{composeHandlers as p}from"../utilities/compose-handlers.js";import{composeRefs as H}from"../utilities/compose-ref.js";import{mergeProps as d}from"../utilities/merge-props.js";function y({isNative:r,disabled:n,onPress:e,ref:t}){function f(o){if(n){o.preventDefault?.();return}e?.(o)}if(r)return{disabled:n||void 0,onClick:o=>f(o),ref:t};const c=v({disabled:n,isNativeButton:!1,onPress:o=>f(o)});return{...c,"aria-disabled":n||void 0,tabIndex:n?-1:c.tabIndex??0,ref:t}}function g(r,n,e){let t=d(r,n);e&&(t=d(t,e));for(const i in t){if(!i.startsWith("on"))continue;const s=n?.[i],m=e?.[i],u=r?.[i];if(s||m||u){const a=l=>typeof l=="function"?l:void 0;t[i]=p(a(s),p(a(m),a(u)))}}const f=r?.ref,c=e?.ref,o=n?.ref;return t.ref=H(f,c,o),t}export{y as applyInteractionPolicy,g as mergeInteractionProps};
+import { pressable } from "./pressable.js";
+import { composeHandlers } from "../utilities/compose-handlers.js";
+import { composeRefs } from "../utilities/compose-ref.js";
+import { mergeProps } from "../utilities/merge-props.js";
+//#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,
+		"aria-disabled": disabled || void 0,
+		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) {
+	let out = mergeProps(childProps, policyProps);
+	if (userProps) out = mergeProps(out, userProps);
+	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 { applyInteractionPolicy, mergeInteractionProps };
+
+//# sourceMappingURL=interaction-policy.js.map

package/dist/foundations/interactions/interaction-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-policy.js","names":["mergePropsBase"],"sources":["../../../src/foundations/interactions/interaction-policy.ts"],"sourcesContent":["/**\n * INTERACTION POLICY (FRAMEWORK LAW)\n *\n * This is THE ONLY way to create interactive elements. Components MUST NOT\n * implement interaction logic directly.\n *\n * INVARIANTS (ENFORCED):\n * 1. \"Press\" is the semantic. Click/touch/Enter/Space are implementation details.\n * 2. Disabled is enforced exactly once, here. Components may not check disabled.\n * 3. Keyboard handling is automatic. Components may not add onKeyDown for activation.\n * 4. Native elements opt out of polyfills, not semantics.\n * 5. asChild may replace the host element, not interaction behavior.\n * 6. This policy is the SINGLE SOURCE OF TRUTH for interactive behavior.\n *\n * DESIGN:\n * - Single public function: applyInteractionPolicy\n * - Returns props that compose via mergeProps\n * - Delegates to pressable for mechanics\n * - Enforces disabled once and only once\n * - No configuration beyond disabled and native element type\n *\n * PIT OF SUCCESS:\n * ✓ Can't bypass policy (only way to get interaction behavior)\n * ✓ Can't duplicate disabled checks (enforced once, here)\n * ✓ Can't write custom keyboard handlers for buttons (policy owns it)\n * ✓ Composes via mergeProps (standard props)\n * ✓ Wrong usage is impossible (no escape hatch)\n *\n * USAGE:\n *   function Button({ onPress, disabled }) {\n *     const interaction = applyInteractionPolicy({\n *       isNative: true,\n *       disabled,\n *       onPress\n *     });\n *\n *     return <button {...interaction}>Click me</button>;\n *   }\n *\n * MISUSE EXAMPLE (PREVENTED):\n *   ❌ Button checking disabled again:\n *      function Button({ disabled, onPress }) {\n *        if (disabled) return; // NO! Policy handles this\n *        const interaction = applyInteractionPolicy(...);\n *      }\n *\n *   ❌ Custom keyboard handler:\n *      function Button({ onPress }) {\n *        const interaction = applyInteractionPolicy(...);\n *        return <button {...interaction} onKeyDown={...}>; // NO! Policy owns this\n *      }\n *\n *   ❌ Direct event handler:\n *      <button onClick={onPress}>; // NO! Use applyInteractionPolicy\n */\n\nimport { pressable } from './pressable';\nimport { composeHandlers } from '../utilities/compose-handlers';\nimport { composeRefs, Ref } from '../utilities/compose-ref';\nimport { mergeProps as mergePropsBase } from '../utilities/merge-props';\n\nexport interface InteractionPolicyInput {\n  /** Whether the host element is a native interactive element (button, a, etc) */\n  isNative: boolean;\n  /** Disabled state - checked ONLY here, never in components */\n  disabled: boolean;\n  /** User-provided press handler - semantic action, not DOM event */\n  onPress?: (e: Event) => void;\n  /** Optional ref to compose */\n  ref?: Ref<unknown>;\n}\n\n/**\n * THE interaction policy. Components MUST use this, NEVER implement\n * interaction logic directly.\n */\nexport function applyInteractionPolicy({\n  isNative,\n  disabled,\n  onPress,\n  ref,\n}: InteractionPolicyInput) {\n  // Disabled is enforced exactly once, here.\n  // Components downstream may NOT check disabled.\n  function invokePress(e: Event) {\n    if (disabled) {\n      e.preventDefault?.();\n      return;\n    }\n    onPress?.(e);\n  }\n\n  if (isNative) {\n    return {\n      disabled: disabled || undefined,\n      onClick: (e: Event) => invokePress(e),\n      ref,\n    };\n  }\n\n  // Non-native elements get full button semantics\n  const interaction = pressable({\n    disabled,\n    isNativeButton: false,\n    onPress: (e) => invokePress(e as Event),\n  });\n\n  return {\n    ...interaction,\n    'aria-disabled': disabled || undefined,\n    tabIndex: disabled ? -1 : (interaction.tabIndex ?? 0),\n    ref,\n  };\n}\n\n/**\n * Merge rule for Slot / asChild\n *\n * Precedence:\n *   policy → user → child\n *\n * Event handlers are composed (policy first).\n * Refs are always composed.\n * Policy props MUST take precedence to enforce invariants.\n */\nexport function mergeInteractionProps(\n  childProps: Record<string, unknown>,\n  policyProps: Record<string, unknown>,\n  userProps?: Record<string, unknown>\n) {\n  let out = mergePropsBase(childProps, policyProps);\n  if (userProps) out = mergePropsBase(out, userProps);\n\n  // Ensure policy handlers always run first\n  for (const k in out) {\n    if (!k.startsWith('on')) continue;\n\n    const policyHandler = policyProps?.[k];\n    const userHandler = userProps?.[k];\n    const childHandler = childProps?.[k];\n\n    if (policyHandler || userHandler || childHandler) {\n      const toHandler = (h: unknown) =>\n        typeof h === 'function'\n          ? (h as (...args: readonly unknown[]) => void)\n          : undefined;\n\n      out[k] = composeHandlers(\n        toHandler(policyHandler),\n        composeHandlers(toHandler(userHandler), toHandler(childHandler))\n      );\n    }\n  }\n\n  const childRef = childProps?.ref as Ref<unknown> | undefined;\n  const userRef = userProps?.ref as Ref<unknown> | undefined;\n  const policyRef = policyProps?.ref as Ref<unknown> | undefined;\n\n  out.ref = composeRefs(childRef, userRef, policyRef);\n\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,SAAgB,uBAAuB,EACrC,UACA,UACA,SACA,OACyB;CAGzB,SAAS,YAAY,GAAU;AAC7B,MAAI,UAAU;AACZ,KAAE,kBAAkB;AACpB;;AAEF,YAAU,EAAE;;AAGd,KAAI,SACF,QAAO;EACL,UAAU,YAAY;EACtB,UAAU,MAAa,YAAY,EAAE;EACrC;EACD;CAIH,MAAM,cAAc,UAAU;EAC5B;EACA,gBAAgB;EAChB,UAAU,MAAM,YAAY,EAAW;EACxC,CAAC;AAEF,QAAO;EACL,GAAG;EACH,iBAAiB,YAAY;EAC7B,UAAU,WAAW,KAAM,YAAY,YAAY;EACnD;EACD;;;;;;;;;;;;AAaH,SAAgB,sBACd,YACA,aACA,WACA;CACA,IAAI,MAAMA,WAAe,YAAY,YAAY;AACjD,KAAI,UAAW,OAAMA,WAAe,KAAK,UAAU;AAGnD,MAAK,MAAM,KAAK,KAAK;AACnB,MAAI,CAAC,EAAE,WAAW,KAAK,CAAE;EAEzB,MAAM,gBAAgB,cAAc;EACpC,MAAM,cAAc,YAAY;EAChC,MAAM,eAAe,aAAa;AAElC,MAAI,iBAAiB,eAAe,cAAc;GAChD,MAAM,aAAa,MACjB,OAAO,MAAM,aACR,IACD;AAEN,OAAI,KAAK,gBACP,UAAU,cAAc,EACxB,gBAAgB,UAAU,YAAY,EAAE,UAAU,aAAa,CAAC,CACjE;;;CAIL,MAAM,WAAW,YAAY;CAC7B,MAAM,UAAU,WAAW;CAC3B,MAAM,YAAY,aAAa;AAE/B,KAAI,MAAM,YAAY,UAAU,SAAS,UAAU;AAEnD,QAAO"}

package/dist/foundations/interactions/pressable.d.ts

@@ -1,3 +1,6 @@
+import { DefaultPreventable, KeyboardLikeEvent, PropagationStoppable } from "../utilities/event-types.js";
+
+//#region src/foundations/interactions/pressable.d.ts
 /**
  * pressable
  *
@@ -30,25 +33,29 @@
  *    - Held Enter/Space will fire onPress repeatedly (matches native button)
  *    - No debouncing or repeat prevention (platform parity)
  */
-export interface PressableOptions {
-    disabled?: boolean;
-    onPress?: (e: PressEvent) => void;
-    /**
-     * Whether the host is a native button. Defaults to false.
-     */
-    isNativeButton?: boolean;
+interface PressableOptions {
+  disabled?: boolean;
+  onPress?: (e: PressEvent) => void;
+  /**
+   * Whether the host is a native button. Defaults to false.
+   */
+  isNativeButton?: boolean;
 }
-import type { DefaultPreventable, KeyboardLikeEvent, PropagationStoppable } from '../utilities/event-types';
 type PressEvent = DefaultPreventable & PropagationStoppable;
-export interface PressableResult {
-    onClick: (e: PressEvent) => void;
-    disabled?: true;
-    role?: 'button';
-    tabIndex?: number;
-    onKeyDown?: (e: KeyboardLikeEvent) => void;
-    onKeyUp?: (e: KeyboardLikeEvent) => void;
-    'aria-disabled'?: 'true';
+interface PressableResult {
+  onClick: (e: PressEvent) => void;
+  disabled?: true;
+  role?: 'button';
+  tabIndex?: number;
+  onKeyDown?: (e: KeyboardLikeEvent) => void;
+  onKeyUp?: (e: KeyboardLikeEvent) => void;
+  'aria-disabled'?: 'true';
 }
-export declare function pressable({ disabled, onPress, isNativeButton, }: PressableOptions): PressableResult;
-export {};
+declare function pressable({
+  disabled,
+  onPress,
+  isNativeButton
+}: PressableOptions): PressableResult;
+//#endregion
+export { PressableOptions, PressableResult, pressable };
 //# sourceMappingURL=pressable.d.ts.map

package/dist/foundations/interactions/pressable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pressable.d.ts","sourceRoot":"","sources":["../../../src/foundations/interactions/pressable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAGlC,KAAK,UAAU,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC;IACjC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC3C,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACzC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,OAAO,EACP,cAAsB,GACvB,EAAE,gBAAgB,GAAG,eAAe,CAwDpC"}
+{"version":3,"file":"pressable.d.ts","names":[],"sources":["../../../src/foundations/interactions/pressable.ts"],"mappings":";;;;;;AAiCA;;;;;;;;;;;AAakC;;;;;AAKlC;;;;;;;;;;;;;UAlBiB,gBAAA;EACf,QAAA;EACA,OAAA,IAAW,CAAA,EAAG,UAAA;EAqBD;;;EAjBb,cAAA;AAAA;AAAA,KAUG,UAAA,GAAa,kBAAA,GAAqB,oBAAA;AAAA,UAEtB,eAAA;EACf,OAAA,GAAU,CAAA,EAAG,UAAA;EACb,QAAA;EACA,IAAA;EACA,QAAA;EACA,SAAA,IAAa,CAAA,EAAG,iBAAA;EAChB,OAAA,IAAW,CAAA,EAAG,iBAAA;EACd,eAAA;AAAA;AAAA,iBAGc,SAAA,CAAA;EACd,QAAA;EACA,OAAA;EACA;AAAA,GACC,gBAAA,GAAmB,eAAA"}

package/dist/foundations/interactions/pressable.js

@@ -1 +1,51 @@
-import{ariaDisabled as o}from"../utilities/aria.js";function u({disabled:n,onPress:e,isNativeButton:f=!1}){const r={onClick:t=>{if(n){t.preventDefault?.(),t.stopPropagation?.();return}e?.(t)}};return f?(n&&(r.disabled=!0,Object.assign(r,o(n))),r):(r.role="button",r.tabIndex=n?-1:0,r.onKeyDown=t=>{if(n){t.preventDefault?.(),t.stopPropagation?.();return}if(t.key==="Enter"){t.preventDefault?.(),e?.(t);return}t.key===" "&&t.preventDefault?.()},r.onKeyUp=t=>{if(n){t.preventDefault?.(),t.stopPropagation?.();return}t.key===" "&&(t.preventDefault?.(),e?.(t))},n&&Object.assign(r,o(n)),r)}export{u as pressable};
+import { ariaDisabled } from "../utilities/aria.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
+export { pressable };
+
+//# sourceMappingURL=pressable.js.map

package/dist/foundations/interactions/pressable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pressable.js","names":[],"sources":["../../../src/foundations/interactions/pressable.ts"],"sourcesContent":["/**\n * pressable\n *\n * Interaction helper that produces VNode props for 'press' semantics.\n * - Pure and deterministic: no DOM construction or mutation here\n * - The runtime owns event attachment and scheduling\n * - This helper returns plain props (handlers) intended to be attached by the runtime\n *\n * Behaviour:\n * - For native buttons: only an `onClick` prop is provided (no ARIA or keyboard shims)\n * - For non-button elements: add `role=\"button\"` and `tabIndex` and keyboard handlers\n * - Activation: `Enter` activates on keydown, `Space` activates on keyup (matches native button)\n * - Disabled: handlers short-circuit and `aria-disabled` is set for all hosts\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Activation Timing (Platform Parity)\n *    - Enter fires on keydown (immediate response)\n *    - Space fires on keyup (allows cancel by moving focus, matches native)\n *    - Space keydown prevents scroll (matches native button behavior)\n *\n * 2. Disabled Enforcement Strategy\n *    - Native buttons: Use HTML `disabled` attribute (platform-enforced non-interactivity)\n *                     AND `aria-disabled` (consistent a11y signaling)\n *    - Non-native: Use `tabIndex=-1` (removes from tab order)\n *                  AND `aria-disabled` (signals disabled state to AT)\n *    - Click handler short-circuits as defense-in-depth (prevents leaked focus issues)\n *\n * 3. Key Repeat Behavior\n *    - Held Enter/Space will fire onPress repeatedly (matches native button)\n *    - No debouncing or repeat prevention (platform parity)\n */\n\nexport interface PressableOptions {\n  disabled?: boolean;\n  onPress?: (e: PressEvent) => void;\n  /**\n   * Whether the host is a native button. Defaults to false.\n   */\n  isNativeButton?: boolean;\n}\n\nimport type {\n  DefaultPreventable,\n  KeyboardLikeEvent,\n  PropagationStoppable,\n} from '../utilities/event-types';\nimport { ariaDisabled } from '../utilities/aria';\n\ntype PressEvent = DefaultPreventable & PropagationStoppable;\n\nexport interface PressableResult {\n  onClick: (e: PressEvent) => void;\n  disabled?: true;\n  role?: 'button';\n  tabIndex?: number;\n  onKeyDown?: (e: KeyboardLikeEvent) => void;\n  onKeyUp?: (e: KeyboardLikeEvent) => void;\n  'aria-disabled'?: 'true';\n}\n\nexport function pressable({\n  disabled,\n  onPress,\n  isNativeButton = false,\n}: PressableOptions): PressableResult {\n  const props: PressableResult = {\n    onClick: (e) => {\n      if (disabled) {\n        e.preventDefault?.();\n        e.stopPropagation?.();\n        return;\n      }\n      onPress?.(e);\n    },\n  };\n\n  if (isNativeButton) {\n    if (disabled) {\n      props.disabled = true;\n      Object.assign(props, ariaDisabled(disabled));\n    }\n    return props;\n  }\n\n  props.role = 'button';\n  props.tabIndex = disabled ? -1 : 0;\n\n  props.onKeyDown = (e) => {\n    if (disabled) {\n      e.preventDefault?.();\n      e.stopPropagation?.();\n      return;\n    }\n\n    if (e.key === 'Enter') {\n      e.preventDefault?.();\n      onPress?.(e);\n      return;\n    }\n\n    if (e.key === ' ') {\n      // Prevent scrolling while Space is held.\n      e.preventDefault?.();\n    }\n  };\n\n  props.onKeyUp = (e) => {\n    if (disabled) {\n      e.preventDefault?.();\n      e.stopPropagation?.();\n      return;\n    }\n    if (e.key === ' ') {\n      e.preventDefault?.();\n      onPress?.(e);\n    }\n  };\n\n  if (disabled) Object.assign(props, ariaDisabled(disabled));\n  return props;\n}\n"],"mappings":";;AA6DA,SAAgB,UAAU,EACxB,UACA,SACA,iBAAiB,SACmB;CACpC,MAAM,QAAyB,EAC7B,UAAU,MAAM;AACd,MAAI,UAAU;AACZ,KAAE,kBAAkB;AACpB,KAAE,mBAAmB;AACrB;;AAEF,YAAU,EAAE;IAEf;AAED,KAAI,gBAAgB;AAClB,MAAI,UAAU;AACZ,SAAM,WAAW;AACjB,UAAO,OAAO,OAAO,aAAa,SAAS,CAAC;;AAE9C,SAAO;;AAGT,OAAM,OAAO;AACb,OAAM,WAAW,WAAW,KAAK;AAEjC,OAAM,aAAa,MAAM;AACvB,MAAI,UAAU;AACZ,KAAE,kBAAkB;AACpB,KAAE,mBAAmB;AACrB;;AAGF,MAAI,EAAE,QAAQ,SAAS;AACrB,KAAE,kBAAkB;AACpB,aAAU,EAAE;AACZ;;AAGF,MAAI,EAAE,QAAQ,IAEZ,GAAE,kBAAkB;;AAIxB,OAAM,WAAW,MAAM;AACrB,MAAI,UAAU;AACZ,KAAE,kBAAkB;AACpB,KAAE,mBAAmB;AACrB;;AAEF,MAAI,EAAE,QAAQ,KAAK;AACjB,KAAE,kBAAkB;AACpB,aAAU,EAAE;;;AAIhB,KAAI,SAAU,QAAO,OAAO,OAAO,aAAa,SAAS,CAAC;AAC1D,QAAO"}

package/dist/foundations/interactions/roving-focus.d.ts

@@ -1,117 +1,52 @@
-/**
- * rovingFocus
- *
- * Single tab stop navigation with arrow-key control.
- *
- * INVARIANTS:
- * 1. Only one item in the group is reachable via Tab (single tab stop)
- * 2. Arrow keys move focus within the group
- * 3. Orientation determines which arrow keys are active
- * 4. Looping is opt-in
- * 5. Disabled items are skipped
- * 6. Returns props objects, never factories (composes via mergeProps)
- *
- * DESIGN:
- * - Container gets onKeyDown for arrow navigation
- * - Each item gets tabIndex based on current selection
- * - Navigation logic is pure - caller controls focus application
- * - Disabled check happens per-item via predicate
- *
- * PIT OF SUCCESS:
- * ✓ Can't accidentally break tab order (tabIndex assigned correctly)
- * ✓ Can't duplicate navigation logic (single source)
- * ✓ Composes via mergeProps (all standard props)
- * ✓ Type-safe - invalid indices caught at call site
- *
- * USAGE:
- *   const nav = rovingFocus({
- *     currentIndex: 0,
- *     itemCount: 3,
- *     orientation: 'horizontal',
- *     onNavigate: setIndex
- *   });
- *
- *   <div {...nav.container}>
- *     <button {...nav.item(0)}>First</button>
- *     <button {...nav.item(1)}>Second</button>
- *   </div>
- *
- * MISUSE EXAMPLE (PREVENTED):
- *   ❌ Can't forget to set tabIndex - returned in item props
- *   ❌ Can't create conflicting arrow handlers - mergeProps composes
- *   ❌ Can't skip disabled items incorrectly - logic is internal
- */
-import type { KeyboardLikeEvent } from '../utilities/event-types';
-export type Orientation = 'horizontal' | 'vertical' | 'both';
-export interface RovingFocusOptions {
-    /**
-     * Current focused index
-     */
-    currentIndex: number;
-    /**
-     * Total number of items
-     */
-    itemCount: number;
-    /**
-     * Navigation orientation
-     * - horizontal: ArrowLeft/ArrowRight
-     * - vertical: ArrowUp/ArrowDown
-     * - both: all arrow keys
-     */
-    orientation?: Orientation;
-    /**
-     * Whether to loop when reaching the end
-     */
-    loop?: boolean;
-    /**
-     * Callback when navigation occurs
-     */
-    onNavigate?: (index: number) => void;
-    /**
-     * Optional disabled state check per index
-     */
-    isDisabled?: (index: number) => boolean;
+import { KeyboardLikeEvent } from "../utilities/event-types.js";
+
+//#region src/foundations/interactions/roving-focus.d.ts
+type Orientation = 'horizontal' | 'vertical' | 'both';
+interface RovingFocusOptions {
+  /**
+   * Current focused index
+   */
+  currentIndex: number;
+  /**
+   * Total number of items
+   */
+  itemCount: number;
+  /**
+   * Navigation orientation
+   * - horizontal: ArrowLeft/ArrowRight
+   * - vertical: ArrowUp/ArrowDown
+   * - both: all arrow keys
+   */
+  orientation?: Orientation;
+  /**
+   * Whether to loop when reaching the end
+   */
+  loop?: boolean;
+  /**
+   * Callback when navigation occurs
+   */
+  onNavigate?: (index: number) => void;
+  /**
+   * Optional disabled state check per index
+   */
+  isDisabled?: (index: number) => boolean;
 }
-export interface RovingFocusResult {
-    /**
-     * Props for the container element (composes via mergeProps)
-     */
-    container: {
-        onKeyDown: (e: KeyboardLikeEvent) => void;
-    };
-    /**
-     * Generate props for an item at the given index (composes via mergeProps)
-     */
-    item: (index: number) => {
-        tabIndex: number;
-        'data-roving-index': number;
-    };
+interface RovingFocusResult {
+  /**
+   * Props for the container element (composes via mergeProps)
+   */
+  container: {
+    onKeyDown: (e: KeyboardLikeEvent) => void;
+  };
+  /**
+   * Generate props for an item at the given index (composes via mergeProps)
+   */
+  item: (index: number) => {
+    tabIndex: number;
+    'data-roving-index': number;
+  };
 }
-export declare function rovingFocus(options: RovingFocusOptions): RovingFocusResult;
-/**
- * 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>
- *   );
- * }
- */
+declare function rovingFocus(options: RovingFocusOptions): RovingFocusResult;
+//#endregion
+export { Orientation, RovingFocusOptions, RovingFocusResult, rovingFocus };
 //# sourceMappingURL=roving-focus.d.ts.map

package/dist/foundations/interactions/roving-focus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roving-focus.d.ts","sourceRoot":"","sources":["../../../src/foundations/interactions/roving-focus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,UAAU,GAAG,MAAM,CAAC;AAE7D,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAErC;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,SAAS,EAAE;QACT,SAAS,EAAE,CAAC,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;KAC3C,CAAC;IAEF;;OAEG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,mBAAmB,EAAE,MAAM,CAAC;KAC7B,CAAC;CACH;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CAkE1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}
+{"version":3,"file":"roving-focus.d.ts","names":[],"sources":["../../../src/foundations/interactions/roving-focus.ts"],"mappings":";;;KA8CY,WAAA;AAAA,UAEK,kBAAA;;;;EAIf,YAAA;;;;EAKA,SAAA;;;;;;;EAQA,WAAA,GAAc,WAAA;;;;EAKd,IAAA;;;;EAKA,UAAA,IAAc,KAAA;;;;EAKd,UAAA,IAAc,KAAA;AAAA;AAAA,UAGC,iBAAA;;;;EAIf,SAAA;IACE,SAAA,GAAY,CAAA,EAAG,iBAAA;EAAA;;;;EAMjB,IAAA,GAAO,KAAA;IACL,QAAA;IACA,mBAAA;EAAA;AAAA;AAAA,iBAIY,WAAA,CAAY,OAAA,EAAS,kBAAA,GAAqB,iBAAA"}

package/dist/foundations/interactions/roving-focus.js

@@ -1 +1,71 @@
-function v(u){const{currentIndex:r,itemCount:e,orientation:o="horizontal",loop:d=!1,onNavigate:l,isDisabled:c}=u;function f(t,i){let n=t+i;if(d)n<0&&(n=e-1),n>=e&&(n=0);else if(n<0||n>=e)return;return c?.(n)?n===t?void 0:f(n,i):n}function s(t){const{key:i}=t;let n;if((o==="horizontal"||o==="both")&&(i==="ArrowRight"&&(n=1),i==="ArrowLeft"&&(n=-1)),(o==="vertical"||o==="both")&&(i==="ArrowDown"&&(n=1),i==="ArrowUp"&&(n=-1)),n===void 0)return;const a=f(r,n);a!==void 0&&(t.preventDefault?.(),t.stopPropagation?.(),l?.(a))}return{container:{onKeyDown:s},item:t=>({tabIndex:t===r?0:-1,"data-roving-index":t})}}export{v as rovingFocus};
+//#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 + direction;
+		if (loop) {
+			if (next < 0) next = itemCount - 1;
+			if (next >= itemCount) next = 0;
+		} else if (next < 0 || next >= itemCount) return void 0;
+		if (isDisabled?.(next)) {
+			if (next === from) return void 0;
+			return findNextIndex(next, direction);
+		}
+		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
+export { rovingFocus };
+
+//# sourceMappingURL=roving-focus.js.map

package/dist/foundations/interactions/roving-focus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roving-focus.js","names":[],"sources":["../../../src/foundations/interactions/roving-focus.ts"],"sourcesContent":["/**\n * rovingFocus\n *\n * Single tab stop navigation with arrow-key control.\n *\n * INVARIANTS:\n * 1. Only one item in the group is reachable via Tab (single tab stop)\n * 2. Arrow keys move focus within the group\n * 3. Orientation determines which arrow keys are active\n * 4. Looping is opt-in\n * 5. Disabled items are skipped\n * 6. Returns props objects, never factories (composes via mergeProps)\n *\n * DESIGN:\n * - Container gets onKeyDown for arrow navigation\n * - Each item gets tabIndex based on current selection\n * - Navigation logic is pure - caller controls focus application\n * - Disabled check happens per-item via predicate\n *\n * PIT OF SUCCESS:\n * ✓ Can't accidentally break tab order (tabIndex assigned correctly)\n * ✓ Can't duplicate navigation logic (single source)\n * ✓ Composes via mergeProps (all standard props)\n * ✓ Type-safe - invalid indices caught at call site\n *\n * USAGE:\n *   const nav = rovingFocus({\n *     currentIndex: 0,\n *     itemCount: 3,\n *     orientation: 'horizontal',\n *     onNavigate: setIndex\n *   });\n *\n *   <div {...nav.container}>\n *     <button {...nav.item(0)}>First</button>\n *     <button {...nav.item(1)}>Second</button>\n *   </div>\n *\n * MISUSE EXAMPLE (PREVENTED):\n *   ❌ Can't forget to set tabIndex - returned in item props\n *   ❌ Can't create conflicting arrow handlers - mergeProps composes\n *   ❌ Can't skip disabled items incorrectly - logic is internal\n */\n\nimport type { KeyboardLikeEvent } from '../utilities/event-types';\n\nexport type Orientation = 'horizontal' | 'vertical' | 'both';\n\nexport interface RovingFocusOptions {\n  /**\n   * Current focused index\n   */\n  currentIndex: number;\n\n  /**\n   * Total number of items\n   */\n  itemCount: number;\n\n  /**\n   * Navigation orientation\n   * - horizontal: ArrowLeft/ArrowRight\n   * - vertical: ArrowUp/ArrowDown\n   * - both: all arrow keys\n   */\n  orientation?: Orientation;\n\n  /**\n   * Whether to loop when reaching the end\n   */\n  loop?: boolean;\n\n  /**\n   * Callback when navigation occurs\n   */\n  onNavigate?: (index: number) => void;\n\n  /**\n   * Optional disabled state check per index\n   */\n  isDisabled?: (index: number) => boolean;\n}\n\nexport interface RovingFocusResult {\n  /**\n   * Props for the container element (composes via mergeProps)\n   */\n  container: {\n    onKeyDown: (e: KeyboardLikeEvent) => void;\n  };\n\n  /**\n   * Generate props for an item at the given index (composes via mergeProps)\n   */\n  item: (index: number) => {\n    tabIndex: number;\n    'data-roving-index': number;\n  };\n}\n\nexport function rovingFocus(options: RovingFocusOptions): RovingFocusResult {\n  const {\n    currentIndex,\n    itemCount,\n    orientation = 'horizontal',\n    loop = false,\n    onNavigate,\n    isDisabled,\n  } = options;\n\n  function findNextIndex(from: number, direction: 1 | -1): number | undefined {\n    let next = from + direction;\n\n    // Handle looping\n    if (loop) {\n      if (next < 0) next = itemCount - 1;\n      if (next >= itemCount) next = 0;\n    } else {\n      if (next < 0 || next >= itemCount) return undefined;\n    }\n\n    // Skip disabled items\n    if (isDisabled?.(next)) {\n      // Recursively find the next non-disabled item\n      if (next === from) return undefined; // Prevent infinite loop\n      return findNextIndex(next, direction);\n    }\n\n    return next;\n  }\n\n  function handleKeyDown(e: KeyboardLikeEvent) {\n    const { key } = e;\n\n    let direction: 1 | -1 | undefined;\n\n    if (orientation === 'horizontal' || orientation === 'both') {\n      if (key === 'ArrowRight') direction = 1;\n      if (key === 'ArrowLeft') direction = -1;\n    }\n\n    if (orientation === 'vertical' || orientation === 'both') {\n      if (key === 'ArrowDown') direction = 1;\n      if (key === 'ArrowUp') direction = -1;\n    }\n\n    if (direction === undefined) return;\n\n    const nextIndex = findNextIndex(currentIndex, direction);\n    if (nextIndex === undefined) return;\n\n    e.preventDefault?.();\n    e.stopPropagation?.();\n\n    onNavigate?.(nextIndex);\n  }\n\n  return {\n    container: {\n      onKeyDown: handleKeyDown,\n    },\n    item: (index: number) => ({\n      tabIndex: index === currentIndex ? 0 : -1,\n      'data-roving-index': index,\n    }),\n  };\n}\n\n/**\n * USAGE EXAMPLE:\n *\n * function Menu() {\n *   const [focusIndex, setFocusIndex] = state(0);\n *   const items = ['File', 'Edit', 'View'];\n *\n *   const navigation = rovingFocus({\n *     currentIndex: focusIndex(),\n *     itemCount: items.length,\n *     orientation: 'horizontal',\n *     loop: true,\n *     onNavigate: setFocusIndex,\n *   });\n *\n *   return (\n *     <div {...navigation.container}>\n *       {items.map((label, index) => (\n *         <button {...navigation.item(index)}>\n *           {label}\n *         </button>\n *       ))}\n *     </div>\n *   );\n * }\n */\n"],"mappings":";AAoGA,SAAgB,YAAY,SAAgD;CAC1E,MAAM,EACJ,cACA,WACA,cAAc,cACd,OAAO,OACP,YACA,eACE;CAEJ,SAAS,cAAc,MAAc,WAAuC;EAC1E,IAAI,OAAO,OAAO;AAGlB,MAAI,MAAM;AACR,OAAI,OAAO,EAAG,QAAO,YAAY;AACjC,OAAI,QAAQ,UAAW,QAAO;aAE1B,OAAO,KAAK,QAAQ,UAAW,QAAO;AAI5C,MAAI,aAAa,KAAK,EAAE;AAEtB,OAAI,SAAS,KAAM,QAAO;AAC1B,UAAO,cAAc,MAAM,UAAU;;AAGvC,SAAO;;CAGT,SAAS,cAAc,GAAsB;EAC3C,MAAM,EAAE,QAAQ;EAEhB,IAAI;AAEJ,MAAI,gBAAgB,gBAAgB,gBAAgB,QAAQ;AAC1D,OAAI,QAAQ,aAAc,aAAY;AACtC,OAAI,QAAQ,YAAa,aAAY;;AAGvC,MAAI,gBAAgB,cAAc,gBAAgB,QAAQ;AACxD,OAAI,QAAQ,YAAa,aAAY;AACrC,OAAI,QAAQ,UAAW,aAAY;;AAGrC,MAAI,cAAc,OAAW;EAE7B,MAAM,YAAY,cAAc,cAAc,UAAU;AACxD,MAAI,cAAc,OAAW;AAE7B,IAAE,kBAAkB;AACpB,IAAE,mBAAmB;AAErB,eAAa,UAAU;;AAGzB,QAAO;EACL,WAAW,EACT,WAAW,eACZ;EACD,OAAO,WAAmB;GACxB,UAAU,UAAU,eAAe,IAAI;GACvC,qBAAqB;GACtB;EACF"}

package/dist/foundations/state/controllable.d.ts

@@ -1,43 +1,22 @@
-/**
- * controllable
- *
- * Small utilities for controlled vs uncontrolled components. These helpers are
- * intentionally minimal and do not manage state themselves; they help component
- * implementations make correct decisions about when to call `onChange` vs
- * update internal state.
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Controlled Detection
- *    A value is "controlled" if it is not `undefined`.
- *    This matches React conventions and is SSR-safe.
- *
- * 2. onChange Timing
- *    - Controlled mode: onChange called immediately, no internal update
- *    - Uncontrolled mode: internal state updated first, then onChange called
- *    This ensures onChange sees the new value in both modes.
- *
- * 3. Value Equality
- *    controllableState uses Object.is() to prevent unnecessary onChange calls.
- *    This is intentional — strict equality, no deep comparison.
- */
-import { type State } from '../../runtime/state';
-export declare function isControlled<T>(value: T | undefined): value is T;
-export declare function resolveControllable<T>(value: T | undefined, defaultValue: T): {
-    value: T;
-    isControlled: boolean;
+import { State } from "../../runtime/state.js";
+
+//#region src/foundations/state/controllable.d.ts
+declare function isControlled<T>(value: T | undefined): value is T;
+declare function resolveControllable<T>(value: T | undefined, defaultValue: T): {
+  value: T;
+  isControlled: boolean;
 };
-export declare function makeControllable<T>(options: {
-    value: T | undefined;
-    defaultValue: T;
-    onChange?: (next: T) => void;
-    setInternal?: (next: T) => void;
+declare function makeControllable<T>(options: {
+  value: T | undefined;
+  defaultValue: T;
+  onChange?: (next: T) => void;
+  setInternal?: (next: T) => void;
 }): {
-    set: (next: T) => void;
-    isControlled: boolean;
+  set: (next: T) => void;
+  isControlled: boolean;
 };
-export type ControllableState<T> = State<T> & {
-    isControlled: boolean;
+type ControllableState<T> = State<T> & {
+  isControlled: boolean;
 };
 /**
  * controllableState
@@ -45,9 +24,11 @@ export type ControllableState<T> = State<T> & {
  * Hook-like primitive that mirrors `state()` semantics while supporting
  * controlled/uncontrolled behavior.
  */
-export declare function controllableState<T>(options: {
-    value: T | undefined;
-    defaultValue: T;
-    onChange?: (next: T) => void;
+declare function controllableState<T>(options: {
+  value: T | undefined;
+  defaultValue: T;
+  onChange?: (next: T) => void;
 }): ControllableState<T>;
+//#endregion
+export { ControllableState, controllableState, isControlled, makeControllable, resolveControllable };
 //# sourceMappingURL=controllable.d.ts.map

package/dist/foundations/state/controllable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controllable.d.ts","sourceRoot":"","sources":["../../../src/foundations/state/controllable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAS,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,KAAK,IAAI,CAAC,CAEhE;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,CAAC,GAAG,SAAS,EACpB,YAAY,EAAE,CAAC,GACd;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAMrC;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE;IAC3C,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;CACjC;gBAIoB,CAAC;;EAUrB;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG;IAAE,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE;IAC5C,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC;IACrB,YAAY,EAAE,CAAC,CAAC;IAChB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;CAC9B,GAAG,iBAAiB,CAAC,CAAC,CAAC,CA4BvB"}
+{"version":3,"file":"controllable.d.ts","names":[],"sources":["../../../src/foundations/state/controllable.ts"],"mappings":";;;iBA0BgB,YAAA,GAAA,CAAgB,KAAA,EAAO,CAAA,eAAgB,KAAA,IAAS,CAAA;AAAA,iBAIhD,mBAAA,GAAA,CACd,KAAA,EAAO,CAAA,cACP,YAAA,EAAc,CAAA;EACX,KAAA,EAAO,CAAA;EAAG,YAAA;AAAA;AAAA,iBAQC,gBAAA,GAAA,CAAoB,OAAA;EAClC,KAAA,EAAO,CAAA;EACP,YAAA,EAAc,CAAA;EACd,QAAA,IAAY,IAAA,EAAM,CAAA;EAClB,WAAA,IAAe,IAAA,EAAM,CAAA;AAAA;cAKF,CAAA;;;KAYT,iBAAA,MAAuB,KAAA,CAAM,CAAA;EAAO,YAAA;AAAA;;;;;;;iBAQhC,iBAAA,GAAA,CAAqB,OAAA;EACnC,KAAA,EAAO,CAAA;EACP,YAAA,EAAc,CAAA;EACd,QAAA,IAAY,IAAA,EAAM,CAAA;AAAA,IAChB,iBAAA,CAAkB,CAAA"}