@askrjs/askr 0.0.28 → 0.0.30

package/dist/foundations/state/controllable.js

@@ -1 +1,81 @@
-import{state as s}from"../../runtime/state.js";function c(n){return n!==void 0}function a(n,t){const e=c(n);return{value:e?n:t,isControlled:e}}function C(n){const{value:t,defaultValue:e,onChange:o,setInternal:l}=n,{isControlled:r}=a(t,e);function u(i){r||l?.(i),o?.(i)}return{set:u,isControlled:r}}function d(n){const t=s(n.defaultValue),e=n.value!==void 0;function o(){return e?n.value:t()}return o.set=l=>{const r=o(),u=typeof l=="function"?l(r):l;if(!Object.is(r,u)){if(e){n.onChange?.(u);return}t.set(l),n.onChange?.(u)}},o.isControlled=e,o}export{d as controllableState,c as isControlled,C as makeControllable,a as resolveControllable};
+import { state } from "../../runtime/state.js";
+//#region src/foundations/state/controllable.ts
+/**
+* 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.
+*/
+function isControlled(value) {
+	return value !== void 0;
+}
+function resolveControllable(value, defaultValue) {
+	const controlled = isControlled(value);
+	return {
+		value: controlled ? value : defaultValue,
+		isControlled: controlled
+	};
+}
+function makeControllable(options) {
+	const { value, defaultValue, onChange, setInternal } = options;
+	const { isControlled } = resolveControllable(value, defaultValue);
+	function set(next) {
+		if (isControlled) onChange?.(next);
+		else {
+			setInternal?.(next);
+			onChange?.(next);
+		}
+	}
+	return {
+		set,
+		isControlled
+	};
+}
+/**
+* controllableState
+*
+* Hook-like primitive that mirrors `state()` semantics while supporting
+* controlled/uncontrolled behavior.
+*/
+function controllableState(options) {
+	const isControlled = options.value !== void 0;
+	const internal = isControlled ? null : state(options.defaultValue);
+	function read() {
+		if (isControlled) return options.value;
+		return internal();
+	}
+	read.set = (nextOrUpdater) => {
+		const prev = read();
+		const next = typeof nextOrUpdater === "function" ? nextOrUpdater(prev) : nextOrUpdater;
+		if (Object.is(prev, next)) return;
+		if (isControlled) {
+			options.onChange?.(next);
+			return;
+		}
+		internal.set(nextOrUpdater);
+		options.onChange?.(next);
+	};
+	read.isControlled = isControlled;
+	return read;
+}
+//#endregion
+export { controllableState, isControlled, makeControllable, resolveControllable };
+
+//# sourceMappingURL=controllable.js.map

