@askrjs/askr 0.0.28 → 0.0.29

package/dist/foundations/structures/layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/foundations/structures/layout.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,MAAM,IAAI,CACxC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,KAC9B,OAAO,CAAC;AAEb,wBAAgB,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,IACnD,WAAW,OAAO,EAAE,QAAQ,CAAC,aAItC"}
+{"version":3,"file":"layout.d.ts","names":[],"sources":["../../../src/foundations/structures/layout.tsx"],"mappings":";;AAwBA;;;;;;;;;;AAIA;;;;;;;;;;;;KAJY,eAAA,gBACV,KAAA,EAAO,CAAA;EAAM,QAAA;AAAA;AAAA,iBAGC,MAAA,YAAA,CAAmB,MAAA,EAAQ,eAAA,CAAgB,CAAA,KACjD,QAAA,YAAoB,KAAA,GAAQ,CAAA"}

package/dist/foundations/structures/layout.js

@@ -1 +1,13 @@
-function o(r){return(t,e)=>{const n={...e,children:t};return r(n)}}export{o as layout};
+//#region src/foundations/structures/layout.tsx
+function layout(Layout) {
+	return (children, props) => {
+		return Layout({
+			...props,
+			children
+		});
+	};
+}
+//#endregion
+export { layout };
+
+//# sourceMappingURL=layout.js.map

package/dist/foundations/structures/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","names":[],"sources":["../../../src/foundations/structures/layout.tsx"],"sourcesContent":["/**\n * Layout helper.\n *\n * A layout is just a normal component that wraps children.\n * Persistence and reuse are handled by the runtime via component identity.\n *\n * This helper exists purely for readability and convention.\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Return Type is Opaque (unknown)\n *    Layout components return `unknown` to remain runtime-agnostic.\n *    The runtime owns concrete JSX element types.\n *\n * 2. Children Positioning\n *    Layout receives children as first argument (router-friendly).\n *    Props come second. This matches route layout conventions where\n *    children represent the nested route content.\n *\n * 3. Props Spreading\n *    Props are spread into the layout component. This is intentional\n *    and deterministic — no merging or composition.\n */\n\nexport type LayoutComponent<P = object> = (\n  props: P & { children?: unknown }\n) => unknown;\n\nexport function layout<P = object>(Layout: LayoutComponent<P>) {\n  return (children?: unknown, props?: P) => {\n    const mergedProps = { ...props, children } as P & { children?: unknown };\n    return Layout(mergedProps);\n  };\n}\n"],"mappings":";AA4BA,SAAgB,OAAmB,QAA4B;AAC7D,SAAQ,UAAoB,UAAc;AAExC,SAAO,OAAO;GADQ,GAAG;GAAO;GAClB,CAAY"}

package/dist/foundations/structures/portal.d.ts

@@ -1,3 +1,4 @@
+//#region src/foundations/structures/portal.d.ts
 /**
  * Portal / Host primitive.
  *
@@ -19,15 +20,21 @@
  *    owns the concrete type. This prevents foundations from assuming JSX.Element
  *    or DOM node types, maintaining runtime-agnostic portability.
  */
