@askrjs/askr 0.0.27 → 0.0.29

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

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