package/dist/foundations/state/controllable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllable.js","names":[],"sources":["../../../src/foundations/state/controllable.ts"],"sourcesContent":["/**\n * controllable\n *\n * Small utilities for controlled vs uncontrolled components. These helpers are\n * intentionally minimal and do not manage state themselves; they help component\n * implementations make correct decisions about when to call `onChange` vs\n * update internal state.\n *\n * POLICY DECISIONS (LOCKED):\n *\n * 1. Controlled Detection\n *    A value is \"controlled\" if it is not `undefined`.\n *    This matches React conventions and is SSR-safe.\n *\n * 2. onChange Timing\n *    - Controlled mode: onChange called immediately, no internal update\n *    - Uncontrolled mode: internal state updated first, then onChange called\n *    This ensures onChange sees the new value in both modes.\n *\n * 3. Value Equality\n *    controllableState uses Object.is() to prevent unnecessary onChange calls.\n *    This is intentional — strict equality, no deep comparison.\n */\n\nimport { state, type State } from '../../runtime/state';\n\nexport function isControlled<T>(value: T | undefined): value is T {\n  return value !== undefined;\n}\n\nexport function resolveControllable<T>(\n  value: T | undefined,\n  defaultValue: T\n): { value: T; isControlled: boolean } {\n  const controlled = isControlled(value);\n  return {\n    value: controlled ? (value as T) : defaultValue,\n    isControlled: controlled,\n  };\n}\n\nexport function makeControllable<T>(options: {\n  value: T | undefined;\n  defaultValue: T;\n  onChange?: (next: T) => void;\n  setInternal?: (next: T) => void;\n}) {\n  const { value, defaultValue, onChange, setInternal } = options;\n  const { isControlled } = resolveControllable(value, defaultValue);\n\n  function set(next: T) {\n    if (isControlled) {\n      onChange?.(next);\n    } else {\n      setInternal?.(next);\n      onChange?.(next);\n    }\n  }\n\n  return { set, isControlled };\n}\n\nexport type ControllableState<T> = State<T> & { isControlled: boolean };\n\n/**\n * controllableState\n *\n * Hook-like primitive that mirrors `state()` semantics while supporting\n * controlled/uncontrolled behavior.\n */\nexport function controllableState<T>(options: {\n  value: T | undefined;\n  defaultValue: T;\n  onChange?: (next: T) => void;\n}): ControllableState<T> {\n  const isControlled = options.value !== undefined;\n  const internal = isControlled ? null : state<T>(options.defaultValue);\n\n  function read(): T {\n    if (isControlled) {\n      return options.value as T;\n    }\n\n    return internal!();\n  }\n\n  read.set = (nextOrUpdater: T | ((prev: T) => T)) => {\n    const prev = read();\n    const next =\n      typeof nextOrUpdater === 'function'\n        ? (nextOrUpdater as (p: T) => T)(prev)\n        : (nextOrUpdater as T);\n\n    if (Object.is(prev, next)) return;\n\n    if (isControlled) {\n      options.onChange?.(next);\n      return;\n    }\n\n    internal!.set(nextOrUpdater as never);\n    options.onChange?.(next);\n  };\n\n  (read as ControllableState<T>).isControlled = isControlled;\n  return read as ControllableState<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAgB,OAAkC;AAChE,QAAO,UAAU;;AAGnB,SAAgB,oBACd,OACA,cACqC;CACrC,MAAM,aAAa,aAAa,MAAM;AACtC,QAAO;EACL,OAAO,aAAc,QAAc;EACnC,cAAc;EACf;;AAGH,SAAgB,iBAAoB,SAKjC;CACD,MAAM,EAAE,OAAO,cAAc,UAAU,gBAAgB;CACvD,MAAM,EAAE,iBAAiB,oBAAoB,OAAO,aAAa;CAEjE,SAAS,IAAI,MAAS;AACpB,MAAI,aACF,YAAW,KAAK;OACX;AACL,iBAAc,KAAK;AACnB,cAAW,KAAK;;;AAIpB,QAAO;EAAE;EAAK;EAAc;;;;;;;;AAW9B,SAAgB,kBAAqB,SAIZ;CACvB,MAAM,eAAe,QAAQ,UAAU;CACvC,MAAM,WAAW,eAAe,OAAO,MAAS,QAAQ,aAAa;CAErE,SAAS,OAAU;AACjB,MAAI,aACF,QAAO,QAAQ;AAGjB,SAAO,UAAW;;AAGpB,MAAK,OAAO,kBAAwC;EAClD,MAAM,OAAO,MAAM;EACnB,MAAM,OACJ,OAAO,kBAAkB,aACpB,cAA8B,KAAK,GACnC;AAEP,MAAI,OAAO,GAAG,MAAM,KAAK,CAAE;AAE3B,MAAI,cAAc;AAChB,WAAQ,WAAW,KAAK;AACxB;;AAGF,WAAU,IAAI,cAAuB;AACrC,UAAQ,WAAW,KAAK;;AAGzB,MAA8B,eAAe;AAC9C,QAAO"}

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

@@ -1,3 +1,4 @@
+//#region src/foundations/structures/collection.d.ts
 /**
  * createCollection
  *
@@ -22,46 +23,30 @@
  *   const allItems = collection.items();
  *   unregister();
  */
-export type CollectionItem<TNode, TMetadata = unknown> = {
-    node: TNode;
-    metadata: TMetadata;
+type CollectionItem<TNode, TMetadata = unknown> = {
+  node: TNode;
+  metadata: TMetadata;
 };
-export interface Collection<TNode, TMetadata = unknown> {
-    /**
-     * Register a node with optional metadata.
-     * Returns an unregister function.
-     */
-    register(node: TNode, metadata: TMetadata): () => void;
-    /**
-     * Get all registered items in insertion order.
-     */
-    items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;
-    /**
-     * Clear all registered items.
-     */
-    clear(): void;
-    /**
-     * Get the count of registered items.
-     */
-    size(): number;
+interface Collection<TNode, TMetadata = unknown> {
+  /**
+   * Register a node with optional metadata.
+   * Returns an unregister function.
+   */
+  register(node: TNode, metadata: TMetadata): () => void;
+  /**
+   * Get all registered items in insertion order.
+   */
+  items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;
+  /**
+   * Clear all registered items.
+   */
+  clear(): void;
+  /**
+   * Get the count of registered items.
+   */
+  size(): number;
 }
-export declare function createCollection<TNode, TMetadata = unknown>(): Collection<TNode, TMetadata>;
-/**
- * USAGE EXAMPLE:
- *
- * // Create a collection for menu items
- * const menuItems = createCollection<HTMLElement, { disabled: boolean }>();
- *
- * // Register items
- * const unregister1 = menuItems.register(element1, { disabled: false });
- * const unregister2 = menuItems.register(element2, { disabled: true });
- *
- * // Query items
- * const allItems = menuItems.items();
- * const enabledItems = allItems.filter(item => !item.metadata.disabled);
- *
- * // Cleanup
- * unregister1();
- * unregister2();
- */
+declare function createCollection<TNode, TMetadata = unknown>(): Collection<TNode, TMetadata>;
+//#endregion
+export { Collection, CollectionItem, createCollection };
 //# sourceMappingURL=collection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../src/foundations/structures/collection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,IAAI;IACvD,IAAI,EAAE,KAAK,CAAC;IACZ,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,MAAM,WAAW,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IACpD;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,GAAG,MAAM,IAAI,CAAC;IAEvD;;OAEG;IACH,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC;IAEzD;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,IAAI,IAAI,MAAM,CAAC;CAChB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,KAAK,UAAU,CACxE,KAAK,EACL,SAAS,CACV,CA8BA;AAED;;;;;;;;;;;;;;;;;GAiBG"}
+{"version":3,"file":"collection.d.ts","names":[],"sources":["../../../src/foundations/structures/collection.ts"],"mappings":";;AAyBA;;;;;;;;;;;;AAKA;;;;;;;;;;;KALY,cAAA;EACV,IAAA,EAAM,KAAA;EACN,QAAA,EAAU,SAAA;AAAA;AAAA,UAGK,UAAA;EAKiB;;;;EAAhC,QAAA,CAAS,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAA;EAKM;;;EAAtC,KAAA,IAAS,aAAA,CAAc,cAAA,CAAe,KAAA,EAAO,SAAA;EAUzC;;AAGN;EARE,KAAA;EAQ8B;;;EAH9B,IAAA;AAAA;AAAA,iBAGc,gBAAA,4BAAA,CAAA,GAAgD,UAAA,CAC9D,KAAA,EACA,SAAA"}

package/dist/foundations/structures/collection.js

@@ -1 +1,51 @@
-function s(){const e=new Map;function r(t,u){const o={node:t,metadata:u};return e.set(t,o),()=>{e.delete(t)}}function n(){return Array.from(e.values())}function i(){e.clear()}function c(){return e.size}return{register:r,items:n,clear:i,size:c}}export{s as createCollection};
+//#region src/foundations/structures/collection.ts
+function createCollection() {
+	const registry = /* @__PURE__ */ new Map();
+	function register(node, metadata) {
+		const item = {
+			node,
+			metadata
+		};
+		registry.set(node, item);
+		return () => {
+			registry.delete(node);
+		};
+	}
+	function items() {
+		return Array.from(registry.values());
+	}
+	function clear() {
+		registry.clear();
+	}
+	function size() {
+		return registry.size;
+	}
+	return {
+		register,
+		items,
+		clear,
+		size
+	};
+}
+/**
+* USAGE EXAMPLE:
+*
+* // Create a collection for menu items
+* const menuItems = createCollection<HTMLElement, { disabled: boolean }>();
+*
+* // Register items
+* const unregister1 = menuItems.register(element1, { disabled: false });
+* const unregister2 = menuItems.register(element2, { disabled: true });
+*
+* // Query items
+* const allItems = menuItems.items();
+* const enabledItems = allItems.filter(item => !item.metadata.disabled);
+*
+* // Cleanup
+* unregister1();
+* unregister2();
+*/
+//#endregion
+export { createCollection };
+
+//# sourceMappingURL=collection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collection.js","names":[],"sources":["../../../src/foundations/structures/collection.ts"],"sourcesContent":["/**\n * createCollection\n *\n * Ordered descendant registry for coordinating items without DOM queries.\n *\n * INVARIANTS:\n * 1. Registration order determines item order (no DOM queries)\n * 2. Stable ordering across renders (insertion order preserved)\n * 3. Each item may have metadata (type-safe, user-defined)\n * 4. No implicit global state (explicit collection instances)\n * 5. No automatic cleanup (caller controls lifecycle)\n *\n * DESIGN:\n * - Returns a registry API ({ register, items, clear })\n * - Items are stored in insertion order\n * - Registration returns an unregister function\n * - No side effects on registration (pure data structure)\n *\n * USAGE:\n *   const collection = createCollection<HTMLElement, { disabled: boolean }>();\n *   const unregister = collection.register(element, { disabled: false });\n *   const allItems = collection.items();\n *   unregister();\n */\n\nexport type CollectionItem<TNode, TMetadata = unknown> = {\n  node: TNode;\n  metadata: TMetadata;\n};\n\nexport interface Collection<TNode, TMetadata = unknown> {\n  /**\n   * Register a node with optional metadata.\n   * Returns an unregister function.\n   */\n  register(node: TNode, metadata: TMetadata): () => void;\n\n  /**\n   * Get all registered items in insertion order.\n   */\n  items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;\n\n  /**\n   * Clear all registered items.\n   */\n  clear(): void;\n\n  /**\n   * Get the count of registered items.\n   */\n  size(): number;\n}\n\nexport function createCollection<TNode, TMetadata = unknown>(): Collection<\n  TNode,\n  TMetadata\n> {\n  const registry = new Map<TNode, CollectionItem<TNode, TMetadata>>();\n\n  function register(node: TNode, metadata: TMetadata): () => void {\n    const item: CollectionItem<TNode, TMetadata> = { node, metadata };\n    registry.set(node, item);\n\n    return () => {\n      registry.delete(node);\n    };\n  }\n\n  function items(): ReadonlyArray<CollectionItem<TNode, TMetadata>> {\n    return Array.from(registry.values());\n  }\n\n  function clear(): void {\n    registry.clear();\n  }\n\n  function size(): number {\n    return registry.size;\n  }\n\n  return {\n    register,\n    items,\n    clear,\n    size,\n  };\n}\n\n/**\n * USAGE EXAMPLE:\n *\n * // Create a collection for menu items\n * const menuItems = createCollection<HTMLElement, { disabled: boolean }>();\n *\n * // Register items\n * const unregister1 = menuItems.register(element1, { disabled: false });\n * const unregister2 = menuItems.register(element2, { disabled: true });\n *\n * // Query items\n * const allItems = menuItems.items();\n * const enabledItems = allItems.filter(item => !item.metadata.disabled);\n *\n * // Cleanup\n * unregister1();\n * unregister2();\n */\n"],"mappings":";AAqDA,SAAgB,mBAGd;CACA,MAAM,2BAAW,IAAI,KAA8C;CAEnE,SAAS,SAAS,MAAa,UAAiC;EAC9D,MAAM,OAAyC;GAAE;GAAM;GAAU;AACjE,WAAS,IAAI,MAAM,KAAK;AAExB,eAAa;AACX,YAAS,OAAO,KAAK;;;CAIzB,SAAS,QAAyD;AAChE,SAAO,MAAM,KAAK,SAAS,QAAQ,CAAC;;CAGtC,SAAS,QAAc;AACrB,WAAS,OAAO;;CAGlB,SAAS,OAAe;AACtB,SAAO,SAAS;;AAGlB,QAAO;EACL;EACA;EACA;EACA;EACD"}

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

@@ -1,3 +1,4 @@
+//#region src/foundations/structures/layer.d.ts
 /**
  * createLayer
  *
@@ -28,75 +29,53 @@
  *   layer.isTop(); // true if this is the topmost layer
  *   layer.unregister();
  */
-export interface LayerOptions {
-    /**
-     * Called when Escape is pressed and this is the top layer
-     */
-    onEscape?: () => void;
-    /**
-     * Called when pointer event occurs outside and this is the top layer
-     */
-    onOutsidePointer?: (e: PointerEvent) => void;
-    /**
-     * Optional node reference for outside pointer detection
-     */
-    node?: Node | null;
+interface LayerOptions {
+  /**
+   * Called when Escape is pressed and this is the top layer
+   */
+  onEscape?: () => void;
+  /**
+   * Called when pointer event occurs outside and this is the top layer
+   */
+  onOutsidePointer?: (e: PointerEvent) => void;
+  /**
+   * Optional node reference for outside pointer detection
+   */
+  node?: Node | null;
 }
-export interface Layer {
-    /**
-     * Unique layer ID
-     */
-    id: number;
-    /**
-     * Check if this layer is the topmost
-     */
-    isTop(): boolean;
-    /**
-     * Remove this layer from the stack
-     */
-    unregister(): void;
+interface Layer {
+  /**
+   * Unique layer ID
+   */
+  id: number;
+  /**
+   * Check if this layer is the topmost
+   */
+  isTop(): boolean;
+  /**
+   * Remove this layer from the stack
+   */
+  unregister(): void;
 }
-export interface LayerManager {
-    /**
-     * Register a new layer
-     */
-    register(options: LayerOptions): Layer;
-    /**
-     * Get all active layers in order
-     */
-    layers(): ReadonlyArray<Layer>;
-    /**
-     * Manually trigger escape handling on the top layer
-     */
-    handleEscape(): void;
-    /**
-     * Manually trigger outside pointer handling on the top layer
-     */
-    handleOutsidePointer(e: PointerEvent): void;
+interface LayerManager {
+  /**
+   * Register a new layer
+   */
+  register(options: LayerOptions): Layer;
+  /**
+   * Get all active layers in order
+   */
+  layers(): ReadonlyArray<Layer>;
+  /**
+   * Manually trigger escape handling on the top layer
+   */
+  handleEscape(): void;
+  /**
+   * Manually trigger outside pointer handling on the top layer
+   */
+  handleOutsidePointer(e: PointerEvent): void;
 }
-export declare function createLayer(): LayerManager;
-/**
- * USAGE EXAMPLE:
- *
- * const layerManager = createLayer();
- *
- * function Modal({ onClose }) {
- *   const modalRef = ref<HTMLDivElement>();
- *
- *   const layer = layerManager.register({
- *     node: modalRef.current,
- *     onEscape: onClose,
- *     onOutsidePointer: onClose,
- *   });
- *
- *   onUnmount(() => layer.unregister());
- *
- *   return (
- *     <div ref={modalRef}>
- *       <h1>Modal</h1>
- *       {layer.isTop() && <p>I am on top!</p>}
- *     </div>
- *   );
- * }
- */
+declare function createLayer(): LayerManager;
+//#endregion
+export { Layer, LayerManager, LayerOptions, createLayer };
 //# sourceMappingURL=layer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../../src/foundations/structures/layer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAEtB;;OAEG;IACH,gBAAgB,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;IAE7C;;OAEG;IACH,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC;IAEjB;;OAEG;IACH,UAAU,IAAI,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAAC;IAEvC;;OAEG;IACH,MAAM,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;IAE/B;;OAEG;IACH,YAAY,IAAI,IAAI,CAAC;IAErB;;OAEG;IACH,oBAAoB,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAC7C;AAED,wBAAgB,WAAW,IAAI,YAAY,CAyE1C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG"}
+{"version":3,"file":"layer.d.ts","names":[],"sources":["../../../src/foundations/structures/layer.ts"],"mappings":";;AA+BA;;;;;;;;;;;;AAiBA;;;;;;;;;AAiBA;;;;;;;;UAlCiB,YAAA;EAqDqB;;;EAjDpC,QAAA;EAkCiC;;;EA7BjC,gBAAA,IAAoB,CAAA,EAAG,YAAA;EAuCvB;;;EAlCA,IAAA,GAAO,IAAA;AAAA;AAAA,UAGQ,KAAA;EAuCD;;;EAnCd,EAAA;EAmCyC;;;EA9BzC,KAAA;;;;EAKA,UAAA;AAAA;AAAA,UAGe,YAAA;;;;EAIf,QAAA,CAAS,OAAA,EAAS,YAAA,GAAe,KAAA;;;;EAKjC,MAAA,IAAU,aAAA,CAAc,KAAA;;;;EAKxB,YAAA;;;;EAKA,oBAAA,CAAqB,CAAA,EAAG,YAAA;AAAA;AAAA,iBAGV,WAAA,CAAA,GAAe,YAAA"}

package/dist/foundations/structures/layer.js

@@ -1 +1,81 @@
-function l(){const n=[];let s=1;function d(t){const i=s++,e={id:i,options:t};n.push(e);function f(){return n[n.length-1]?.id===i}function p(){const o=n.findIndex(a=>a.id===i);o!==-1&&n.splice(o,1)}return{id:i,isTop:f,unregister:p}}function r(){return n.map(t=>({id:t.id,isTop:()=>n[n.length-1]?.id===t.id,unregister:()=>{const i=n.findIndex(e=>e.id===t.id);i!==-1&&n.splice(i,1)}}))}function c(){const t=n[n.length-1];t&&t.options.onEscape?.()}function u(t){const i=n[n.length-1];if(!i)return;const e=i.options.node;e&&t.target instanceof Node&&e.contains(t.target)||i.options.onOutsidePointer?.(t)}return{register:d,layers:r,handleEscape:c,handleOutsidePointer:u}}export{l as createLayer};
+//#region src/foundations/structures/layer.ts
+function createLayer() {
+	const stack = [];
+	let nextId = 1;
+	function register(options) {
+		const id = nextId++;
+		const entry = {
+			id,
+			options
+		};
+		stack.push(entry);
+		function isTop() {
+			return stack[stack.length - 1]?.id === id;
+		}
+		function unregister() {
+			const index = stack.findIndex((e) => e.id === id);
+			if (index !== -1) stack.splice(index, 1);
+		}
+		return {
+			id,
+			isTop,
+			unregister
+		};
+	}
+	function layers() {
+		return stack.map((entry) => ({
+			id: entry.id,
+			isTop: () => stack[stack.length - 1]?.id === entry.id,
+			unregister: () => {
+				const index = stack.findIndex((e) => e.id === entry.id);
+				if (index !== -1) stack.splice(index, 1);
+			}
+		}));
+	}
+	function handleEscape() {
+		const top = stack[stack.length - 1];
+		if (top) top.options.onEscape?.();
+	}
+	function handleOutsidePointer(e) {
+		const top = stack[stack.length - 1];
+		if (!top) return;
+		const node = top.options.node;
+		if (node && e.target instanceof Node) {
+			if (!node.contains(e.target)) top.options.onOutsidePointer?.(e);
+		} else top.options.onOutsidePointer?.(e);
+	}
+	return {
+		register,
+		layers,
+		handleEscape,
+		handleOutsidePointer
+	};
+}
+/**
+* USAGE EXAMPLE:
+*
+* const layerManager = createLayer();
+*
+* function Modal({ onClose }) {
+*   const modalRef = ref<HTMLDivElement>();
+*
+*   const layer = layerManager.register({
+*     node: modalRef.current,
+*     onEscape: onClose,
+*     onOutsidePointer: onClose,
+*   });
+*
+*   onUnmount(() => layer.unregister());
+*
+*   return (
+*     <div ref={modalRef}>
+*       <h1>Modal</h1>
+*       {layer.isTop() && <p>I am on top!</p>}
+*     </div>
+*   );
+* }
+*/
+//#endregion
+export { createLayer };
+
+//# sourceMappingURL=layer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layer.js","names":[],"sources":["../../../src/foundations/structures/layer.ts"],"sourcesContent":["/**\n * createLayer\n *\n * Manages stacking order and coordination for overlays (modals, popovers, etc).\n *\n * INVARIANTS:\n * 1. Layers are ordered by registration time (FIFO)\n * 2. Only the top layer handles Escape key\n * 3. Only the top layer handles outside pointer events\n * 4. Nested layers are supported\n * 5. Does not implement portals (orthogonal concern)\n * 6. No automatic DOM insertion (caller controls mounting)\n *\n * DESIGN:\n * - Returns a layer manager with register/unregister API\n * - Each layer has a unique ID and can query if it's the top layer\n * - Escape and outside pointer coordination via callbacks\n * - No z-index management (CSS concern)\n *\n * USAGE:\n *   const manager = createLayer();\n *\n *   const layer = manager.register({\n *     onEscape: () => { ... },\n *     onOutsidePointer: () => { ... }\n *   });\n *\n *   layer.isTop(); // true if this is the topmost layer\n *   layer.unregister();\n */\n\nexport interface LayerOptions {\n  /**\n   * Called when Escape is pressed and this is the top layer\n   */\n  onEscape?: () => void;\n\n  /**\n   * Called when pointer event occurs outside and this is the top layer\n   */\n  onOutsidePointer?: (e: PointerEvent) => void;\n\n  /**\n   * Optional node reference for outside pointer detection\n   */\n  node?: Node | null;\n}\n\nexport interface Layer {\n  /**\n   * Unique layer ID\n   */\n  id: number;\n\n  /**\n   * Check if this layer is the topmost\n   */\n  isTop(): boolean;\n\n  /**\n   * Remove this layer from the stack\n   */\n  unregister(): void;\n}\n\nexport interface LayerManager {\n  /**\n   * Register a new layer\n   */\n  register(options: LayerOptions): Layer;\n\n  /**\n   * Get all active layers in order\n   */\n  layers(): ReadonlyArray<Layer>;\n\n  /**\n   * Manually trigger escape handling on the top layer\n   */\n  handleEscape(): void;\n\n  /**\n   * Manually trigger outside pointer handling on the top layer\n   */\n  handleOutsidePointer(e: PointerEvent): void;\n}\n\nexport function createLayer(): LayerManager {\n  const stack: Array<{\n    id: number;\n    options: LayerOptions;\n  }> = [];\n\n  let nextId = 1;\n\n  function register(options: LayerOptions): Layer {\n    const id = nextId++;\n    const entry = { id, options };\n    stack.push(entry);\n\n    function isTop(): boolean {\n      return stack[stack.length - 1]?.id === id;\n    }\n\n    function unregister(): void {\n      const index = stack.findIndex((e) => e.id === id);\n      if (index !== -1) {\n        stack.splice(index, 1);\n      }\n    }\n\n    return {\n      id,\n      isTop,\n      unregister,\n    };\n  }\n\n  function layers(): ReadonlyArray<Layer> {\n    return stack.map((entry) => ({\n      id: entry.id,\n      isTop: () => stack[stack.length - 1]?.id === entry.id,\n      unregister: () => {\n        const index = stack.findIndex((e) => e.id === entry.id);\n        if (index !== -1) {\n          stack.splice(index, 1);\n        }\n      },\n    }));\n  }\n\n  function handleEscape(): void {\n    const top = stack[stack.length - 1];\n    if (top) {\n      top.options.onEscape?.();\n    }\n  }\n\n  function handleOutsidePointer(e: PointerEvent): void {\n    const top = stack[stack.length - 1];\n    if (!top) return;\n\n    const node = top.options.node;\n    if (node && e.target instanceof Node) {\n      // Check if the event target is outside the layer node\n      if (!node.contains(e.target)) {\n        top.options.onOutsidePointer?.(e);\n      }\n    } else {\n      // No node provided, always trigger\n      top.options.onOutsidePointer?.(e);\n    }\n  }\n\n  return {\n    register,\n    layers,\n    handleEscape,\n    handleOutsidePointer,\n  };\n}\n\n/**\n * USAGE EXAMPLE:\n *\n * const layerManager = createLayer();\n *\n * function Modal({ onClose }) {\n *   const modalRef = ref<HTMLDivElement>();\n *\n *   const layer = layerManager.register({\n *     node: modalRef.current,\n *     onEscape: onClose,\n *     onOutsidePointer: onClose,\n *   });\n *\n *   onUnmount(() => layer.unregister());\n *\n *   return (\n *     <div ref={modalRef}>\n *       <h1>Modal</h1>\n *       {layer.isTop() && <p>I am on top!</p>}\n *     </div>\n *   );\n * }\n */\n"],"mappings":";AAuFA,SAAgB,cAA4B;CAC1C,MAAM,QAGD,EAAE;CAEP,IAAI,SAAS;CAEb,SAAS,SAAS,SAA8B;EAC9C,MAAM,KAAK;EACX,MAAM,QAAQ;GAAE;GAAI;GAAS;AAC7B,QAAM,KAAK,MAAM;EAEjB,SAAS,QAAiB;AACxB,UAAO,MAAM,MAAM,SAAS,IAAI,OAAO;;EAGzC,SAAS,aAAmB;GAC1B,MAAM,QAAQ,MAAM,WAAW,MAAM,EAAE,OAAO,GAAG;AACjD,OAAI,UAAU,GACZ,OAAM,OAAO,OAAO,EAAE;;AAI1B,SAAO;GACL;GACA;GACA;GACD;;CAGH,SAAS,SAA+B;AACtC,SAAO,MAAM,KAAK,WAAW;GAC3B,IAAI,MAAM;GACV,aAAa,MAAM,MAAM,SAAS,IAAI,OAAO,MAAM;GACnD,kBAAkB;IAChB,MAAM,QAAQ,MAAM,WAAW,MAAM,EAAE,OAAO,MAAM,GAAG;AACvD,QAAI,UAAU,GACZ,OAAM,OAAO,OAAO,EAAE;;GAG3B,EAAE;;CAGL,SAAS,eAAqB;EAC5B,MAAM,MAAM,MAAM,MAAM,SAAS;AACjC,MAAI,IACF,KAAI,QAAQ,YAAY;;CAI5B,SAAS,qBAAqB,GAAuB;EACnD,MAAM,MAAM,MAAM,MAAM,SAAS;AACjC,MAAI,CAAC,IAAK;EAEV,MAAM,OAAO,IAAI,QAAQ;AACzB,MAAI,QAAQ,EAAE,kBAAkB,MAE9B;OAAI,CAAC,KAAK,SAAS,EAAE,OAAO,CAC1B,KAAI,QAAQ,mBAAmB,EAAE;QAInC,KAAI,QAAQ,mBAAmB,EAAE;;AAIrC,QAAO;EACL;EACA;EACA;EACA;EACD"}

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

@@ -1,3 +1,4 @@
+//#region src/foundations/structures/layout.d.ts
 /**
  * Layout helper.
  *
@@ -21,8 +22,10 @@
  *    Props are spread into the layout component. This is intentional
  *    and deterministic — no merging or composition.
  */
-export type LayoutComponent<P = object> = (props: P & {
-    children?: unknown;
+type LayoutComponent<P = object> = (props: P & {
+  children?: unknown;
 }) => unknown;
-export declare function layout<P = object>(Layout: LayoutComponent<P>): (children?: unknown, props?: P) => unknown;
+declare function layout<P = object>(Layout: LayoutComponent<P>): (children?: unknown, props?: P) => unknown;
+//#endregion
+export { LayoutComponent, layout };
 //# sourceMappingURL=layout.d.ts.map

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"}