-export interface Portal<T = unknown> {
-    /** Mount point — rendered exactly once */
-    (): unknown;
-    /** Render content into the portal */
-    render(props: {
-        children?: T;
-    }): unknown;
+interface Portal<T = unknown> {
+  /** Mount point — rendered exactly once */
+  (): unknown;
+  /** Render content into the portal */
+  render(props: {
+    children?: T;
+  }): unknown;
 }
-export declare function definePortal<T = unknown>(): Portal<T>;
-export declare function _resetDefaultPortal(): void;
-export declare const DefaultPortal: Portal<unknown>;
+interface PortalProps {
+  children?: unknown;
+}
+declare function definePortal<T = unknown>(): Portal<T>;
+declare function _resetDefaultPortal(): void;
+declare const DefaultPortal: Portal<unknown>;
+declare function Portal(props: PortalProps): null;
+//#endregion
+export { DefaultPortal, Portal, PortalProps, definePortal };
 //# sourceMappingURL=portal.d.ts.map

package/dist/foundations/structures/portal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../../src/foundations/structures/portal.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,MAAM,CAAC,CAAC,GAAG,OAAO;IACjC,0CAA0C;IAC1C,IAAI,OAAO,CAAC;IAEZ,qCAAqC;IACrC,MAAM,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,EAAE,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC;CAC1C;AAED,wBAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CA6CrD;AAaD,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAOD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,OAAO,CAUtC,CAAC"}
+{"version":3,"file":"portal.d.ts","names":[],"sources":["../../../src/foundations/structures/portal.tsx"],"mappings":";;AA8BA;;;;;;;;;;;AAQA;;;;;AAgCA;;;;UAxCiB,MAAA;EAwC4B;EAAA;EAAQ;EAnCnD,MAAA,CAAO,KAAA;IAAS,QAAA,GAAW,CAAA;EAAA;AAAA;AAAA,UAGZ,WAAA;EACf,QAAA;AAAA;AAAA,iBA+Bc,YAAA,aAAA,CAAA,GAA6B,MAAA,CAAO,CAAA;AAAA,iBA0DpC,mBAAA,CAAA;AAAA,cASH,aAAA,EAAe,MAAA;AAAA,iBAYZ,MAAA,CAAO,KAAA,EAAO,WAAA"}

package/dist/foundations/structures/portal.js

@@ -1 +1,105 @@
-function f(){if(typeof createPortalSlot=="function"){let o=function(){return n.read()};const n=createPortalSlot();return o.render=function(a){return n.write(a.children),null},o}let r=!1,t;function e(){return r=!0,t}return e.render=function(n){return r&&(t=n.children),null},e}let l;function i(){l=void 0}function u(){return l||(l=f()),l}const d=(()=>{function r(){const t=u()();return t===void 0?null:t}return r.render=function(e){return u().render(e),null},r})();export{d as DefaultPortal,i as _resetDefaultPortal,f as definePortal};
+import { markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead } from "../../runtime/readable.js";
+//#region src/foundations/structures/portal.tsx
+/**
+* Portal / Host primitive.
+*
+* Foundations remain runtime-agnostic: a portal is an explicit read/write slot.
+* Scheduling and attachment are owned by the runtime when `createPortalSlot`
+* exists; otherwise this falls back to a local slot (deterministic, but does
+* not schedule updates).
+*
+* POLICY DECISIONS (LOCKED):
+*
+* 1. Local Mutable State
+*    Foundations may use local mutable state ONLY to model deterministic slots,
+*    never to coordinate timing, effects, or ordering. The fallback mode uses
+*    closure-local `mounted` and `value` variables which are non-escaping and
+*    deterministic.
+*
+* 2. Return Type Philosophy
+*    Portal call signatures return `unknown` (intentionally opaque). The runtime
+*    owns the concrete type. This prevents foundations from assuming JSX.Element
+*    or DOM node types, maintaining runtime-agnostic portability.
+*/
+function createPortalSlot() {
+	let currentValue;
+	const source = (() => {
+		recordReadableRead(source);
+		return currentValue;
+	});
+	return {
+		read() {
+			return source();
+		},
+		write(value) {
+			if (Object.is(currentValue, value)) return;
+			currentValue = value;
+			markReadableDerivedSubscribersDirty(source);
+			markReactivePropsDirtySource(source);
+			notifyReadableReaders(source);
+		}
+	};
+}
+function definePortal() {
+	if (typeof createPortalSlot === "function") {
+		const slot = createPortalSlot();
+		function PortalHost() {
+			return slot.read();
+		}
+		PortalHost.render = function PortalRender(props) {
+			slot.write(props.children);
+			return null;
+		};
+		return PortalHost;
+	}
+	let mounted = false;
+	let value;
+	function PortalHostFallback() {
+		mounted = true;
+		return value;
+	}
+	PortalHostFallback.render = function PortalRenderFallback(props) {
+		if (!mounted) return null;
+		value = props.children;
+		return null;
+	};
+	return PortalHostFallback;
+}
+/**
+* Default Portal Singleton
+*
+* POLICY (LOCKED):
+* There is exactly one default portal per runtime.
+* Tests must reset it explicitly using _resetDefaultPortal().
+* This ensures consistent portal behavior across the application
+* while maintaining test isolation.
+*/
+let _defaultPortal;
+function ensureDefaultPortal() {
+	if (!_defaultPortal) _defaultPortal = definePortal();
+	return _defaultPortal;
+}
+const DefaultPortal = (() => {
+	function Host() {
+		const v = ensureDefaultPortal()();
+		return v === void 0 ? null : v;
+	}
+	Host.render = function Render(props) {
+		ensureDefaultPortal().render(props);
+		return null;
+	};
+	return Host;
+})();
+function Portal(props) {
+	DefaultPortal.render(props);
+	return null;
+}
+/**
+* NOTE:
+* createPortalSlot is a runtime primitive.
+* It owns scheduling, consistency, and SSR behavior.
+*/
+//#endregion
+export { DefaultPortal, Portal, definePortal };
+
+//# sourceMappingURL=portal.js.map

package/dist/foundations/structures/portal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.js","names":[],"sources":["../../../src/foundations/structures/portal.tsx"],"sourcesContent":["/**\n * Portal / Host primitive.\n *\n * Foundations remain runtime-agnostic: a portal is an explicit read/write slot.\n * Scheduling and attachment are owned by the runtime when `createPortalSlot`\n * exists; otherwise this falls back to a local slot (deterministic, but does\n * not schedule updates).\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Local Mutable State\n *    Foundations may use local mutable state ONLY to model deterministic slots,\n *    never to coordinate timing, effects, or ordering. The fallback mode uses\n *    closure-local `mounted` and `value` variables which are non-escaping and\n *    deterministic.\n *\n * 2. Return Type Philosophy\n *    Portal call signatures return `unknown` (intentionally opaque). The runtime\n *    owns the concrete type. This prevents foundations from assuming JSX.Element\n *    or DOM node types, maintaining runtime-agnostic portability.\n */\n\nimport {\n  markReactivePropsDirtySource,\n  markReadableDerivedSubscribersDirty,\n  notifyReadableReaders,\n  recordReadableRead,\n  type ReadableSource,\n} from '../../runtime/readable';\n\nexport interface Portal<T = unknown> {\n  /** Mount point — rendered exactly once */\n  (): unknown;\n\n  /** Render content into the portal */\n  render(props: { children?: T }): unknown;\n}\n\nexport interface PortalProps {\n  children?: unknown;\n}\n\nfunction createPortalSlot<T>(): {\n  read(): unknown;\n  write(value: T | undefined): void;\n} {\n  let currentValue: T | undefined;\n\n  const source = (() => {\n    recordReadableRead(source);\n    return currentValue;\n  }) as ReadableSource<T | undefined>;\n\n  return {\n    read() {\n      return source();\n    },\n    write(value: T | undefined) {\n      if (Object.is(currentValue, value)) {\n        return;\n      }\n\n      currentValue = value;\n      markReadableDerivedSubscribersDirty(source);\n      markReactivePropsDirtySource(source);\n      notifyReadableReaders(source);\n    },\n  };\n}\n\nexport function definePortal<T = unknown>(): Portal<T> {\n  // Using `typeof createPortalSlot` is safe even if the identifier is not\n  // defined at runtime (it returns 'undefined' rather than throwing).\n  if (typeof createPortalSlot === 'function') {\n    const slot = createPortalSlot<T>();\n\n    function PortalHost() {\n      return slot.read();\n    }\n\n    PortalHost.render = function PortalRender(props: { children?: T }) {\n      slot.write(props.children);\n      return null;\n    };\n\n    return PortalHost as Portal<T>;\n  }\n\n  // Deterministic local fallback (SSR/tests). No runtime scheduling.\n  // Writes are accepted only after the host has rendered at least once.\n  //\n  // CRITICAL BEHAVIOR:\n  // - Writes update local state but do NOT trigger re-renders\n  // - The portal host will reflect changes only when the component tree\n  //   re-renders for other reasons (e.g., parent state change)\n  // - This is safe for SSR and tests where rendering is synchronous\n  //   and externally controlled\n  // - In runtime mode, createPortalSlot handles scheduling automatically\n  let mounted = false;\n  let value: T | undefined;\n\n  function PortalHostFallback() {\n    mounted = true;\n    return value as unknown;\n  }\n\n  PortalHostFallback.render = function PortalRenderFallback(props: {\n    children?: T;\n  }) {\n    if (!mounted) return null;\n    value = props.children;\n    return null;\n  };\n\n  return PortalHostFallback as Portal<T>;\n}\n\n/**\n * Default Portal Singleton\n *\n * POLICY (LOCKED):\n * There is exactly one default portal per runtime.\n * Tests must reset it explicitly using _resetDefaultPortal().\n * This ensures consistent portal behavior across the application\n * while maintaining test isolation.\n */\nlet _defaultPortal: Portal<unknown> | undefined;\n\nexport function _resetDefaultPortal(): void {\n  _defaultPortal = undefined;\n}\n\nfunction ensureDefaultPortal(): Portal<unknown> {\n  if (!_defaultPortal) _defaultPortal = definePortal<unknown>();\n  return _defaultPortal;\n}\n\nexport const DefaultPortal: Portal<unknown> = (() => {\n  function Host() {\n    const v = ensureDefaultPortal()();\n    return v === undefined ? null : v;\n  }\n  Host.render = function Render(props: { children?: unknown }) {\n    ensureDefaultPortal().render(props);\n    return null;\n  };\n  return Host as Portal<unknown>;\n})();\n\nexport function Portal(props: PortalProps): null {\n  DefaultPortal.render(props);\n  return null;\n}\n\n/**\n * NOTE:\n * createPortalSlot is a runtime primitive.\n * It owns scheduling, consistency, and SSR behavior.\n */\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAS,mBAGP;CACA,IAAI;CAEJ,MAAM,gBAAgB;AACpB,qBAAmB,OAAO;AAC1B,SAAO;;AAGT,QAAO;EACL,OAAO;AACL,UAAO,QAAQ;;EAEjB,MAAM,OAAsB;AAC1B,OAAI,OAAO,GAAG,cAAc,MAAM,CAChC;AAGF,kBAAe;AACf,uCAAoC,OAAO;AAC3C,gCAA6B,OAAO;AACpC,yBAAsB,OAAO;;EAEhC;;AAGH,SAAgB,eAAuC;AAGrD,KAAI,OAAO,qBAAqB,YAAY;EAC1C,MAAM,OAAO,kBAAqB;EAElC,SAAS,aAAa;AACpB,UAAO,KAAK,MAAM;;AAGpB,aAAW,SAAS,SAAS,aAAa,OAAyB;AACjE,QAAK,MAAM,MAAM,SAAS;AAC1B,UAAO;;AAGT,SAAO;;CAaT,IAAI,UAAU;CACd,IAAI;CAEJ,SAAS,qBAAqB;AAC5B,YAAU;AACV,SAAO;;AAGT,oBAAmB,SAAS,SAAS,qBAAqB,OAEvD;AACD,MAAI,CAAC,QAAS,QAAO;AACrB,UAAQ,MAAM;AACd,SAAO;;AAGT,QAAO;;;;;;;;;;;AAYT,IAAI;AAMJ,SAAS,sBAAuC;AAC9C,KAAI,CAAC,eAAgB,kBAAiB,cAAuB;AAC7D,QAAO;;AAGT,MAAa,uBAAwC;CACnD,SAAS,OAAO;EACd,MAAM,IAAI,qBAAqB,EAAE;AACjC,SAAO,MAAM,SAAY,OAAO;;AAElC,MAAK,SAAS,SAAS,OAAO,OAA+B;AAC3D,uBAAqB,CAAC,OAAO,MAAM;AACnC,SAAO;;AAET,QAAO;IACL;AAEJ,SAAgB,OAAO,OAA0B;AAC/C,eAAc,OAAO,MAAM;AAC3B,QAAO"}

package/dist/foundations/structures/presence.d.ts

@@ -1,7 +1,8 @@
-import type { JSXElement } from '../../jsx';
-export interface PresenceProps {
-    present: boolean | (() => boolean);
-    children?: unknown;
+import { JSXElement } from "../../common/jsx.js";
+//#region src/foundations/structures/presence.d.ts
+interface PresenceProps {
+  present: boolean | (() => boolean);
+  children?: unknown;
 }
 /**
  * Presence
@@ -26,5 +27,10 @@ export interface PresenceProps {
  *    children are removed immediately. Animation must be layered above
  *    this primitive.
  */
-export declare function Presence({ present, children, }: PresenceProps): JSXElement | null;
+declare function Presence({
+  present,
+  children
+}: PresenceProps): JSXElement | null;
+//#endregion
+export { Presence, PresenceProps };
 //# sourceMappingURL=presence.d.ts.map

package/dist/foundations/structures/presence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../../../src/foundations/structures/presence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,OAAO,EACP,QAAQ,GACT,EAAE,aAAa,GAAG,UAAU,GAAG,IAAI,CAYnC"}
+{"version":3,"file":"presence.d.ts","names":[],"sources":["../../../src/foundations/structures/presence.ts"],"mappings":";;UAGiB,aAAA;EACf,OAAA;EACA,QAAA;AAAA;;;;;AA0BF;;;;;;;;;;;;;;;;;;;iBAAgB,QAAA,CAAA;EACd,OAAA;EACA;AAAA,GACC,aAAA,GAAgB,UAAA"}

package/dist/foundations/structures/presence.js

@@ -1 +1,39 @@
-import"../../jsx/index.js";import{Fragment as t,ELEMENT_TYPE as o}from"../../common/jsx.js";function m({present:e,children:n}){return(typeof e=="function"?e():!!e)?{$$typeof:o,type:t,props:{children:n},key:null}:null}export{m as Presence};
+import { ELEMENT_TYPE, Fragment } from "../../common/jsx.js";
+import "../../jsx/index.js";
+//#region src/foundations/structures/presence.ts
+/**
+* Presence
+*
+* Structural policy primitive for conditional mount/unmount.
+* - No timers
+* - No animation coupling
+* - No DOM side-effects
+*
+* POLICY DECISIONS (LOCKED):
+*
+* 1. Present as Function
+*    Accepts boolean OR function to support lazy evaluation patterns.
+*    Function is called once per render. Use boolean form for static values.
+*
+* 2. Children Type
+*    `children` is intentionally `unknown` to remain runtime-agnostic.
+*    The runtime owns child normalization and validation.
+*
+* 3. Immediate Mount/Unmount
+*    No exit animations or transitions. When `present` becomes false,
+*    children are removed immediately. Animation must be layered above
+*    this primitive.
+*/
+function Presence({ present, children }) {
+	if (!(typeof present === "function" ? present() : Boolean(present))) return null;
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children },
+		key: null
+	};
+}
+//#endregion
+export { Presence };
+
+//# sourceMappingURL=presence.js.map

package/dist/foundations/structures/presence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.js","names":[],"sources":["../../../src/foundations/structures/presence.ts"],"sourcesContent":["import { ELEMENT_TYPE, Fragment } from '../../jsx';\nimport type { JSXElement } from '../../jsx';\n\nexport interface PresenceProps {\n  present: boolean | (() => boolean);\n  children?: unknown;\n}\n\n/**\n * Presence\n *\n * Structural policy primitive for conditional mount/unmount.\n * - No timers\n * - No animation coupling\n * - No DOM side-effects\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Present as Function\n *    Accepts boolean OR function to support lazy evaluation patterns.\n *    Function is called once per render. Use boolean form for static values.\n *\n * 2. Children Type\n *    `children` is intentionally `unknown` to remain runtime-agnostic.\n *    The runtime owns child normalization and validation.\n *\n * 3. Immediate Mount/Unmount\n *    No exit animations or transitions. When `present` becomes false,\n *    children are removed immediately. Animation must be layered above\n *    this primitive.\n */\nexport function Presence({\n  present,\n  children,\n}: PresenceProps): JSXElement | null {\n  const isPresent =\n    typeof present === 'function' ? present() : Boolean(present);\n  if (!isPresent) return null;\n\n  const element: JSXElement = {\n    $$typeof: ELEMENT_TYPE,\n    type: Fragment,\n    props: { children },\n    key: null,\n  };\n  return element;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,SAAS,EACvB,SACA,YACmC;AAGnC,KAAI,EADF,OAAO,YAAY,aAAa,SAAS,GAAG,QAAQ,QAAQ,EAC9C,QAAO;AAQvB,QAAO;EALL,UAAU;EACV,MAAM;EACN,OAAO,EAAE,UAAU;EACnB,KAAK;EAEA"}

package/dist/foundations/structures/slot.d.ts

@@ -1,11 +1,12 @@
-import type { JSXElement } from '../../jsx';
-export type SlotProps = {
-    asChild: true;
-    children: JSXElement;
-    [key: string]: unknown;
+import { JSXElement } from "../../common/jsx.js";
+//#region src/foundations/structures/slot.d.ts
+type SlotProps = {
+  asChild: true;
+  children: JSXElement;
+  [key: string]: unknown;
 } | {
-    asChild?: false;
-    children?: unknown;
+  asChild?: false;
+  children?: unknown;
 };
 /**
  * Slot
@@ -27,5 +28,7 @@ export type SlotProps = {
  *    asChild=true requires exactly one JSXElement child (enforced by type).
  *    Runtime validates with isElement() check.
  */
-export declare function Slot(props: SlotProps): JSXElement | null;
+declare function Slot(props: SlotProps): JSXElement | null;
+//#endregion
+export { Slot, SlotProps };
 //# sourceMappingURL=slot.d.ts.map

package/dist/foundations/structures/slot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slot.d.ts","sourceRoot":"","sources":["../../../src/foundations/structures/slot.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,MAAM,SAAS,GACjB;IACE,OAAO,EAAE,IAAI,CAAC;IACd,QAAQ,EAAE,UAAU,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,GACD;IACE,OAAO,CAAC,EAAE,KAAK,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEN;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI,CAmBxD"}
+{"version":3,"file":"slot.d.ts","names":[],"sources":["../../../src/foundations/structures/slot.tsx"],"mappings":";;KAGY,SAAA;EAEN,OAAA;EACA,QAAA,EAAU,UAAA;EAAA,CACT,GAAA;AAAA;EAGD,OAAA;EACA,QAAA;AAAA;;;;;;;;AAuBN;;;;;;;;;;;;;iBAAgB,IAAA,CAAK,KAAA,EAAO,SAAA,GAAY,UAAA"}

package/dist/foundations/structures/slot.js

@@ -1 +1,41 @@
-import"../../jsx/index.js";import{isElement as l,cloneElement as r}from"../../jsx/utils.js";import{Fragment as i,ELEMENT_TYPE as o}from"../../common/jsx.js";function s(e){if(e.asChild){const{children:t,asChild:c,...n}=e;return l(t)?r(t,n):null}return{$$typeof:o,type:i,props:{children:e.children},key:null}}export{s as Slot};
+import { ELEMENT_TYPE, Fragment } from "../../common/jsx.js";
+import { cloneElement, isElement } from "../../jsx/utils.js";
+import "../../jsx/index.js";
+//#region src/foundations/structures/slot.tsx
+/**
+* Slot
+*
+* Structural primitive for prop forwarding patterns.
+*
+* POLICY DECISIONS (LOCKED):
+*
+* 1. asChild Pattern
+*    When asChild=true, merges props into the single child element.
+*    Child must be a valid JSXElement; non-element children return null.
+*    **Slot props override child props** (injection pattern).
+*
+* 2. Fallback Behavior
+*    When asChild=false, returns a Fragment (structural no-op).
+*    No DOM element is introduced.
+*
+* 3. Type Safety
+*    asChild=true requires exactly one JSXElement child (enforced by type).
+*    Runtime validates with isElement() check.
+*/
+function Slot(props) {
+	if (props.asChild) {
+		const { children, asChild: _asChild, ...rest } = props;
+		if (isElement(children)) return cloneElement(children, rest);
+		return null;
+	}
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: props.children },
+		key: null
+	};
+}
+//#endregion
+export { Slot };
+
+//# sourceMappingURL=slot.js.map

package/dist/foundations/structures/slot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.js","names":[],"sources":["../../../src/foundations/structures/slot.tsx"],"sourcesContent":["import { Fragment, cloneElement, isElement, ELEMENT_TYPE } from '../../jsx';\nimport type { JSXElement } from '../../jsx';\n\nexport type SlotProps =\n  | {\n      asChild: true;\n      children: JSXElement;\n      [key: string]: unknown;\n    }\n  | {\n      asChild?: false;\n      children?: unknown;\n    };\n\n/**\n * Slot\n *\n * Structural primitive for prop forwarding patterns.\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. asChild Pattern\n *    When asChild=true, merges props into the single child element.\n *    Child must be a valid JSXElement; non-element children return null.\n *    **Slot props override child props** (injection pattern).\n *\n * 2. Fallback Behavior\n *    When asChild=false, returns a Fragment (structural no-op).\n *    No DOM element is introduced.\n *\n * 3. Type Safety\n *    asChild=true requires exactly one JSXElement child (enforced by type).\n *    Runtime validates with isElement() check.\n */\nexport function Slot(props: SlotProps): JSXElement | null {\n  if (props.asChild) {\n    const { children, asChild: _asChild, ...rest } = props;\n\n    if (isElement(children)) {\n      return cloneElement(children, rest);\n    }\n    return null;\n  }\n\n  // Structural no-op: Slot does not introduce DOM\n  // Return a vnode object for the fragment with the internal element marker.\n  const element: JSXElement = {\n    $$typeof: ELEMENT_TYPE,\n    type: Fragment,\n    props: { children: props.children },\n    key: null,\n  };\n  return element;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,KAAK,OAAqC;AACxD,KAAI,MAAM,SAAS;EACjB,MAAM,EAAE,UAAU,SAAS,UAAU,GAAG,SAAS;AAEjD,MAAI,UAAU,SAAS,CACrB,QAAO,aAAa,UAAU,KAAK;AAErC,SAAO;;AAWT,QAAO;EALL,UAAU;EACV,MAAM;EACN,OAAO,EAAE,UAAU,MAAM,UAAU;EACnC,KAAK;EAEA"}

package/dist/foundations/structures.d.ts

@@ -1,14 +1,7 @@
-export { layout } from './structures/layout';
-export type { LayoutComponent } from './structures/layout';
-export { Slot } from './structures/slot';
-export type { SlotProps } from './structures/slot';
-export type { JSXElement } from '../jsx';
-export { Presence } from './structures/presence';
-export type { PresenceProps } from './structures/presence';
-export { definePortal, DefaultPortal } from './structures/portal';
-export type { Portal } from './structures/portal';
-export { createCollection } from './structures/collection';
-export type { Collection, CollectionItem } from './structures/collection';
-export { createLayer } from './structures/layer';
-export type { Layer, LayerManager, LayerOptions } from './structures/layer';
-//# sourceMappingURL=structures.d.ts.map
+import { JSXElement } from "../common/jsx.js";
+import { LayoutComponent, layout } from "./structures/layout.js";
+import { Slot, SlotProps } from "./structures/slot.js";
+import { Presence, PresenceProps } from "./structures/presence.js";
+import { DefaultPortal, Portal, PortalProps, definePortal } from "./structures/portal.js";
+import { Collection, CollectionItem, createCollection } from "./structures/collection.js";
+import { Layer, LayerManager, LayerOptions, createLayer } from "./structures/layer.js";

package/dist/foundations/structures.js

@@ -1 +1,6 @@
-import{layout as r}from"./structures/layout.js";import{Slot as f}from"./structures/slot.js";import{Presence as l}from"./structures/presence.js";import{DefaultPortal as p,definePortal as x}from"./structures/portal.js";import{createCollection as n}from"./structures/collection.js";import{createLayer as i}from"./structures/layer.js";export{p as DefaultPortal,l as Presence,f as Slot,n as createCollection,i as createLayer,x as definePortal,r as layout};
+import "./structures/portal.js";
+import "./structures/layout.js";
+import "./structures/slot.js";
+import "./structures/presence.js";
+import "./structures/collection.js";
+import "./structures/layer.js";

package/dist/foundations/utilities/aria.js

@@ -1 +1,11 @@
-function a(r){return r?{"aria-disabled":"true"}:{}}function i(r){return r===void 0?{}:{"aria-expanded":String(r)}}function n(r){return r===void 0?{}:{"aria-selected":String(r)}}export{a as ariaDisabled,i as ariaExpanded,n as ariaSelected};
+//#region src/foundations/utilities/aria.ts
+/**
+* Tiny aria helpers
+*/
+function ariaDisabled(disabled) {
+	return disabled ? { "aria-disabled": "true" } : {};
+}
+//#endregion
+export { ariaDisabled };
+
+//# sourceMappingURL=aria.js.map

package/dist/foundations/utilities/aria.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria.js","names":[],"sources":["../../../src/foundations/utilities/aria.ts"],"sourcesContent":["/**\n * Tiny aria helpers\n */\n\nexport function ariaDisabled(disabled?: boolean): { 'aria-disabled'?: 'true' } {\n  return disabled ? { 'aria-disabled': 'true' } : {};\n}\n\nexport function ariaExpanded(expanded?: boolean): {\n  'aria-expanded'?: 'true' | 'false';\n} {\n  return expanded === undefined\n    ? {}\n    : { 'aria-expanded': String(expanded) as 'true' | 'false' };\n}\n\nexport function ariaSelected(selected?: boolean): {\n  'aria-selected'?: 'true' | 'false';\n} {\n  return selected === undefined\n    ? {}\n    : { 'aria-selected': String(selected) as 'true' | 'false' };\n}\n"],"mappings":";;;;AAIA,SAAgB,aAAa,UAAkD;AAC7E,QAAO,WAAW,EAAE,iBAAiB,QAAQ,GAAG,EAAE"}

package/dist/foundations/utilities/compose-handlers.js

@@ -1 +1,20 @@
-function f(e){return typeof e=="object"&&e!==null&&"defaultPrevented"in e&&e.defaultPrevented===!0}function i(e,t,r){if(!e&&!t)return o;if(!e)return t;if(!t)return e;const u=r?.checkDefaultPrevented!==!1;return function(...n){e(...n),!(u&&f(n[0]))&&t(...n)}}function o(){}export{i as composeHandlers};
+//#region src/foundations/utilities/compose-handlers.ts
+function isDefaultPrevented(value) {
+	return typeof value === "object" && value !== null && "defaultPrevented" in value && value.defaultPrevented === true;
+}
+function composeHandlers(first, second, options) {
+	if (!first && !second) return noop;
+	if (!first) return second;
+	if (!second) return first;
+	const checkDefaultPrevented = options?.checkDefaultPrevented !== false;
+	return function composed(...args) {
+		first(...args);
+		if (checkDefaultPrevented && isDefaultPrevented(args[0])) return;
+		second(...args);
+	};
+}
+function noop() {}
+//#endregion
+export { composeHandlers };
+
+//# sourceMappingURL=compose-handlers.js.map

package/dist/foundations/utilities/compose-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose-handlers.js","names":[],"sources":["../../../src/foundations/utilities/compose-handlers.ts"],"sourcesContent":["/**\n * composeHandlers\n *\n * Compose two event handlers into one. The first handler runs, and unless it\n * calls `event.preventDefault()` (or sets `defaultPrevented`), the second\n * handler runs. This prevents accidental clobbering of child handlers when\n * injecting props.\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Execution Order\n *    First handler runs before second (injected before base).\n *    This allows injected handlers to prevent default behavior.\n *\n * 2. Default Prevention Check\n *    By default, checks `defaultPrevented` on first argument.\n *    Can be disabled via options.checkDefaultPrevented = false.\n *\n * 3. Undefined Handler Support\n *    Undefined handlers are skipped (no-op). This simplifies usage\n *    where handlers are optional.\n *\n * 4. Type Safety\n *    Args are readonly to prevent mutation. Return type matches input.\n */\n\nexport interface ComposeHandlersOptions {\n  /**\n   * When true (default), do not run the second handler if the first prevented default.\n   * When false, always run both handlers.\n   */\n  checkDefaultPrevented?: boolean;\n}\n\nfunction isDefaultPrevented(\n  value: unknown\n): value is { defaultPrevented: true } {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'defaultPrevented' in value &&\n    (value as { defaultPrevented?: boolean }).defaultPrevented === true\n  );\n}\n\nexport function composeHandlers<A extends readonly unknown[]>(\n  first?: (...args: A) => void,\n  second?: (...args: A) => void,\n  options?: ComposeHandlersOptions\n): (...args: A) => void {\n  // Fast path: if neither handler exists, return stable no-op\n  if (!first && !second) {\n    return noop as (...args: A) => void;\n  }\n\n  // Fast path: if only one handler exists, return it directly\n  if (!first) return second!;\n  if (!second) return first;\n\n  // Composition path: both handlers exist\n  const checkDefaultPrevented = options?.checkDefaultPrevented !== false;\n\n  return function composed(...args: A) {\n    first(...args);\n\n    if (checkDefaultPrevented && isDefaultPrevented(args[0])) {\n      return;\n    }\n\n    second(...args);\n  } as (...args: A) => void;\n}\n\n// Stable no-op for fast path\nfunction noop() {}\n"],"mappings":";AAkCA,SAAS,mBACP,OACqC;AACrC,QACE,OAAO,UAAU,YACjB,UAAU,QACV,sBAAsB,SACrB,MAAyC,qBAAqB;;AAInE,SAAgB,gBACd,OACA,QACA,SACsB;AAEtB,KAAI,CAAC,SAAS,CAAC,OACb,QAAO;AAIT,KAAI,CAAC,MAAO,QAAO;AACnB,KAAI,CAAC,OAAQ,QAAO;CAGpB,MAAM,wBAAwB,SAAS,0BAA0B;AAEjE,QAAO,SAAS,SAAS,GAAG,MAAS;AACnC,QAAM,GAAG,KAAK;AAEd,MAAI,yBAAyB,mBAAmB,KAAK,GAAG,CACtD;AAGF,SAAO,GAAG,KAAK;;;AAKnB,SAAS,OAAO"}

package/dist/foundations/utilities/compose-ref.d.ts

@@ -1,3 +1,4 @@
+//#region src/foundations/utilities/compose-ref.d.ts
 /**
  * Ref composition utilities
  *
@@ -16,9 +17,11 @@
  *    composeRefs applies refs in array order (left to right).
  *    All refs are called even if one fails.
  */
-export type Ref<T> = ((value: T | null) => void) | {
-    current: T | null;
+type Ref<T> = ((value: T | null) => void) | {
+  current: T | null;
 } | null | undefined;
-export declare function setRef<T>(ref: Ref<T>, value: T | null): void;
-export declare function composeRefs<T>(...refs: Array<Ref<T>>): (value: T | null) => void;
+declare function setRef<T>(ref: Ref<T>, value: T | null): void;
+declare function composeRefs<T>(...refs: Array<Ref<T>>): (value: T | null) => void;
+//#endregion
+export { Ref };
 //# sourceMappingURL=compose-ref.d.ts.map

package/dist/foundations/utilities/compose-ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose-ref.d.ts","sourceRoot":"","sources":["../../../src/foundations/utilities/compose-ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,GAAG,CAAC,CAAC,IACb,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC,GAC3B;IAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAAA;CAAE,GACrB,IAAI,GACJ,SAAS,CAAC;AAEd,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,CAU5D;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GACrB,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,CAI3B"}
+{"version":3,"file":"compose-ref.d.ts","names":[],"sources":["../../../src/foundations/utilities/compose-ref.ts"],"mappings":";;AAmBA;;;;;;;;;;;AAMA;;;;;;KANY,GAAA,QACN,KAAA,EAAO,CAAA;EACP,OAAA,EAAS,CAAA;AAAA;AAAA,iBAIC,MAAA,GAAA,CAAU,GAAA,EAAK,GAAA,CAAI,CAAA,GAAI,KAAA,EAAO,CAAA;AAAA,iBAY9B,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,KAAA,CAAM,GAAA,CAAI,CAAA,MACjB,KAAA,EAAO,CAAA"}

package/dist/foundations/utilities/compose-ref.js

@@ -1 +1,18 @@
-function e(t,n){if(t){if(typeof t=="function"){t(n);return}Object.isExtensible(t)&&(t.current=n)}}function f(...t){return n=>{for(const o of t)e(o,n)}}export{f as composeRefs,e as setRef};
+//#region src/foundations/utilities/compose-ref.ts
+function setRef(ref, value) {
+	if (!ref) return;
+	if (typeof ref === "function") {
+		ref(value);
+		return;
+	}
+	if (Object.isExtensible(ref)) ref.current = value;
+}
+function composeRefs(...refs) {
+	return (value) => {
+		for (const ref of refs) setRef(ref, value);
+	};
+}
+//#endregion
+export { composeRefs };
+
+//# sourceMappingURL=compose-ref.js.map

package/dist/foundations/utilities/compose-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose-ref.js","names":[],"sources":["../../../src/foundations/utilities/compose-ref.ts"],"sourcesContent":["/**\n * Ref composition utilities\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Ref Types Supported\n *    - Callback refs: (value: T | null) => void\n *    - Object refs: { current: T | null }\n *    - null/undefined (no-op)\n *\n * 2. Write Failure Handling\n *    setRef catches write failures (readonly refs) and ignores them.\n *    This is intentional — refs may be readonly in some contexts.\n *\n * 3. Composition Order\n *    composeRefs applies refs in array order (left to right).\n *    All refs are called even if one fails.\n */\n\nexport type Ref<T> =\n  | ((value: T | null) => void)\n  | { current: T | null }\n  | null\n  | undefined;\n\nexport function setRef<T>(ref: Ref<T>, value: T | null): void {\n  if (!ref) return;\n  if (typeof ref === 'function') {\n    ref(value);\n    return;\n  }\n  // Fast path: use Object.isExtensible check instead of try/catch for better performance\n  if (Object.isExtensible(ref)) {\n    (ref as { current: T | null }).current = value;\n  }\n}\n\nexport function composeRefs<T>(\n  ...refs: Array<Ref<T>>\n): (value: T | null) => void {\n  return (value: T | null) => {\n    for (const ref of refs) setRef(ref, value);\n  };\n}\n"],"mappings":";AAyBA,SAAgB,OAAU,KAAa,OAAuB;AAC5D,KAAI,CAAC,IAAK;AACV,KAAI,OAAO,QAAQ,YAAY;AAC7B,MAAI,MAAM;AACV;;AAGF,KAAI,OAAO,aAAa,IAAI,CACzB,KAA8B,UAAU;;AAI7C,SAAgB,YACd,GAAG,MACwB;AAC3B,SAAQ,UAAoB;AAC1B,OAAK,MAAM,OAAO,KAAM,QAAO,KAAK,MAAM"}

package/dist/foundations/utilities/merge-props.js

@@ -1 +1,49 @@
-import{composeHandlers as f}from"./compose-handlers.js";function u(n){return n.startsWith("on")}function a(n,o){const s=Object.keys(n);if(s.length===0)return o;const e={...o};for(const t of s){const r=n[t],c=o[t];if(u(t)&&typeof r=="function"&&typeof c=="function"){e[t]=f(c,r);continue}e[t]=r}return e}export{a as mergeProps};
+import { composeHandlers } from "./compose-handlers.js";
+//#region src/foundations/utilities/merge-props.ts
+/**
+* mergeProps
+*
+* Deterministic props merging.
+* - For non-handlers: `base` overwrites `injected`.
+* - For handlers present in both: handlers are composed with `injected` running
+*   first; it may call `preventDefault()` to suppress the `base` handler.
+*
+* POLICY DECISIONS (LOCKED):
+*
+* 1. Merge Strategy
+*    Base props overwrite injected props (base wins).
+*    Exception: Event handlers are composed, not overwritten.
+*
+* 2. Event Handler Detection
+*    Keys starting with "on" are treated as event handlers.
+*    This matches JSX conventions.
+*
+* 3. Handler Composition Order
+*    Injected handler runs first, base handler second.
+*    This allows injected handlers to prevent default.
+*
+* 4. Return Type
+*    Returns intersection type (TInjected & TBase) for type safety.
+*/
+function isEventHandlerKey(key) {
+	return key.startsWith("on");
+}
+function mergeProps(base, injected) {
+	const baseKeys = Object.keys(base);
+	if (baseKeys.length === 0) return injected;
+	const out = { ...injected };
+	for (const key of baseKeys) {
+		const baseValue = base[key];
+		const injectedValue = injected[key];
+		if (isEventHandlerKey(key) && typeof baseValue === "function" && typeof injectedValue === "function") {
+			out[key] = composeHandlers(injectedValue, baseValue);
+			continue;
+		}
+		out[key] = baseValue;
+	}
+	return out;
+}
+//#endregion
+export { mergeProps };
+
+//# sourceMappingURL=merge-props.js.map

package/dist/foundations/utilities/merge-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-props.js","names":[],"sources":["../../../src/foundations/utilities/merge-props.ts"],"sourcesContent":["/**\n * mergeProps\n *\n * Deterministic props merging.\n * - For non-handlers: `base` overwrites `injected`.\n * - For handlers present in both: handlers are composed with `injected` running\n *   first; it may call `preventDefault()` to suppress the `base` handler.\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Merge Strategy\n *    Base props overwrite injected props (base wins).\n *    Exception: Event handlers are composed, not overwritten.\n *\n * 2. Event Handler Detection\n *    Keys starting with \"on\" are treated as event handlers.\n *    This matches JSX conventions.\n *\n * 3. Handler Composition Order\n *    Injected handler runs first, base handler second.\n *    This allows injected handlers to prevent default.\n *\n * 4. Return Type\n *    Returns intersection type (TInjected & TBase) for type safety.\n */\nimport { composeHandlers } from './compose-handlers';\n\ntype Fn = (...args: readonly unknown[]) => void;\n\nfunction isEventHandlerKey(key: string): boolean {\n  return key.startsWith('on');\n}\n\nexport function mergeProps<TBase extends object, TInjected extends object>(\n  base: TBase,\n  injected: TInjected\n): TInjected & TBase {\n  // Fast path: if base is empty, return injected as-is\n  const baseKeys = Object.keys(base);\n  if (baseKeys.length === 0) {\n    return injected as TInjected & TBase;\n  }\n\n  const out = { ...(injected as object) } as TInjected & TBase;\n\n  for (const key of baseKeys as Array<Extract<keyof TBase, string>>) {\n    const baseValue = (base as Record<string, unknown>)[key];\n    const injectedValue = (injected as Record<string, unknown>)[key];\n\n    if (\n      isEventHandlerKey(key) &&\n      typeof baseValue === 'function' &&\n      typeof injectedValue === 'function'\n    ) {\n      // Invariant: injected runs first; it may call preventDefault() to\n      // suppress base behaviour.\n      (out as Record<string, unknown>)[key] = composeHandlers(\n        injectedValue as unknown as Fn,\n        baseValue as unknown as Fn\n      );\n      continue;\n    }\n\n    (out as Record<string, unknown>)[key] = baseValue;\n  }\n\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAS,kBAAkB,KAAsB;AAC/C,QAAO,IAAI,WAAW,KAAK;;AAG7B,SAAgB,WACd,MACA,UACmB;CAEnB,MAAM,WAAW,OAAO,KAAK,KAAK;AAClC,KAAI,SAAS,WAAW,EACtB,QAAO;CAGT,MAAM,MAAM,EAAE,GAAI,UAAqB;AAEvC,MAAK,MAAM,OAAO,UAAiD;EACjE,MAAM,YAAa,KAAiC;EACpD,MAAM,gBAAiB,SAAqC;AAE5D,MACE,kBAAkB,IAAI,IACtB,OAAO,cAAc,cACrB,OAAO,kBAAkB,YACzB;AAGC,OAAgC,OAAO,gBACtC,eACA,UACD;AACD;;AAGD,MAAgC,OAAO;;AAG1C,QAAO"}

package/dist/fx/fx.d.ts

@@ -1,30 +1,33 @@
-export type CancelFn = () => void;
-export declare function debounceEvent(ms: number, handler: EventListener, options?: {
-    leading?: boolean;
-    trailing?: boolean;
+//#region src/fx/fx.d.ts
+type CancelFn = () => void;
+declare function debounceEvent(ms: number, handler: EventListener, options?: {
+  leading?: boolean;
+  trailing?: boolean;
 }): EventListener & {
-    cancel(): void;
-    flush(): void;
+  cancel(): void;
+  flush(): void;
 };
-export declare function throttleEvent(ms: number, handler: EventListener, options?: {
-    leading?: boolean;
-    trailing?: boolean;
+declare function throttleEvent(ms: number, handler: EventListener, options?: {
+  leading?: boolean;
+  trailing?: boolean;
 }): EventListener & {
-    cancel(): void;
+  cancel(): void;
 };
-export declare function rafEvent(handler: EventListener): EventListener & {
-    cancel(): void;
+declare function rafEvent(handler: EventListener): EventListener & {
+  cancel(): void;
 };
-export declare function scheduleTimeout(ms: number, fn: () => void): CancelFn;
-export declare function scheduleIdle(fn: () => void, options?: {
-    timeout?: number;
+declare function scheduleTimeout(ms: number, fn: () => void): CancelFn;
+declare function scheduleIdle(fn: () => void, options?: {
+  timeout?: number;
 }): CancelFn;
-export interface RetryOptions {
-    maxAttempts?: number;
-    delayMs?: number;
-    backoff?: (attemptIndex: number) => number;
+interface RetryOptions {
+  maxAttempts?: number;
+  delayMs?: number;
+  backoff?: (attemptIndex: number) => number;
 }
-export declare function scheduleRetry<T>(fn: () => Promise<T>, options?: RetryOptions): {
-    cancel(): void;
+declare function scheduleRetry<T>(fn: () => Promise<T>, options?: RetryOptions): {
+  cancel(): void;
 };
+//#endregion
+export { debounceEvent, rafEvent, scheduleIdle, scheduleRetry, scheduleTimeout, throttleEvent };
 //# sourceMappingURL=fx.d.ts.map

package/dist/fx/fx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fx.d.ts","sourceRoot":"","sources":["../../src/fx/fx.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAwClC,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAClD,aAAa,GAAG;IAAE,MAAM,IAAI,IAAI,CAAC;IAAC,KAAK,IAAI,IAAI,CAAA;CAAE,CAoEnD;AAED,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAClD,aAAa,GAAG;IAAE,MAAM,IAAI,IAAI,CAAA;CAAE,CAwDpC;AAED,wBAAgB,QAAQ,CACtB,OAAO,EAAE,aAAa,GACrB,aAAa,GAAG;IAAE,MAAM,IAAI,IAAI,CAAA;CAAE,CAmDpC;AAID,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,QAAQ,CAqBpE;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,IAAI,EACd,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7B,QAAQ,CAwCV;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC7B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,YAAY,GACrB;IAAE,MAAM,IAAI,IAAI,CAAA;CAAE,CAiDpB"}
+{"version":3,"file":"fx.d.ts","names":[],"sources":["../../src/fx/fx.ts"],"mappings":";KAKY,QAAA;AAAA,iBAwCI,aAAA,CACd,EAAA,UACA,OAAA,EAAS,aAAA,EACT,OAAA;EAAY,OAAA;EAAmB,QAAA;AAAA,IAC9B,aAAA;EAAkB,MAAA;EAAgB,KAAA;AAAA;AAAA,iBAsErB,aAAA,CACd,EAAA,UACA,OAAA,EAAS,aAAA,EACT,OAAA;EAAY,OAAA;EAAmB,QAAA;AAAA,IAC9B,aAAA;EAAkB,MAAA;AAAA;AAAA,iBA0DL,QAAA,CACd,OAAA,EAAS,aAAA,GACR,aAAA;EAAkB,MAAA;AAAA;AAAA,iBAuDL,eAAA,CAAgB,EAAA,UAAY,EAAA,eAAiB,QAAA;AAAA,iBAuB7C,YAAA,CACd,EAAA,cACA,OAAA;EAAY,OAAA;AAAA,IACX,QAAA;AAAA,UA0Cc,YAAA;EACf,WAAA;EACA,OAAA;EACA,OAAA,IAAW,YAAA;AAAA;AAAA,iBAGG,aAAA,GAAA,CACd,EAAA,QAAU,OAAA,CAAQ,CAAA,GAClB,OAAA,GAAU,YAAA;EACP,MAAA;AAAA"}