@omerdlw/base-framework 1.0.0

package/dist/modules/modal/index.js

@@ -0,0 +1,2672 @@
+"use client";
+import { Icon as Icon$1 } from '@iconify-icon/react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import '@radix-ui/react-tooltip';
+import { useState, useRef, useCallback, useMemo, use, useSyncExternalStore, createContext, useLayoutEffect, useEffect, createElement, useInsertionEffect, useId, useContext, isValidElement, cloneElement, Children } from 'react';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { usePathname } from 'next/navigation';
+import { motion, AnimatePresence } from 'motion/react';
+import { createPortal } from 'react-dom';
+import dynamic from 'next/dynamic';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function Icon({
+  className = "center",
+  color,
+  icon,
+  onClick,
+  size = 20,
+  style,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    Icon$1,
+    {
+      className,
+      height: size,
+      icon,
+      onClick,
+      style: { color, ...style },
+      width: size,
+      ...props
+    }
+  );
+}
+var init_icon = __esm({
+  "src/atoms/icon.tsx"() {
+    "use client";
+    Icon.displayName = "Icon";
+  }
+});
+var init_spinner = __esm({
+  "src/atoms/spinner.tsx"() {
+    "use client";
+    init_icon();
+  }
+});
+var init_tooltip = __esm({
+  "src/atoms/tooltip.tsx"() {
+    "use client";
+  }
+});
+function Button({
+  ref,
+  children,
+  className,
+  disabled = false,
+  loading = false,
+  type = "button",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type,
+      disabled: disabled || loading,
+      "aria-busy": loading ? true : void 0,
+      className,
+      ...props,
+      children
+    }
+  );
+}
+var init_button = __esm({
+  "src/atoms/button.tsx"() {
+    "use client";
+    Button.displayName = "Button";
+  }
+});
+var init_use_fullscreen_state = __esm({
+  "src/hooks/use-fullscreen-state.ts"() {
+    "use client";
+  }
+});
+
+// src/atoms/index.ts
+var init_atoms = __esm({
+  "src/atoms/index.ts"() {
+    "use client";
+    init_icon();
+    init_spinner();
+    init_tooltip();
+    init_button();
+    init_use_fullscreen_state();
+  }
+});
+
+// src/tokens/tokens.ts
+var Z_INDEX;
+var init_tokens = __esm({
+  "src/tokens/tokens.ts"() {
+    Z_INDEX = Object.freeze({
+      BACKGROUND: 0,
+      DOCK_BACKDROP: 100,
+      DOCK: 110,
+      NOTIFICATION: 120,
+      MODAL_BACKDROP: 130,
+      MODAL: 140,
+      SELECT: 150,
+      LOADING: 160,
+      ERROR_OVERLAY: 170,
+      CONTEXT_MENU_BACKDROP: 180,
+      CONTEXT_MENU: 190,
+      TOOLTIP: 200,
+      UI_ELEMENT: 10,
+      DOCK_CARD_BACKGROUND: 0,
+      DOCK_CARD_CONTENT: 10,
+      DOCK_CARD_STACK_BASE: 10,
+      DOCK_CARD_BADGE: 20,
+      DOCK_CARD_MEDIA: 30,
+      DOCK_BREADCRUMBS: 10,
+      DOCK_SURFACE_CONTROL: 10,
+      DOCK_SURFACE_POPOVER: 30,
+      DOCK_SURFACE_CENTER: 0,
+      MODAL_FRAME: 1,
+      MODAL_STICKY_HEADER: 10
+    });
+  }
+});
+
+// src/tokens/motion.ts
+var DURATION_TOKENS, EASING_CURVES, MOTION_EASINGS, MOTION_TIERS;
+var init_motion = __esm({
+  "src/tokens/motion.ts"() {
+    DURATION_TOKENS = Object.freeze({
+      INSTANT: 0.08,
+      MICRO: 0.18,
+      FAST: 0.28,
+      BASE: 0.36,
+      MODERATE: 0.44,
+      SLOW: 0.58,
+      CINEMATIC: 0.86
+    });
+    EASING_CURVES = Object.freeze({
+      OUT_EXPO: [0.16, 1, 0.3, 1],
+      OUT_QUART: [0.25, 1, 0.5, 1],
+      OUT_QUINT: [0.22, 1, 0.36, 1],
+      IN_OUT_CUBIC: [0.65, 0, 0.35, 1],
+      IN_CUBIC: [0.5, 0, 1, 1],
+      OUT_BACK: [0.34, 1.56, 0.64, 1]
+    });
+    MOTION_EASINGS = Object.freeze({
+      ENTER: EASING_CURVES.OUT_QUART,
+      ENTER_EMPHASIZED: EASING_CURVES.OUT_EXPO,
+      EXIT: EASING_CURVES.IN_CUBIC
+    });
+    MOTION_TIERS = Object.freeze({
+      MICRO: Object.freeze({
+        distance: 4,
+        duration: DURATION_TOKENS.MICRO,
+        ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+        scaleDelta: 8e-3
+      }),
+      FAST: Object.freeze({
+        distance: 9,
+        duration: DURATION_TOKENS.FAST,
+        ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+        scaleDelta: 0.012
+      }),
+      STANDARD: Object.freeze({
+        distance: 18,
+        duration: DURATION_TOKENS.MODERATE,
+        ease: MOTION_EASINGS.ENTER,
+        scaleDelta: 0.018
+      }),
+      SURFACE: Object.freeze({
+        distance: 28,
+        duration: DURATION_TOKENS.SLOW,
+        ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+        scaleDelta: 0.024
+      })
+    });
+    Object.freeze({
+      duration: DURATION_TOKENS.INSTANT,
+      ease: "linear"
+    });
+  }
+});
+
+// src/tokens/index.ts
+var init_tokens2 = __esm({
+  "src/tokens/index.ts"() {
+    init_tokens();
+    init_motion();
+  }
+});
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+var init_cn = __esm({
+  "src/utils/cn.ts"() {
+  }
+});
+
+// src/utils/string.ts
+function trimToNull(value) {
+  if (value === null || value === void 0) return null;
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+var init_string = __esm({
+  "src/utils/string.ts"() {
+  }
+});
+
+// src/utils/dom.ts
+function acquireGlobalScrollLock() {
+  if (typeof document === "undefined") return () => {
+  };
+  if (globalScrollLockCount === 0) {
+    globalScrollLockStyles = {
+      bodyOverflow: document.body.style.overflow,
+      bodyOverscrollBehavior: document.body.style.overscrollBehavior,
+      htmlOverflow: document.documentElement.style.overflow,
+      htmlOverscrollBehavior: document.documentElement.style.overscrollBehavior
+    };
+  }
+  globalScrollLockCount += 1;
+  document.body.style.overflow = "hidden";
+  document.body.style.overscrollBehavior = "none";
+  document.documentElement.style.overflow = "hidden";
+  document.documentElement.style.overscrollBehavior = "none";
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    globalScrollLockCount = Math.max(0, globalScrollLockCount - 1);
+    if (globalScrollLockCount > 0 || !globalScrollLockStyles) return;
+    document.body.style.overflow = globalScrollLockStyles.bodyOverflow;
+    document.body.style.overscrollBehavior = globalScrollLockStyles.bodyOverscrollBehavior;
+    document.documentElement.style.overflow = globalScrollLockStyles.htmlOverflow;
+    document.documentElement.style.overscrollBehavior = globalScrollLockStyles.htmlOverscrollBehavior;
+    globalScrollLockStyles = null;
+  };
+}
+var isBrowser, globalScrollLockCount, globalScrollLockStyles;
+var init_dom = __esm({
+  "src/utils/dom.ts"() {
+    init_string();
+    isBrowser = typeof window !== "undefined";
+    globalScrollLockCount = 0;
+    globalScrollLockStyles = null;
+  }
+});
+
+// src/utils/number.ts
+var init_number = __esm({
+  "src/utils/number.ts"() {
+  }
+});
+
+// src/utils/object.ts
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainObject(value) {
+  if (!isObject(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var init_object = __esm({
+  "src/utils/object.ts"() {
+  }
+});
+
+// src/utils/timing.ts
+var init_timing = __esm({
+  "src/utils/timing.ts"() {
+  }
+});
+
+// src/utils/json.ts
+var init_json = __esm({
+  "src/utils/json.ts"() {
+  }
+});
+
+// src/utils/report.ts
+function report(scope, error, level = "error") {
+  if (sink) {
+    try {
+      sink(scope, error, level);
+      return;
+    } catch {
+    }
+  }
+  if (process.env.NODE_ENV === "production" && typeof window !== "undefined") {
+    return;
+  }
+  console[level](`[${scope}]`, error);
+}
+var sink;
+var init_report = __esm({
+  "src/utils/report.ts"() {
+    sink = null;
+  }
+});
+var init_user_message = __esm({
+  "src/utils/user-message.ts"() {
+  }
+});
+
+// src/utils/store.ts
+function freezeStoreSnapshot(state) {
+  if (process.env.NODE_ENV === "production" || !state || typeof state !== "object") {
+    return state;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const freeze = (value) => {
+    if (seen.has(value) || Object.isFrozen(value)) return;
+    seen.add(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || prototype === Object.prototype || prototype === null) {
+      for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor && "value" in descriptor && descriptor.value !== null) {
+          if (typeof descriptor.value === "object") freeze(descriptor.value);
+        }
+      }
+    }
+    Object.freeze(value);
+  };
+  freeze(state);
+  return state;
+}
+function createStore(initialState, { freezeSnapshots = true } = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const prepare = freezeSnapshots ? freezeStoreSnapshot : (state) => state;
+  let snapshot = prepare(initialState);
+  const publish = (nextStateOrUpdater) => {
+    const nextState = typeof nextStateOrUpdater === "function" ? nextStateOrUpdater(snapshot) : nextStateOrUpdater;
+    if (Object.is(snapshot, nextState)) return false;
+    snapshot = prepare(nextState);
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch (error) {
+        report("CoreStore subscriber", error, "warn");
+      }
+    }
+    return true;
+  };
+  const setState = (updater) => {
+    if (typeof updater === "function") {
+      return publish(updater);
+    }
+    if (snapshot && typeof snapshot === "object" && updater && typeof updater === "object") {
+      return publish({ ...snapshot, ...updater });
+    }
+    return publish(updater);
+  };
+  return Object.freeze({
+    getSnapshot() {
+      return snapshot;
+    },
+    publish,
+    setState,
+    subscribe(listener) {
+      if (typeof listener !== "function") return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  });
+}
+var init_store = __esm({
+  "src/utils/store.ts"() {
+    init_report();
+  }
+});
+var init_scheduler = __esm({
+  "src/utils/scheduler.ts"() {
+    init_report();
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_cn();
+    init_dom();
+    init_string();
+    init_number();
+    init_object();
+    init_timing();
+    init_json();
+    init_report();
+    init_user_message();
+    init_store();
+    init_scheduler();
+  }
+});
+
+// src/kernel/types.ts
+var init_types = __esm({
+  "src/kernel/types.ts"() {
+  }
+});
+
+// src/kernel/constants.ts
+var DEFAULT_SOURCE, REGISTRY_SOURCES, REGISTRY_LIFECYCLES, REGISTRY_VALIDATION_MODES, REGISTRY_METADATA_KEYS, REGISTRY_LIFECYCLE_VALUES, REGISTRY_METADATA_KEY_SET, REGISTRY_SCOPE_KINDS;
+var init_constants = __esm({
+  "src/kernel/constants.ts"() {
+    DEFAULT_SOURCE = "dynamic";
+    REGISTRY_SOURCES = Object.freeze({
+      STATIC: "static",
+      DYNAMIC: "dynamic",
+      USER: "user"
+    });
+    REGISTRY_LIFECYCLES = Object.freeze({
+      IMMEDIATE: "immediate",
+      GRACEFUL: "graceful",
+      PERSISTENT: "persistent",
+      ROUTE: "route"
+    });
+    REGISTRY_VALIDATION_MODES = Object.freeze({
+      WARN: "warn",
+      STRICT: "strict"
+    });
+    REGISTRY_METADATA_KEYS = Object.freeze([
+      "cleanup",
+      "cleanupDelayMs",
+      "instanceId",
+      "lifecycle",
+      "priority",
+      "source",
+      "scope",
+      "validation"
+    ]);
+    Object.freeze({
+      [REGISTRY_SOURCES.STATIC]: 100,
+      [REGISTRY_SOURCES.DYNAMIC]: 200,
+      [REGISTRY_SOURCES.USER]: 300
+    });
+    Object.freeze({
+      [REGISTRY_SOURCES.STATIC]: 10,
+      [REGISTRY_SOURCES.DYNAMIC]: 20,
+      [REGISTRY_SOURCES.USER]: 30
+    });
+    REGISTRY_LIFECYCLE_VALUES = new Set(
+      Object.values(REGISTRY_LIFECYCLES)
+    );
+    REGISTRY_METADATA_KEY_SET = new Set(
+      REGISTRY_METADATA_KEYS
+    );
+    REGISTRY_SCOPE_KINDS = Object.freeze({
+      APP: "app",
+      SESSION: "session",
+      ROUTE: "route",
+      INSTANCE: "instance",
+      WORKSPACE: "workspace"
+    });
+    REGISTRY_SCOPE_KINDS.APP;
+  }
+});
+
+// src/kernel/utils.ts
+function parseFiniteNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function getValidString(value, fallback = null) {
+  return trimToNull(value) ?? fallback;
+}
+var init_utils2 = __esm({
+  "src/kernel/utils.ts"() {
+    init_constants();
+    init_utils();
+  }
+});
+
+// src/kernel/schema.ts
+function resolveLifecycle(metadata, fallback) {
+  const lifecycle = metadata?.lifecycle ?? metadata?.cleanup;
+  return lifecycle && REGISTRY_LIFECYCLE_VALUES.has(lifecycle) ? lifecycle : fallback;
+}
+function validateRegistryMetadata(metadata) {
+  if (metadata === void 0 || metadata === null)
+    return { issues: [], valid: true };
+  if (!isObject(metadata))
+    return { issues: ["registry metadata must be an object"], valid: false };
+  const issues = [];
+  Object.keys(metadata).forEach((key) => {
+    if (!REGISTRY_METADATA_KEY_SET.has(key))
+      issues.push(`unknown registry metadata field: ${key}`);
+  });
+  if (metadata.source !== void 0 && !getValidString(metadata.source))
+    issues.push("source must be a non-empty string");
+  if (metadata.instanceId !== void 0 && !getValidString(metadata.instanceId))
+    issues.push("instanceId must be a non-empty string");
+  if (metadata.scope !== void 0 && !getValidString(metadata.scope))
+    issues.push("scope must be a non-empty string");
+  if (metadata.priority !== void 0 && parseFiniteNumber(metadata.priority) === null)
+    issues.push("priority must be a finite number");
+  if (metadata.cleanupDelayMs !== void 0) {
+    const delay = parseFiniteNumber(metadata.cleanupDelayMs);
+    if (delay === null || delay < 0)
+      issues.push("cleanupDelayMs must be a non-negative finite number");
+  }
+  const lifecycle = metadata.lifecycle ?? metadata.cleanup;
+  if (lifecycle !== void 0 && !REGISTRY_LIFECYCLE_VALUES.has(String(lifecycle))) {
+    issues.push(
+      `lifecycle must be one of: ${[...REGISTRY_LIFECYCLE_VALUES].join(", ")}`
+    );
+  }
+  if (metadata.validation !== void 0 && !Object.values(REGISTRY_VALIDATION_MODES).includes(
+    metadata.validation
+  )) {
+    issues.push(
+      `validation must be one of: ${Object.values(REGISTRY_VALIDATION_MODES).join(", ")}`
+    );
+  }
+  return { issues, valid: issues.length === 0 };
+}
+function normalizeRegistryMetadata(metadata, {
+  defaultCleanupDelayMs = null,
+  defaultLifecycle = null,
+  defaultSource = DEFAULT_SOURCE
+} = {}) {
+  const registryMeta = isObject(metadata) ? metadata : {};
+  const normalizedDefaultDelay = parseFiniteNumber(defaultCleanupDelayMs);
+  const fallbackCleanupDelayMs = normalizedDefaultDelay !== null && normalizedDefaultDelay >= 0 ? normalizedDefaultDelay : null;
+  const fallbackLifecycle = defaultLifecycle && REGISTRY_LIFECYCLE_VALUES.has(defaultLifecycle) ? defaultLifecycle : null;
+  const source = getValidString(registryMeta.source) || getValidString(defaultSource, DEFAULT_SOURCE) || DEFAULT_SOURCE;
+  const scope = getValidString(registryMeta.scope);
+  const priority = parseFiniteNumber(registryMeta.priority);
+  const lifecycle = resolveLifecycle(registryMeta, fallbackLifecycle);
+  const validation = isValidationMode(registryMeta.validation) ? registryMeta.validation : null;
+  const cleanupDelayCandidate = parseFiniteNumber(registryMeta.cleanupDelayMs);
+  let cleanupDelayMs = cleanupDelayCandidate !== null && cleanupDelayCandidate >= 0 ? cleanupDelayCandidate : fallbackCleanupDelayMs;
+  if (lifecycle === REGISTRY_LIFECYCLES.IMMEDIATE) {
+    cleanupDelayMs = 0;
+  } else if ((lifecycle === REGISTRY_LIFECYCLES.GRACEFUL || lifecycle === REGISTRY_LIFECYCLES.ROUTE) && cleanupDelayMs === null) {
+    cleanupDelayMs = fallbackCleanupDelayMs;
+  }
+  return {
+    cleanupDelayMs,
+    lifecycle,
+    priority,
+    registerOptions: {
+      ...priority !== null && { priority },
+      ...validation === REGISTRY_VALIDATION_MODES.STRICT && { validation },
+      ...scope && { scope }
+    },
+    source,
+    ...scope && { scope },
+    ...validation && { validation }
+  };
+}
+function isValidationMode(value) {
+  return Object.values(REGISTRY_VALIDATION_MODES).includes(value);
+}
+function pickRegistryMetadata(options) {
+  if (!isObject(options)) return {};
+  return Object.fromEntries(
+    REGISTRY_METADATA_KEYS.filter((key) => options[key] !== void 0).map(
+      (key) => [key, options[key]]
+    )
+  );
+}
+var init_schema = __esm({
+  "src/kernel/schema.ts"() {
+    init_constants();
+    init_utils2();
+  }
+});
+
+// src/kernel/operations.ts
+var init_operations = __esm({
+  "src/kernel/operations.ts"() {
+    init_constants();
+    init_utils2();
+    init_schema();
+  }
+});
+function useRequiredContext(context, hookName, providerName) {
+  const value = use(context);
+  if (value === null) {
+    throw new Error(`${hookName} must be used within ${providerName}`);
+  }
+  return value;
+}
+var init_use_required_context = __esm({
+  "src/hooks/use-required-context.ts"() {
+    "use client";
+  }
+});
+function useStore(store, selector = (state) => state, isEqual = Object.is) {
+  const cacheRef = useRef({
+    isEqual: null,
+    selected: void 0,
+    selector: null,
+    snapshot: null
+  });
+  const getSelectedSnapshot = useCallback(() => {
+    const snapshot = store.getSnapshot();
+    const cache = cacheRef.current;
+    if (cache.snapshot === snapshot && cache.selector === selector && cache.isEqual === isEqual) {
+      return cache.selected;
+    }
+    const selected = selector(snapshot);
+    if (cache.snapshot !== null && cache.isEqual === isEqual && isEqual(cache.selected, selected)) {
+      cache.snapshot = snapshot;
+      cache.selector = selector;
+      return cache.selected;
+    }
+    cacheRef.current = {
+      isEqual,
+      selected,
+      selector,
+      snapshot
+    };
+    return selected;
+  }, [isEqual, selector, store]);
+  return useSyncExternalStore(
+    store.subscribe,
+    getSelectedSnapshot,
+    getSelectedSnapshot
+  );
+}
+var init_use_store = __esm({
+  "src/hooks/use-store.ts"() {
+    "use client";
+  }
+});
+var init_use_click_outside = __esm({
+  "src/hooks/use-click-outside.ts"() {
+    "use client";
+  }
+});
+var useIsomorphicLayoutEffect;
+var init_use_isomorphic_layout_effect = __esm({
+  "src/hooks/use-isomorphic-layout-effect.ts"() {
+    "use client";
+    init_utils();
+    useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
+  }
+});
+var init_use_debounce = __esm({
+  "src/hooks/use-debounce.ts"() {
+    "use client";
+  }
+});
+var init_use_mounted = __esm({
+  "src/hooks/use-mounted.ts"() {
+    "use client";
+  }
+});
+var init_use_media_query = __esm({
+  "src/hooks/use-media-query.ts"() {
+    "use client";
+    init_utils();
+  }
+});
+var init_use_controllable_state = __esm({
+  "src/hooks/use-controllable-state.ts"() {
+    "use client";
+    init_use_isomorphic_layout_effect();
+  }
+});
+var init_use_hotkey = __esm({
+  "src/hooks/use-hotkey.ts"() {
+    "use client";
+    init_utils();
+    init_use_isomorphic_layout_effect();
+  }
+});
+
+// src/events.ts
+var EventEmitter, GLOBAL_EVENTS_KEY, _global;
+var init_events = __esm({
+  "src/events.ts"() {
+    init_report();
+    EventEmitter = class {
+      events = /* @__PURE__ */ new Map();
+      debounceTimers = /* @__PURE__ */ new Map();
+      subscribe(event, callback) {
+        if (typeof event !== "string" || !event || typeof callback !== "function") {
+          return () => {
+          };
+        }
+        const listeners = this.events.get(event) || /* @__PURE__ */ new Set();
+        listeners.add(callback);
+        this.events.set(event, listeners);
+        return () => {
+          listeners.delete(callback);
+          if (listeners.size === 0) this.events.delete(event);
+        };
+      }
+      emit(event, payload) {
+        const listeners = this.events.get(event);
+        if (!listeners || listeners.size === 0) return;
+        const snapshot = Array.from(listeners);
+        for (const callback of snapshot) {
+          try {
+            callback(payload);
+          } catch (error) {
+            report(`Event listener (${String(event)})`, error);
+          }
+        }
+      }
+      emitDebounced(event, payload, waitMs = 100) {
+        const existing = this.debounceTimers.get(event);
+        if (existing) clearTimeout(existing);
+        const timer = setTimeout(() => {
+          this.debounceTimers.delete(event);
+          this.emit(event, payload);
+        }, waitMs);
+        this.debounceTimers.set(event, timer);
+      }
+      cancelDebounced(event) {
+        if (event) {
+          const timer = this.debounceTimers.get(event);
+          if (timer) {
+            clearTimeout(timer);
+            this.debounceTimers.delete(event);
+          }
+        } else {
+          for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+          }
+          this.debounceTimers.clear();
+        }
+      }
+      unsubscribeAll(event) {
+        this.cancelDebounced(event);
+        if (event) this.events.delete(event);
+        else this.events.clear();
+      }
+      hasListeners(event) {
+        return Boolean(this.events.get(event)?.size);
+      }
+      getListenerCount(event) {
+        return this.events.get(event)?.size || 0;
+      }
+      getAllEvents() {
+        return [...this.events.keys()];
+      }
+    };
+    GLOBAL_EVENTS_KEY = /* @__PURE__ */ Symbol.for("__base_framework_global_events__");
+    _global = globalThis;
+    _global[GLOBAL_EVENTS_KEY] ?? (_global[GLOBAL_EVENTS_KEY] = new EventEmitter());
+  }
+});
+var init_use_global_event = __esm({
+  "src/hooks/use-global-event.ts"() {
+    "use client";
+    init_events();
+    init_use_isomorphic_layout_effect();
+  }
+});
+
+// src/result.ts
+var init_result = __esm({
+  "src/result.ts"() {
+    init_user_message();
+    init_report();
+  }
+});
+var init_use_async_action = __esm({
+  "src/hooks/use-async-action.ts"() {
+    "use client";
+    init_events();
+    init_result();
+    init_utils();
+  }
+});
+var init_use_server_action = __esm({
+  "src/hooks/use-server-action.ts"() {
+    "use client";
+    init_events();
+    init_result();
+    init_utils();
+  }
+});
+var init_use_storage_state = __esm({
+  "src/hooks/use-storage-state.ts"() {
+    "use client";
+    init_utils();
+    init_use_isomorphic_layout_effect();
+  }
+});
+var init_use_intersection_observer = __esm({
+  "src/hooks/use-intersection-observer.ts"() {
+    "use client";
+    init_utils();
+    init_use_isomorphic_layout_effect();
+  }
+});
+
+// src/hooks/index.ts
+var init_hooks = __esm({
+  "src/hooks/index.ts"() {
+    "use client";
+    init_use_required_context();
+    init_use_store();
+    init_use_click_outside();
+    init_use_isomorphic_layout_effect();
+    init_use_debounce();
+    init_use_mounted();
+    init_use_media_query();
+    init_use_controllable_state();
+    init_use_hotkey();
+    init_use_global_event();
+    init_use_async_action();
+    init_use_server_action();
+    init_use_storage_state();
+    init_use_intersection_observer();
+    init_use_fullscreen_state();
+  }
+});
+
+// src/kernel/runtime.ts
+var init_runtime = __esm({
+  "src/kernel/runtime.ts"() {
+    "use client";
+  }
+});
+function createNoopHandle(status = "rejected", reason = "unknown") {
+  const handle = Object.assign(() => false, {
+    active: false,
+    dispose: () => false,
+    instanceId: null,
+    key: "",
+    priority: 0,
+    reason,
+    source: "",
+    status,
+    type: "",
+    update: () => handle,
+    updatedAt: 0,
+    validation: "warn"
+  });
+  return handle;
+}
+var init_store2 = __esm({
+  "src/kernel/store.ts"() {
+    init_operations();
+    init_schema();
+    init_runtime();
+    init_utils();
+    createNoopHandle();
+  }
+});
+function getOrCreateGlobalContext(name, defaultValue) {
+  const sym = /* @__PURE__ */ Symbol.for(`@omerdlw/base-framework/context/${name}`);
+  const store = globalThis;
+  if (!store[sym]) {
+    store[sym] = createContext(defaultValue);
+  }
+  return store[sym];
+}
+var init_context_registry = __esm({
+  "src/kernel/context-registry.ts"() {
+  }
+});
+function useRegistryActions() {
+  return useRequiredContext(
+    RegistryContext,
+    "useRegistryActions",
+    "RegistryProvider"
+  ).actions;
+}
+function useRegistrySubscription() {
+  return useRequiredContext(
+    RegistryContext,
+    "useRegistrySubscription",
+    "RegistryProvider"
+  ).subscription;
+}
+function useRegistryEntries(type) {
+  const { getEntriesSnapshot, subscribe } = useRegistrySubscription();
+  const subscribeToType = useCallback(
+    (listener) => subscribe(type, null, listener),
+    [subscribe, type]
+  );
+  const getEntries = useCallback(
+    () => getEntriesSnapshot(type),
+    [getEntriesSnapshot, type]
+  );
+  return useSyncExternalStore(subscribeToType, getEntries, getEntries);
+}
+var RegistryContext;
+var init_provider = __esm({
+  "src/kernel/provider.tsx"() {
+    "use client";
+    init_hooks();
+    init_store2();
+    init_context_registry();
+    RegistryContext = getOrCreateGlobalContext(
+      "RegistryContext",
+      null
+    );
+  }
+});
+function selectModuleSlice(coreModule, config) {
+  const slice = coreModule.page?.select ? coreModule.page.select(config) : config[coreModule.id];
+  return slice ?? null;
+}
+function createModulePayload(modules, config, metadata = {}) {
+  const payload = {};
+  let hasSlices = false;
+  for (const coreModule of modules) {
+    if (!coreModule.page?.entries) continue;
+    const slice = selectModuleSlice(coreModule, config);
+    if (slice === null) continue;
+    payload[coreModule.id] = slice;
+    hasSlices = true;
+  }
+  if (!hasSlices) return null;
+  return {
+    ...payload,
+    registry: {
+      ...metadata,
+      ...isObject(config.registry) ? config.registry : {}
+    }
+  };
+}
+function useInstalledModules() {
+  return use(ModuleHostContext)?.modules ?? EMPTY_MODULES;
+}
+var EMPTY_MODULES, PassthroughBoundary, ModuleHostContext;
+var init_installed = __esm({
+  "src/kernel/installed.ts"() {
+    "use client";
+    init_utils();
+    init_context_registry();
+    EMPTY_MODULES = Object.freeze([]);
+    PassthroughBoundary = ({ children }) => children;
+    ModuleHostContext = getOrCreateGlobalContext("ModuleHostContext", null);
+  }
+});
+
+// src/kernel/handlers.ts
+function isPersistentLifecycle(lifecycle) {
+  return lifecycle === REGISTRY_LIFECYCLES.PERSISTENT;
+}
+function runRegistrationBatch(context, executor) {
+  return typeof context.batch === "function" ? context.batch(executor) : executor(context);
+}
+function createEntryCleanupKey(type, key, source, instanceId, scope) {
+  return JSON.stringify([
+    "entry",
+    type,
+    key,
+    scope ?? null,
+    source,
+    instanceId
+  ]);
+}
+function getCleanupScope(context) {
+  return context?.cleanupScope || /* @__PURE__ */ new Map();
+}
+function clearCleanupTimer(scope, cleanupKey) {
+  const lifecycle = scope.get(cleanupKey);
+  if (!lifecycle) return;
+  lifecycle.cancelled = true;
+  if (lifecycle.timerId !== null) clearTimeout(lifecycle.timerId);
+  scope.delete(cleanupKey);
+}
+function scheduleCleanup(scope, cleanupKey, callback, delayMs) {
+  clearCleanupTimer(scope, cleanupKey);
+  const lifecycle = {
+    cancelled: false,
+    timerId: null
+  };
+  lifecycle.timerId = setTimeout(() => {
+    if (lifecycle.cancelled || scope.get(cleanupKey) !== lifecycle) return;
+    scope.delete(cleanupKey);
+    callback();
+  }, delayMs);
+  scope.set(cleanupKey, lifecycle);
+}
+function collectModuleRegistrations(coreModule, slice, pageMetadata, context) {
+  const definition = coreModule.registry;
+  const toEntries = coreModule.page?.entries;
+  if (!definition || !toEntries || slice == null || slice === false) return [];
+  const type = coreModule.id;
+  const items = Array.isArray(slice) ? slice : [slice];
+  const registrations = [];
+  for (const item of items) {
+    if (item == null || item === false) continue;
+    const itemMetadata = isObject(item) && isObject(item.registry) ? item.registry : {};
+    const metadata = { ...pageMetadata, ...itemMetadata };
+    if (metadata.validation === "strict" && !validateRegistryMetadata(metadata).valid) {
+      continue;
+    }
+    const payload = isObject(item) ? Object.fromEntries(
+      Object.entries(item).filter(([key]) => key !== "registry")
+    ) : item;
+    const { cleanupDelayMs, lifecycle, registerOptions, scope, source } = normalizeRegistryMetadata(metadata, {
+      defaultCleanupDelayMs: definition.cleanupDelayMs ?? null,
+      defaultLifecycle: definition.lifecycle,
+      defaultSource: DEFAULT_SOURCE
+    });
+    for (const { key, value } of toEntries(payload, context) ?? []) {
+      const validation = definition.validate?.(value);
+      if (validation && !validation.valid) {
+        report(`Registry ${type} config is invalid`, validation.issues, "warn");
+        continue;
+      }
+      registrations.push({
+        cleanupDelayMs,
+        cleanupKey: createEntryCleanupKey(
+          type,
+          key,
+          source,
+          context.instanceId,
+          scope
+        ),
+        key,
+        lifecycle,
+        registerOptions,
+        scope,
+        source,
+        type,
+        value
+      });
+    }
+  }
+  return registrations;
+}
+function applyRegistryConfig(config, context) {
+  const modules = context.modules ?? [];
+  if (!config || modules.length === 0) return NO_CLEANUP;
+  const pageMetadata = isObject(config.registry) ? config.registry : {};
+  const slices = config;
+  const registrations = modules.flatMap((coreModule) => {
+    try {
+      return collectModuleRegistrations(
+        coreModule,
+        slices[coreModule.id],
+        pageMetadata,
+        context
+      );
+    } catch (error) {
+      report(`Registry apply (${coreModule.id})`, error);
+      return [];
+    }
+  });
+  if (registrations.length === 0) return NO_CLEANUP;
+  const cleanupScope = getCleanupScope(context);
+  const owner = (registration) => ({
+    instanceId: context.instanceId,
+    scope: registration.scope,
+    source: registration.source
+  });
+  runRegistrationBatch(context, (queue) => {
+    registrations.forEach(
+      ({ cleanupKey, key, registerOptions, source, type, value }) => {
+        clearCleanupTimer(cleanupScope, cleanupKey);
+        queue.register(type, key, value, source, registerOptions);
+      }
+    );
+  });
+  return () => {
+    const immediate = [];
+    registrations.forEach((registration) => {
+      if (isPersistentLifecycle(registration.lifecycle)) return;
+      const { cleanupDelayMs, cleanupKey, key, type } = registration;
+      if (typeof cleanupDelayMs === "number" && cleanupDelayMs > 0) {
+        scheduleCleanup(
+          cleanupScope,
+          cleanupKey,
+          () => context.unregister(type, key, owner(registration)),
+          cleanupDelayMs
+        );
+      } else {
+        immediate.push(registration);
+      }
+    });
+    if (immediate.length === 0) return;
+    runRegistrationBatch(context, (queue) => {
+      immediate.forEach(
+        (registration) => queue.unregister(
+          registration.type,
+          registration.key,
+          owner(registration)
+        )
+      );
+    });
+  };
+}
+var NO_CLEANUP;
+var init_handlers = __esm({
+  "src/kernel/handlers.ts"() {
+    init_schema();
+    init_utils2();
+    init_utils();
+    NO_CLEANUP = () => {
+    };
+  }
+});
+function withInstanceId(instanceId, sourceOrOptions, optionsArg) {
+  if (typeof sourceOrOptions === "string") {
+    return {
+      optionsArg: { ...isObject(optionsArg) ? optionsArg : {}, instanceId },
+      sourceOrOptions
+    };
+  }
+  if (isObject(sourceOrOptions)) {
+    return {
+      optionsArg,
+      sourceOrOptions: { ...sourceOrOptions, instanceId }
+    };
+  }
+  return {
+    optionsArg: void 0,
+    sourceOrOptions: {
+      ...isObject(optionsArg) ? optionsArg : {},
+      instanceId
+    }
+  };
+}
+function withInstanceIdForUnregister(instanceId, sourceOrOptions) {
+  if (typeof sourceOrOptions === "string") {
+    return { instanceId, source: sourceOrOptions };
+  }
+  if (isObject(sourceOrOptions)) {
+    return { ...sourceOrOptions, instanceId };
+  }
+  return { instanceId };
+}
+function resolveRegisterArgsWithInstance(instanceId, sourceOrOptions, optionsArg) {
+  const input = withInstanceId(instanceId, sourceOrOptions, optionsArg);
+  return [input.sourceOrOptions, input.optionsArg];
+}
+function createStableFunctionEntry(fn) {
+  const entry = {
+    current: fn,
+    stable(...args) {
+      return entry.current?.apply(this, args);
+    }
+  };
+  return entry;
+}
+function isDirectRegistryComponentPath(path, componentSlices) {
+  const match = /^config\.([^.[]+)\.[^.[]+$/.exec(path);
+  return Boolean(match && componentSlices.has(match[1]));
+}
+function isReactNodeLike(value) {
+  return value === null || value === void 0 || typeof value === "boolean" || typeof value === "string" || typeof value === "number" || isValidElement(value);
+}
+function isStabilizableObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isValidElement(value);
+}
+function hasSameObjectKeys(previousValue, nextValue) {
+  if (!isStabilizableObject(previousValue) || !isStabilizableObject(nextValue)) {
+    return false;
+  }
+  const previousKeys = Object.keys(previousValue);
+  const nextKeys = Object.keys(nextValue);
+  if (previousKeys.length !== nextKeys.length) return false;
+  return nextKeys.every(
+    (key) => Object.prototype.hasOwnProperty.call(previousValue, key)
+  );
+}
+function stabilizeRegistryValue(value, path, scope, previousValue, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (depth > MAX_STABILIZATION_DEPTH) return value;
+  if (typeof value === "function") {
+    const isComponent = value.name && /^[A-Z]/.test(value.name);
+    if (isComponent || isDirectRegistryComponentPath(path, scope.componentSlices)) {
+      return value;
+    }
+    scope.usedPaths.add(path);
+    let entry = scope.functionEntries.get(path);
+    if (!entry) {
+      entry = createStableFunctionEntry(value);
+      scope.functionEntries.set(path, entry);
+    } else {
+      entry.current = value;
+    }
+    return entry.stable;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) return value;
+    seen.add(value);
+  }
+  if (isValidElement(value)) {
+    const nextProps = stabilizeRegistryValue(
+      value.props,
+      `${path}.props`,
+      scope,
+      isValidElement(previousValue) ? previousValue.props : void 0,
+      seen,
+      depth + 1
+    );
+    if (isValidElement(previousValue) && previousValue.type === value.type && previousValue.key === value.key && previousValue.props === nextProps) {
+      return previousValue;
+    }
+    return cloneElement(value, nextProps);
+  }
+  if (Array.isArray(value)) {
+    const nextValue = value.every(isReactNodeLike) ? Children.toArray(value) : value;
+    const previousArray = Array.isArray(previousValue) ? previousValue : null;
+    let hasChanged2 = !previousArray || previousArray.length !== nextValue.length;
+    const stabilizedValue2 = nextValue.map((item, index) => {
+      const nextItem = stabilizeRegistryValue(
+        item,
+        `${path}[${index}]`,
+        scope,
+        previousArray?.[index],
+        seen,
+        depth + 1
+      );
+      if (!previousArray || nextItem !== previousArray[index]) {
+        hasChanged2 = true;
+      }
+      return nextItem;
+    });
+    return !hasChanged2 ? previousArray : stabilizedValue2;
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const source = value;
+  const previousRecord = previousValue;
+  const stabilizedValue = {};
+  const canReusePrevious = hasSameObjectKeys(previousValue, value);
+  let hasChanged = !canReusePrevious;
+  Object.keys(source).forEach((key) => {
+    const nextValue = stabilizeRegistryValue(
+      source[key],
+      `${path}.${key}`,
+      scope,
+      previousRecord?.[key],
+      seen,
+      depth + 1
+    );
+    stabilizedValue[key] = nextValue;
+    if (!canReusePrevious || nextValue !== previousRecord?.[key]) {
+      hasChanged = true;
+    }
+  });
+  return !hasChanged ? previousValue : stabilizedValue;
+}
+function useAppliedRegistryConfig(payload, context, componentSlices) {
+  const functionEntriesRef = useRef(/* @__PURE__ */ new Map());
+  const appliedRef = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    const previous = appliedRef.current;
+    if (previous && previous.payload === payload && previous.context === context) {
+      return;
+    }
+    const functionEntries = functionEntriesRef.current;
+    const usedPaths = /* @__PURE__ */ new Set();
+    const config = stabilizeRegistryValue(
+      payload,
+      "config",
+      { componentSlices, functionEntries, usedPaths },
+      previous?.config
+    );
+    functionEntries.forEach((_entry, path) => {
+      if (!usedPaths.has(path)) functionEntries.delete(path);
+    });
+    if (previous && previous.config === config && previous.context === context) {
+      previous.payload = payload;
+      return;
+    }
+    previous?.cleanup();
+    appliedRef.current = {
+      cleanup: applyRegistryConfig(config, context),
+      config,
+      context,
+      payload
+    };
+  });
+  useIsomorphicLayoutEffect(
+    () => () => {
+      appliedRef.current?.cleanup();
+      appliedRef.current = null;
+    },
+    []
+  );
+}
+function createRegistryApplyContext(actions, {
+  cleanupScope = /* @__PURE__ */ new Map(),
+  instanceId,
+  modules = [],
+  pathname
+}) {
+  const stamp = (queue) => ({
+    register: (type, key, item, sourceOrOptions, optionsArg) => queue.register(
+      type,
+      key,
+      item,
+      ...resolveRegisterArgsWithInstance(
+        instanceId,
+        sourceOrOptions,
+        optionsArg
+      )
+    ),
+    unregister: (type, key, sourceOrOptions) => queue.unregister(
+      type,
+      key,
+      withInstanceIdForUnregister(instanceId, sourceOrOptions)
+    )
+  });
+  return {
+    ...stamp(actions),
+    batch: (executor) => typeof executor === "function" ? actions.batch((queue) => executor(stamp(queue))) : 0,
+    cleanupScope,
+    instanceId,
+    modules,
+    pathname
+  };
+}
+function useRegistry(config, metadata) {
+  const { batch, register, unregister } = useRegistryActions();
+  const pathname = usePathname();
+  const modules = useInstalledModules();
+  const instanceId = `registry-instance-${useId()}`;
+  const [cleanupScope] = useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const context = useMemo(
+    () => createRegistryApplyContext(
+      { batch, register, unregister },
+      {
+        cleanupScope,
+        instanceId,
+        modules,
+        pathname
+      }
+    ),
+    [batch, cleanupScope, instanceId, modules, pathname, register, unregister]
+  );
+  const payload = useMemo(
+    () => config ? createModulePayload(modules, config, metadata) : null,
+    [config, metadata, modules]
+  );
+  const componentSlices = useMemo(
+    () => new Set(
+      modules.filter(
+        (coreModule) => coreModule.registry?.valueKind === "component"
+      ).map((coreModule) => coreModule.id)
+    ),
+    [modules]
+  );
+  useAppliedRegistryConfig(payload, context, componentSlices);
+}
+var MAX_STABILIZATION_DEPTH;
+var init_hooks2 = __esm({
+  "src/kernel/hooks.ts"() {
+    "use client";
+    init_hooks();
+    init_handlers();
+    init_installed();
+    init_provider();
+    init_utils();
+    MAX_STABILIZATION_DEPTH = 64;
+  }
+});
+function createPageControllerStore() {
+  const listeners = /* @__PURE__ */ new Set();
+  let stack = [];
+  const notify = () => {
+    listeners.forEach((listener) => {
+      try {
+        listener();
+      } catch (error) {
+        report("Page controller listener", error);
+      }
+    });
+  };
+  return {
+    getSnapshot() {
+      const top = stack[stack.length - 1];
+      return top?.controllerRef?.current || null;
+    },
+    notify,
+    register(id, controllerRef) {
+      stack = stack.filter((item) => item.id !== id);
+      stack.push({ controllerRef, id });
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    unregister(id) {
+      stack = stack.filter((item) => item.id !== id);
+      notify();
+    }
+  };
+}
+var fallbackStandaloneStore;
+var init_page_controller = __esm({
+  "src/kernel/page-controller.tsx"() {
+    "use client";
+    init_hooks();
+    init_hooks2();
+    init_installed();
+    init_schema();
+    init_utils2();
+    init_utils();
+    init_context_registry();
+    fallbackStandaloneStore = createPageControllerStore();
+    getOrCreateGlobalContext(
+      "PageControllerContext",
+      null
+    );
+    getOrCreateGlobalContext(
+      "PageControllerStoreContext",
+      fallbackStandaloneStore
+    );
+  }
+});
+function defineModule(coreModule) {
+  return Object.freeze({ ...coreModule });
+}
+function ModuleBoundary({
+  children,
+  name
+}) {
+  const Boundary = use(ModuleHostContext)?.Boundary ?? PassthroughBoundary;
+  return createElement(Boundary, { name }, children);
+}
+var init_module = __esm({
+  "src/kernel/module.tsx"() {
+    "use client";
+    init_hooks();
+    init_utils();
+    init_installed();
+    init_page_controller();
+    init_provider();
+    init_utils();
+    createStore(void 0);
+  }
+});
+
+// src/kernel/adapters.tsx
+function useModuleRegistration(id, value, options) {
+  const coreModule = useInstalledModules().find(
+    (candidate) => candidate.id === id
+  );
+  const config = coreModule && options?.enabled !== false && value != null ? { [id]: value } : null;
+  useRegistry(config, pickRegistryMetadata(options));
+}
+var init_adapters = __esm({
+  "src/kernel/adapters.tsx"() {
+    "use client";
+    init_schema();
+    init_hooks2();
+    init_installed();
+  }
+});
+var init_compose = __esm({
+  "src/kernel/compose.ts"() {
+  }
+});
+
+// src/kernel/index.ts
+var init_kernel = __esm({
+  "src/kernel/index.ts"() {
+    "use client";
+    init_types();
+    init_constants();
+    init_utils2();
+    init_operations();
+    init_provider();
+    init_store2();
+    init_installed();
+    init_module();
+    init_handlers();
+    init_hooks2();
+    init_adapters();
+    init_page_controller();
+    init_compose();
+  }
+});
+function defineThemeSpec(id) {
+  return Object.freeze({ id });
+}
+function useTheme(spec) {
+  const config = useContext(ThemeContext).get(spec.id);
+  if (!config) {
+    throw new Error(
+      `Theme "${spec.id}" is missing. Add its theme file to src/config/ and list it in src/config/index.ts.`
+    );
+  }
+  return {
+    slots: config.slots,
+    styles: config.styles ?? {}
+  };
+}
+var EMPTY, ThemeContext;
+var init_theme = __esm({
+  "src/theme.tsx"() {
+    "use client";
+    init_context_registry();
+    EMPTY = /* @__PURE__ */ new Map();
+    ThemeContext = getOrCreateGlobalContext("ThemeContext", EMPTY);
+  }
+});
+
+// src/modules/theme.ts
+var init_theme2 = __esm({
+  "src/modules/theme.ts"() {
+    init_theme();
+  }
+});
+
+// src/modules/modal/constants.ts
+var MODAL_POSITIONS, MODAL_CHROME, MODAL_BREAKPOINTS, SMOOTH_SCROLL_LOCK_EVENT, FOCUSABLE_SELECTOR, HEIGHT_CONSTRAINT_PATTERN, modalTheme;
+var init_constants2 = __esm({
+  "src/modules/modal/constants.ts"() {
+    init_theme2();
+    MODAL_POSITIONS = Object.freeze({
+      BOTTOM: "bottom",
+      CENTER: "center",
+      LEFT: "left",
+      RIGHT: "right",
+      TOP: "top"
+    });
+    MODAL_CHROME = Object.freeze({
+      BARE: "bare",
+      PANEL: "panel"
+    });
+    MODAL_BREAKPOINTS = Object.freeze({
+      MOBILE_MAX_WIDTH: 639
+    });
+    SMOOTH_SCROLL_LOCK_EVENT = "modal:smooth-scroll-lock";
+    FOCUSABLE_SELECTOR = 'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [contenteditable="true"], [tabindex]:not([tabindex="-1"])';
+    HEIGHT_CONSTRAINT_PATTERN = /(\s|^)(?:[\w-]+:)*(?:h|max-h)-/;
+    modalTheme = defineThemeSpec("modal");
+  }
+});
+
+// src/modules/modal/motion.ts
+function toCssDistance(value = 0) {
+  return typeof value === "number" ? `${Math.round(value)}px` : value;
+}
+function toGpuTransform(yOrConfig, scaleValue = 1) {
+  if (typeof yOrConfig === "object" && yOrConfig !== null) {
+    const xVal = yOrConfig.x ?? 0;
+    const yVal = yOrConfig.y ?? 0;
+    const sVal = yOrConfig.scale ?? 1;
+    const safeScale2 = Number.parseFloat(String(sVal));
+    const roundedScale2 = Number.isFinite(safeScale2) ? Math.round(safeScale2 * 1e3) / 1e3 : 1;
+    return `translate3d(${toCssDistance(xVal)}, ${toCssDistance(yVal)}, 0) scale(${roundedScale2})`;
+  }
+  const safeY = Number.parseFloat(String(yOrConfig));
+  const safeScale = Number.parseFloat(String(scaleValue));
+  const roundedY = Number.isFinite(safeY) ? Math.round(safeY) : 0;
+  const roundedScale = Number.isFinite(safeScale) ? Math.round(safeScale * 1e3) / 1e3 : 1;
+  return `translate3d(0, ${roundedY}px, 0) scale(${roundedScale})`;
+}
+function buildVariants(tierName, {
+  axis,
+  direction = 1,
+  fullSlide = false
+}) {
+  const tier = MODAL_TIERS[tierName];
+  const distance = fullSlide ? "100%" : tier.distance;
+  const signedDistance = direction < 0 ? fullSlide ? "-100%" : -Number(distance) : distance;
+  const transform = axis === "x" ? {
+    x: signedDistance
+  } : {
+    y: signedDistance
+  };
+  return Object.freeze({
+    exit: {
+      opacity: 0,
+      transform: toGpuTransform(transform),
+      transition: MODAL_SURFACE_EXIT_TRANSITION
+    },
+    hidden: {
+      opacity: 0,
+      transform: toGpuTransform(transform)
+    },
+    visible: {
+      opacity: 1,
+      transform: toGpuTransform(),
+      transition: MODAL_SURFACE_ENTER_TRANSITION
+    }
+  });
+}
+function getModalPositionVariants(position) {
+  switch (position) {
+    case MODAL_POSITIONS.BOTTOM:
+      return BOTTOM_VARIANTS;
+    case MODAL_POSITIONS.RIGHT:
+      return RIGHT_VARIANTS;
+    case MODAL_POSITIONS.LEFT:
+      return LEFT_VARIANTS;
+    case MODAL_POSITIONS.TOP:
+      return TOP_VARIANTS;
+    case MODAL_POSITIONS.CENTER:
+    default:
+      return CENTER_VARIANTS;
+  }
+}
+function getModalTransition(position) {
+  return position === MODAL_POSITIONS.CENTER ? MODAL_PANEL_SPRING : void 0;
+}
+var MODAL_EASINGS, MODAL_TIERS, MODAL_DURATIONS, MODAL_SPRINGS, MODAL_COMPOSITOR_STYLE, MODAL_PANEL_SPRING, MODAL_BACKDROP_TRANSITION, MODAL_BACKDROP_EXIT_TRANSITION, MODAL_SURFACE_ENTER_TRANSITION, MODAL_SURFACE_EXIT_TRANSITION, MODAL_BODY_ENTER_TRANSITION, MODAL_BODY_EXIT_TRANSITION, MODAL_CONTENT_VARIANTS, MODAL_HEADER_VARIANTS, MODAL_FOOTER_VARIANTS, modalBackdropVariants, CENTER_VARIANTS, BOTTOM_VARIANTS, RIGHT_VARIANTS, LEFT_VARIANTS, TOP_VARIANTS;
+var init_motion2 = __esm({
+  "src/modules/modal/motion.ts"() {
+    init_tokens2();
+    init_constants2();
+    MODAL_EASINGS = Object.freeze({
+      CINEMATIC: EASING_CURVES.OUT_EXPO,
+      EMPHASIZED: EASING_CURVES.OUT_EXPO,
+      EXIT: EASING_CURVES.IN_CUBIC,
+      FLUID: EASING_CURVES.OUT_QUART,
+      FLUID_RESIZE: EASING_CURVES.OUT_QUART,
+      PROGRESSIVE_EXIT: EASING_CURVES.IN_CUBIC,
+      SOFT: EASING_CURVES.OUT_QUART,
+      SOFT_EXIT: EASING_CURVES.IN_CUBIC
+    });
+    MODAL_TIERS = MOTION_TIERS;
+    MODAL_DURATIONS = Object.freeze({
+      BACKDROP_EXIT: DURATION_TOKENS.FAST,
+      BODY: DURATION_TOKENS.BASE,
+      BODY_EXIT: DURATION_TOKENS.FAST,
+      EDGE_EXIT: DURATION_TOKENS.FAST,
+      FAST: DURATION_TOKENS.FAST,
+      MODERATE: DURATION_TOKENS.MODERATE,
+      SLOT: DURATION_TOKENS.BASE,
+      SLOT_EXIT: DURATION_TOKENS.MICRO,
+      SLOW: DURATION_TOKENS.SLOW
+    });
+    MODAL_SPRINGS = Object.freeze({
+      DECK: Object.freeze({
+        damping: 28,
+        mass: 0.85,
+        stiffness: 240,
+        type: "spring"
+      }),
+      MICRO: Object.freeze({
+        damping: 32,
+        mass: 0.3,
+        stiffness: 480,
+        type: "spring"
+      }),
+      PANEL: Object.freeze({
+        damping: 28,
+        mass: 0.85,
+        stiffness: 240,
+        type: "spring"
+      })
+    });
+    MODAL_COMPOSITOR_STYLE = Object.freeze({
+      WebkitBackfaceVisibility: "hidden",
+      WebkitFontSmoothing: "antialiased",
+      backfaceVisibility: "hidden",
+      transform: "translateZ(0)",
+      willChange: "transform, opacity"
+    });
+    MODAL_PANEL_SPRING = MODAL_SPRINGS.PANEL;
+    MODAL_BACKDROP_TRANSITION = Object.freeze({
+      duration: MODAL_DURATIONS.SLOW,
+      ease: MODAL_EASINGS.FLUID,
+      type: "tween"
+    });
+    MODAL_BACKDROP_EXIT_TRANSITION = Object.freeze({
+      duration: MODAL_DURATIONS.BACKDROP_EXIT,
+      ease: MODAL_EASINGS.FLUID,
+      type: "tween"
+    });
+    MODAL_SURFACE_ENTER_TRANSITION = Object.freeze({
+      duration: MODAL_DURATIONS.SLOW,
+      ease: MODAL_EASINGS.FLUID,
+      type: "tween"
+    });
+    MODAL_SURFACE_EXIT_TRANSITION = Object.freeze({
+      duration: MODAL_DURATIONS.EDGE_EXIT,
+      ease: MODAL_EASINGS.EXIT,
+      type: "tween"
+    });
+    MODAL_BODY_ENTER_TRANSITION = Object.freeze({
+      delay: 0.04,
+      duration: MODAL_DURATIONS.BODY,
+      ease: MODAL_EASINGS.FLUID,
+      type: "tween"
+    });
+    MODAL_BODY_EXIT_TRANSITION = Object.freeze({
+      duration: MODAL_DURATIONS.BODY_EXIT,
+      ease: MODAL_EASINGS.EXIT,
+      type: "tween"
+    });
+    MODAL_CONTENT_VARIANTS = Object.freeze({
+      exit: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.98,
+          y: 12
+        }),
+        transition: MODAL_BODY_EXIT_TRANSITION
+      },
+      hidden: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.98,
+          y: 12
+        })
+      },
+      visible: {
+        opacity: 1,
+        transform: toGpuTransform(),
+        transition: MODAL_BODY_ENTER_TRANSITION
+      }
+    });
+    MODAL_HEADER_VARIANTS = Object.freeze({
+      exit: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.99,
+          y: -6
+        }),
+        transition: {
+          duration: MODAL_DURATIONS.SLOT_EXIT,
+          ease: MODAL_EASINGS.EXIT
+        }
+      },
+      hidden: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.99,
+          y: -6
+        })
+      },
+      visible: {
+        opacity: 1,
+        transform: toGpuTransform(),
+        transition: {
+          delay: 0.02,
+          duration: MODAL_DURATIONS.SLOT,
+          ease: MODAL_EASINGS.FLUID
+        }
+      }
+    });
+    MODAL_FOOTER_VARIANTS = Object.freeze({
+      exit: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.99,
+          y: 6
+        }),
+        transition: {
+          duration: MODAL_DURATIONS.SLOT_EXIT,
+          ease: MODAL_EASINGS.EXIT
+        }
+      },
+      hidden: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.99,
+          y: 6
+        })
+      },
+      visible: {
+        opacity: 1,
+        transform: toGpuTransform(),
+        transition: {
+          delay: 0.06,
+          duration: MODAL_DURATIONS.SLOT,
+          ease: MODAL_EASINGS.FLUID
+        }
+      }
+    });
+    modalBackdropVariants = Object.freeze({
+      exit: {
+        opacity: 0,
+        transition: MODAL_BACKDROP_EXIT_TRANSITION
+      },
+      hidden: {
+        opacity: 0
+      },
+      visible: {
+        opacity: 1,
+        transition: MODAL_BACKDROP_TRANSITION
+      }
+    });
+    CENTER_VARIANTS = Object.freeze({
+      exit: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.96,
+          y: 8
+        }),
+        transition: {
+          duration: MODAL_DURATIONS.FAST,
+          ease: MODAL_EASINGS.EXIT
+        }
+      },
+      hidden: {
+        opacity: 0,
+        transform: toGpuTransform({
+          scale: 0.95,
+          y: 12
+        })
+      },
+      visible: {
+        opacity: 1,
+        transform: toGpuTransform(),
+        transition: {
+          duration: MODAL_TIERS.STANDARD.duration,
+          ease: MODAL_EASINGS.FLUID
+        }
+      }
+    });
+    BOTTOM_VARIANTS = buildVariants("SURFACE", {
+      axis: "y",
+      fullSlide: true
+    });
+    RIGHT_VARIANTS = buildVariants("SURFACE", {
+      axis: "x",
+      fullSlide: true
+    });
+    LEFT_VARIANTS = buildVariants("SURFACE", {
+      axis: "x",
+      direction: -1,
+      fullSlide: true
+    });
+    TOP_VARIANTS = buildVariants("SURFACE", {
+      axis: "y",
+      direction: -1,
+      fullSlide: true
+    });
+  }
+});
+function getModalIdentity(input) {
+  if (typeof input === "string") return { component: null, type: input };
+  const options = typeof input === "function" ? { component: input } : input;
+  const component = options.component ?? null;
+  return {
+    component,
+    type: "type" in options && options.type || "id" in options && options.id || component?.displayName || component?.name || "modal"
+  };
+}
+function hasHeightConstraint(className) {
+  return typeof className === "string" && HEIGHT_CONSTRAINT_PATTERN.test(className);
+}
+function isSidePosition(position) {
+  return position === MODAL_POSITIONS.LEFT || position === MODAL_POSITIONS.RIGHT;
+}
+function isVerticalEdgePosition(position) {
+  return position === MODAL_POSITIONS.TOP || position === MODAL_POSITIONS.BOTTOM;
+}
+function hasSlotContent(value) {
+  return value !== null && value !== void 0 && value !== false && value !== "";
+}
+function isHeaderConfig(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && !isValidElement(value)
+  );
+}
+function resolveHeaderActions(actions, close) {
+  return typeof actions === "function" ? actions({ close }) : actions || null;
+}
+function getModalPosition(position) {
+  return position === MODAL_POSITIONS.TOP || position === MODAL_POSITIONS.BOTTOM || position === MODAL_POSITIONS.LEFT || position === MODAL_POSITIONS.RIGHT ? position : MODAL_POSITIONS.CENTER;
+}
+function getModalLayout(position, isMobile) {
+  const resolved = getModalPosition(position);
+  if (!isMobile) return resolved;
+  if (resolved === MODAL_POSITIONS.TOP || resolved === MODAL_POSITIONS.BOTTOM)
+    return `${resolved}-mobile`;
+  if (resolved === MODAL_POSITIONS.LEFT || resolved === MODAL_POSITIONS.RIGHT)
+    return "side-mobile";
+  return resolved;
+}
+function dispatchSmoothScrollLock(locked) {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(
+    new CustomEvent(SMOOTH_SCROLL_LOCK_EVENT, {
+      detail: { locked, source: "modal" }
+    })
+  );
+}
+function getViewportIsMobile() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia(
+    `(max-width: ${MODAL_BREAKPOINTS.MOBILE_MAX_WIDTH}px)`
+  ).matches;
+}
+function resolveActivePosition(position, responsivePosition, isMobileViewport) {
+  if (!isPlainObject(responsivePosition)) return position;
+  const responsive = isMobileViewport ? responsivePosition.mobile : responsivePosition.desktop;
+  return responsive || position;
+}
+function normalizePosition(input) {
+  if (typeof input === "string") {
+    return { position: input, responsivePosition: null };
+  }
+  if (!isPlainObject(input)) {
+    return { position: MODAL_POSITIONS.CENTER, responsivePosition: null };
+  }
+  return {
+    position: resolveActivePosition(
+      MODAL_POSITIONS.CENTER,
+      input,
+      getViewportIsMobile()
+    ),
+    responsivePosition: input
+  };
+}
+function getFocusableElements(container) {
+  if (!container || typeof container.querySelectorAll !== "function") return [];
+  return Array.from(
+    container.querySelectorAll(FOCUSABLE_SELECTOR)
+  ).filter(
+    (element) => !element.hasAttribute("disabled") && element.getAttribute("aria-hidden") !== "true"
+  );
+}
+function trapFocus(event, container) {
+  if (event.key !== "Tab" || !container) return;
+  const elements = getFocusableElements(container);
+  if (elements.length === 0) return;
+  const firstElement = elements[0];
+  const lastElement = elements[elements.length - 1];
+  if (event.shiftKey) {
+    if (document.activeElement === firstElement) {
+      event.preventDefault();
+      lastElement?.focus();
+    }
+  } else {
+    if (document.activeElement === lastElement) {
+      event.preventDefault();
+      firstElement?.focus();
+    }
+  }
+}
+function getModalLabel(modalType) {
+  if (typeof modalType !== "string" || !modalType.trim()) return "Modal";
+  return modalType.trim().toLowerCase().split(/[_-]+/).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+var init_utils3 = __esm({
+  "src/modules/modal/utils.ts"() {
+    init_utils();
+    init_constants2();
+  }
+});
+
+// src/modules/modal/state.ts
+function createModalState(modalStack = []) {
+  const activeModal = modalStack[modalStack.length - 1] || null;
+  return {
+    activeModalId: activeModal?.id || null,
+    chrome: activeModal?.chrome || MODAL_CHROME.PANEL,
+    headerActions: activeModal?.headerActions || null,
+    isOpen: modalStack.length > 0,
+    modalStack,
+    modalType: activeModal?.modalType || null,
+    position: activeModal?.position || MODAL_POSITIONS.CENTER,
+    props: activeModal?.props || {},
+    responsivePosition: activeModal?.responsivePosition || null,
+    showClose: activeModal?.showClose ?? true,
+    title: activeModal?.title || null
+  };
+}
+var INITIAL_MODAL_STATE;
+var init_state = __esm({
+  "src/modules/modal/state.ts"() {
+    init_constants2();
+    INITIAL_MODAL_STATE = createModalState([]);
+  }
+});
+function useModalRegistration(config, options) {
+  useModuleRegistration("modal", config, options);
+}
+function useModalRegistryEntries() {
+  const entries = useRegistryEntries("modal");
+  return useMemo(() => ({ get: (type) => entries[type] }), [entries]);
+}
+function ModalProvider({
+  children,
+  modalRenderer: ModalRenderer = null
+}) {
+  const [store] = useState(
+    () => createStore(INITIAL_MODAL_STATE, { freezeSnapshots: false })
+  );
+  const modalStackRef = useRef([]);
+  const pendingRef = useRef(/* @__PURE__ */ new Map());
+  const modalIdRef = useRef(0);
+  const syncModalStack = useCallback(
+    (nextStack) => {
+      modalStackRef.current = nextStack;
+      store.publish(createModalState(nextStack));
+    },
+    [store]
+  );
+  const settleModal = useCallback((modalId, result) => {
+    const pending = pendingRef.current.get(modalId);
+    if (!pending) return;
+    pendingRef.current.delete(modalId);
+    try {
+      const outcome = pending.onClose?.(result);
+      if (outcome instanceof Promise) {
+        outcome.catch((error) => report("Modal onClose", error));
+      }
+    } catch (error) {
+      report("Modal onClose", error);
+    }
+    pending.resolve(result);
+  }, []);
+  const openModal = useCallback(
+    (modalInput, options = {}) => {
+      if (!modalInput) return Promise.resolve(null);
+      const stack = modalStackRef.current;
+      const { component, type } = getModalIdentity(modalInput);
+      const topEntry = stack[stack.length - 1];
+      if (topEntry && (topEntry.modalType === type || component && topEntry.component === component)) {
+        return Promise.resolve(null);
+      }
+      const definition = typeof modalInput === "object" ? modalInput : void 0;
+      const merged = {
+        ...definition,
+        ...options
+      };
+      const data = { ...definition?.defaultData, ...options.data };
+      const modalId = ++modalIdRef.current;
+      const entry = {
+        chrome: merged.chrome || MODAL_CHROME.PANEL,
+        component,
+        headerActions: merged.actions || null,
+        id: modalId,
+        modalType: type,
+        props: data,
+        showClose: merged.showClose ?? true,
+        title: typeof merged.title === "function" ? merged.title(data) : merged.title ?? null,
+        ...normalizePosition(merged.position)
+      };
+      return new Promise((resolve) => {
+        pendingRef.current.set(modalId, { onClose: merged.onClose, resolve });
+        syncModalStack([...stack, entry]);
+      });
+    },
+    [syncModalStack]
+  );
+  const closeModal = useCallback(
+    (result = null, targetModalId = null) => {
+      const stack = modalStackRef.current;
+      const modalId = targetModalId || stack[stack.length - 1]?.id;
+      if (!modalId || !stack.some((entry) => entry.id === modalId)) return;
+      syncModalStack(stack.filter((entry) => entry.id !== modalId));
+      settleModal(modalId, result);
+    },
+    [settleModal, syncModalStack]
+  );
+  const closeAllModals = useCallback(
+    (result = null) => {
+      const stack = modalStackRef.current;
+      if (stack.length === 0) return;
+      syncModalStack([]);
+      stack.forEach((entry) => settleModal(entry.id, result));
+    },
+    [settleModal, syncModalStack]
+  );
+  const actionsValue = useMemo(
+    () => ({ closeAllModals, closeModal, openModal }),
+    [openModal, closeModal, closeAllModals]
+  );
+  const contextValue = useMemo(
+    () => ({ actions: actionsValue, store }),
+    [actionsValue, store]
+  );
+  return /* @__PURE__ */ jsxs(ModalContext, { value: contextValue, children: [
+    ModalRenderer && /* @__PURE__ */ jsx(ModalRenderer, {}),
+    children
+  ] });
+}
+function useModalActions() {
+  return useRequiredContext(ModalContext, "useModalActions", "ModalProvider").actions;
+}
+function useModalState() {
+  const { store } = useRequiredContext(
+    ModalContext,
+    "useModalState",
+    "ModalProvider"
+  );
+  return useStore(store);
+}
+function useModal(modalInput) {
+  const actions = useModalActions();
+  const state = useModalState();
+  return useMemo(() => {
+    if (!modalInput) return { ...actions, ...state };
+    const { component, type } = getModalIdentity(modalInput);
+    const isOpen = state.modalStack.some(
+      (entry) => entry.modalType === type || component && entry.component === component
+    );
+    const open = (data, overrides) => actions.openModal(modalInput, { ...overrides, data });
+    const controls = {
+      close: actions.closeModal,
+      closeAll: actions.closeAllModals,
+      isOpen,
+      state
+    };
+    return Object.assign([open, controls], controls, { open });
+  }, [actions, modalInput, state]);
+}
+var ModalContext;
+var init_context = __esm({
+  "src/modules/modal/context.tsx"() {
+    "use client";
+    init_hooks();
+    init_kernel();
+    init_utils();
+    init_constants2();
+    init_state();
+    init_utils3();
+    init_utils();
+    init_context_registry();
+    ModalContext = getOrCreateGlobalContext(
+      "ModalContext",
+      null
+    );
+  }
+});
+function useModalLayerModel({
+  closeModal,
+  entry,
+  isMobileViewport,
+  isTopModal,
+  modalStack,
+  registry,
+  stackIndex
+}) {
+  const modalRef = useRef(null);
+  const activePosition = useMemo(
+    () => resolveActivePosition(
+      entry.position,
+      entry.responsivePosition,
+      isMobileViewport
+    ),
+    [entry.position, entry.responsivePosition, isMobileViewport]
+  );
+  const ActiveModalComponent = entry.component || registry.get(entry.modalType);
+  const isPanelChrome = entry.chrome !== MODAL_CHROME.BARE;
+  const isLeftModal = activePosition === MODAL_POSITIONS.LEFT;
+  const isSide = isSidePosition(activePosition);
+  const isVerticalEdge = isVerticalEdgePosition(activePosition);
+  const previousEntry = modalStack[stackIndex - 1] || null;
+  const baseZIndex = Z_INDEX.MODAL;
+  useEffect(() => {
+    if (!isTopModal || !modalRef.current) return;
+    const previouslyFocusedElement = document.activeElement;
+    const initialElements = getFocusableElements(modalRef.current);
+    if (initialElements.length > 0) initialElements[0].focus();
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") closeModal(null, entry.id);
+      else trapFocus(event, modalRef.current);
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown);
+      if (previouslyFocusedElement?.isConnected)
+        previouslyFocusedElement.focus();
+    };
+  }, [closeModal, entry.id, isTopModal]);
+  return {
+    modalRef,
+    activePosition,
+    ActiveModalComponent,
+    isPanelChrome,
+    isLeftModal,
+    isSide,
+    isVerticalEdge,
+    previousEntry,
+    baseZIndex
+  };
+}
+function useModalContainerModel() {
+  return { theme: useTheme(modalTheme) };
+}
+function useModalModel() {
+  const { modalStack = [], isOpen, closeModal } = useModal();
+  const registry = useModalRegistryEntries();
+  const visibleModalStack = useMemo(
+    () => modalStack.filter(
+      (entry) => Boolean(entry.component || registry.get(entry.modalType))
+    ),
+    [modalStack, registry]
+  );
+  const topModalEntry = visibleModalStack[visibleModalStack.length - 1] || null;
+  const isModalVisible = Boolean(isOpen && topModalEntry);
+  const mounted = useSyncExternalStore(
+    emptySubscribe,
+    () => true,
+    () => false
+  );
+  const [isMobileViewport, setIsMobileViewport] = useState(getViewportIsMobile);
+  const [isTopExitSettling, setIsTopExitSettling] = useState(false);
+  const previousTopModalIdRef = useRef(null);
+  const releaseScrollLockRef = useRef(null);
+  useLayoutEffect(() => {
+    const currentTopModalId = topModalEntry?.id || null;
+    const previousTopModalId = previousTopModalIdRef.current;
+    const previousTopStillMounted = visibleModalStack.some(
+      (entry) => entry.id === previousTopModalId
+    );
+    if (previousTopModalId && previousTopModalId !== currentTopModalId && !previousTopStillMounted) {
+      setIsTopExitSettling(true);
+    }
+    previousTopModalIdRef.current = currentTopModalId;
+  }, [topModalEntry?.id, visibleModalStack]);
+  useEffect(() => {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mediaQuery = window.matchMedia(
+      `(max-width: ${MODAL_BREAKPOINTS.MOBILE_MAX_WIDTH}px)`
+    );
+    const handleViewportChange = (e) => setIsMobileViewport(e.matches);
+    mediaQuery.addEventListener("change", handleViewportChange);
+    return () => mediaQuery.removeEventListener("change", handleViewportChange);
+  }, []);
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    if (isModalVisible) {
+      releaseScrollLockRef.current ??= acquireGlobalScrollLock();
+    } else if (releaseScrollLockRef.current) {
+      releaseScrollLockRef.current();
+      releaseScrollLockRef.current = null;
+    }
+    dispatchSmoothScrollLock(isModalVisible);
+  }, [isModalVisible]);
+  useEffect(() => {
+    return () => {
+      releaseScrollLockRef.current?.();
+      releaseScrollLockRef.current = null;
+      dispatchSmoothScrollLock(false);
+    };
+  }, []);
+  return {
+    modalStack,
+    closeModal,
+    registry,
+    visibleModalStack,
+    topModalEntry,
+    isModalVisible,
+    mounted,
+    isMobileViewport,
+    isTopExitSettling,
+    setIsTopExitSettling,
+    theme: useTheme(modalTheme)
+  };
+}
+var emptySubscribe;
+var init_hooks3 = __esm({
+  "src/modules/modal/hooks.ts"() {
+    "use client";
+    init_tokens2();
+    init_utils();
+    init_theme2();
+    init_constants2();
+    init_utils3();
+    init_context();
+    emptySubscribe = () => () => {
+    };
+  }
+});
+
+// src/modules/modal/overlay.tsx
+var overlay_exports = {};
+__export(overlay_exports, {
+  Modal: () => Modal,
+  ModalContainer: () => ModalContainer
+});
+function CloseButton({
+  close,
+  theme
+}) {
+  if (typeof close !== "function") return null;
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      type: "button",
+      "aria-label": "Close modal",
+      onClick: close,
+      className: theme.slots.closeButton,
+      children: /* @__PURE__ */ jsx(Icon, { icon: "solar:close-bold", size: 16 })
+    }
+  );
+}
+function SlotRow({
+  center,
+  left,
+  right,
+  sticky,
+  theme,
+  variants
+}) {
+  const hasCenter = hasSlotContent(center);
+  return /* @__PURE__ */ jsxs(
+    motion.div,
+    {
+      variants,
+      initial: "hidden",
+      animate: "visible",
+      "data-columns": hasCenter ? 3 : 2,
+      "data-sticky": sticky,
+      className: theme.slots.row,
+      style: sticky ? theme.styles.row : void 0,
+      children: [
+        /* @__PURE__ */ jsx("div", { className: theme.slots.rowStart, children: left }),
+        hasCenter && /* @__PURE__ */ jsx("div", { className: theme.slots.rowCenter, children: center }),
+        /* @__PURE__ */ jsx("div", { className: theme.slots.rowEnd, children: right })
+      ]
+    }
+  );
+}
+function resolveHeader(header, close, theme) {
+  const config = isHeaderConfig(header) ? header : {};
+  const customNode = typeof header !== "boolean" && !isHeaderConfig(header) && hasSlotContent(header) ? header : null;
+  const actions = resolveHeaderActions(config.actions, close);
+  const showClose = config.showClose === true;
+  const left = customNode !== null ? null : config.left ?? (config.title ? /* @__PURE__ */ jsx("h2", { id: config.titleId, className: theme.slots.title, children: config.title }) : null);
+  const right = customNode !== null ? null : config.right ?? (hasSlotContent(actions) || showClose ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    actions,
+    showClose && /* @__PURE__ */ jsx(CloseButton, { close, theme })
+  ] }) : null);
+  return { center: customNode ?? config.center ?? null, config, left, right };
+}
+function ModalContainer({
+  bodyClassName,
+  children,
+  className,
+  close,
+  footer,
+  header = {},
+  position = null
+}) {
+  const { theme } = useModalContainerModel();
+  const headerRow = header === false ? null : resolveHeader(header, close, theme);
+  const shouldRenderHeader = headerRow && [headerRow.left, headerRow.center, headerRow.right].some(hasSlotContent);
+  const footerConfig = footer && typeof footer === "object" ? footer : {};
+  const {
+    center: footerCenter = null,
+    left: footerLeft = null,
+    right: footerRight = null
+  } = footerConfig;
+  const shouldRenderFooter = footer !== false && [footerLeft, footerCenter, footerRight].some(hasSlotContent);
+  const resolvedPosition = position || headerRow?.config.position || null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-height": isSidePosition(resolvedPosition) ? "full" : hasHeightConstraint(className) ? void 0 : "capped",
+      className: cn(theme.slots.content, className),
+      children: [
+        shouldRenderHeader && /* @__PURE__ */ jsx(
+          SlotRow,
+          {
+            variants: MODAL_HEADER_VARIANTS,
+            left: headerRow.left,
+            center: headerRow.center,
+            right: headerRow.right,
+            theme,
+            sticky: headerRow.config.sticky ? "top" : void 0
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          motion.div,
+          {
+            variants: MODAL_CONTENT_VARIANTS,
+            initial: "hidden",
+            animate: "visible",
+            "data-lenis-prevent": true,
+            "data-lenis-prevent-wheel": true,
+            className: cn(theme.slots.body, bodyClassName),
+            children
+          }
+        ),
+        shouldRenderFooter && /* @__PURE__ */ jsx(
+          SlotRow,
+          {
+            variants: MODAL_FOOTER_VARIANTS,
+            left: footerLeft,
+            center: footerCenter,
+            right: footerRight,
+            theme,
+            sticky: footerConfig.sticky ? "bottom" : void 0
+          }
+        )
+      ]
+    }
+  );
+}
+function ModalLayerSwitcher({
+  currentEntry,
+  onSwitchToPrevious,
+  previousEntry,
+  theme
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: theme.slots.switcher, children: [
+    /* @__PURE__ */ jsxs(
+      Button,
+      {
+        type: "button",
+        onClick: onSwitchToPrevious,
+        className: theme.slots.switcherButton,
+        children: [
+          /* @__PURE__ */ jsx("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", children: /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M7.5 2.5L4 6l3.5 3.5",
+              stroke: "currentColor",
+              strokeWidth: "1.5",
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            }
+          ) }),
+          getModalLabel(previousEntry.modalType)
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: theme.slots.switcherDivider, children: "/" }),
+    /* @__PURE__ */ jsx("span", { className: theme.slots.switcherCurrent, children: getModalLabel(currentEntry.modalType) })
+  ] });
+}
+function ModalLayer({
+  closeModal,
+  entry,
+  isMobileViewport,
+  isTopModal,
+  modalStack,
+  registry,
+  stackIndex,
+  theme
+}) {
+  const {
+    modalRef,
+    activePosition,
+    ActiveModalComponent,
+    isPanelChrome,
+    previousEntry,
+    baseZIndex
+  } = useModalLayerModel({
+    closeModal,
+    entry,
+    isMobileViewport,
+    isTopModal,
+    modalStack,
+    registry,
+    stackIndex
+  });
+  if (!ActiveModalComponent) return null;
+  const layout = getModalLayout(activePosition, isMobileViewport);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": isTopModal,
+      "aria-labelledby": entry.title ? `modal-title-${entry.id}` : void 0,
+      style: { zIndex: baseZIndex },
+      "data-position": getModalPosition(activePosition),
+      "data-inset": activePosition === MODAL_POSITIONS.CENTER && !isMobileViewport ? true : void 0,
+      className: theme.slots.layer,
+      children: /* @__PURE__ */ jsx(
+        motion.div,
+        {
+          ref: modalRef,
+          variants: getModalPositionVariants(activePosition),
+          initial: "hidden",
+          animate: "visible",
+          exit: "exit",
+          transition: getModalTransition(activePosition),
+          "data-active": isTopModal,
+          "data-layout": layout,
+          className: theme.slots.frame,
+          style: { zIndex: Z_INDEX.MODAL_FRAME, ...MODAL_COMPOSITOR_STYLE },
+          onClick: (e) => e.stopPropagation(),
+          children: /* @__PURE__ */ jsxs(
+            "div",
+            {
+              "data-layout": layout,
+              className: cn(
+                theme.slots.panel,
+                isPanelChrome ? theme.slots.panelChrome : theme.slots.panelBare
+              ),
+              children: [
+                /* @__PURE__ */ jsx(ModuleBoundary, { name: entry.modalType, children: createElement(ActiveModalComponent, {
+                  close: (result) => closeModal(result, entry.id),
+                  data: entry.props,
+                  header: {
+                    actions: entry.headerActions,
+                    position: activePosition,
+                    showClose: entry.showClose,
+                    title: entry.title,
+                    titleId: `modal-title-${entry.id}`
+                  }
+                }) }),
+                !isTopModal && /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    onClick: (e) => {
+                      e.stopPropagation();
+                      const topModal = modalStack[modalStack.length - 1];
+                      if (topModal) closeModal(null, topModal.id);
+                    },
+                    className: theme.slots.dim,
+                    style: theme.styles.dim,
+                    "aria-label": "Close active top modal"
+                  }
+                ),
+                isTopModal && stackIndex > 0 && previousEntry && /* @__PURE__ */ jsx(
+                  ModalLayerSwitcher,
+                  {
+                    currentEntry: entry,
+                    previousEntry,
+                    theme,
+                    onSwitchToPrevious: () => closeModal(null, entry.id)
+                  }
+                )
+              ]
+            }
+          )
+        }
+      )
+    }
+  );
+}
+function Modal() {
+  const {
+    closeModal,
+    registry,
+    visibleModalStack,
+    topModalEntry,
+    isModalVisible,
+    mounted,
+    isMobileViewport,
+    isTopExitSettling,
+    setIsTopExitSettling,
+    theme
+  } = useModalModel();
+  if (!mounted) return null;
+  return createPortal(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(AnimatePresence, { children: isModalVisible && /* @__PURE__ */ jsx(
+        motion.div,
+        {
+          variants: modalBackdropVariants,
+          initial: "hidden",
+          animate: "visible",
+          exit: "exit",
+          className: theme.slots.backdrop,
+          style: theme.styles.backdrop,
+          onClick: () => {
+            if (!isTopExitSettling) closeModal(null, topModalEntry.id);
+          }
+        },
+        "global-modal-backdrop"
+      ) }),
+      /* @__PURE__ */ jsx(AnimatePresence, { onExitComplete: () => setIsTopExitSettling(false), children: visibleModalStack.map((entry, index) => /* @__PURE__ */ jsx(
+        ModalLayer,
+        {
+          entry,
+          stackIndex: index,
+          isTopModal: index === visibleModalStack.length - 1 && !isTopExitSettling,
+          isMobileViewport,
+          closeModal,
+          registry,
+          modalStack: visibleModalStack,
+          theme
+        },
+        entry.id
+      )) })
+    ] }),
+    document.body
+  );
+}
+var init_overlay = __esm({
+  "src/modules/modal/overlay.tsx"() {
+    "use client";
+    init_atoms();
+    init_tokens2();
+    init_utils();
+    init_kernel();
+    init_constants2();
+    init_motion2();
+    init_utils3();
+    init_hooks3();
+  }
+});
+
+// src/modules/modal/index.ts
+init_overlay();
+init_overlay();
+init_context();
+
+// src/modules/modal/module.tsx
+init_kernel();
+init_context();
+init_utils3();
+var LazyModal = dynamic(
+  () => Promise.resolve().then(() => (init_overlay(), overlay_exports)).then((view) => view.Modal),
+  {
+    ssr: false
+  }
+);
+function selectPageModals(config) {
+  return config.modal ?? null;
+}
+function useModalPage(slice, page) {
+  const actions = useModalActions();
+  const sliceRef = useRef(slice);
+  useInsertionEffect(() => {
+    sliceRef.current = slice;
+  }, [slice]);
+  return useMemo(
+    () => ({
+      ...actions,
+      open: (modal, data = {}) => {
+        const own = typeof modal === "string" && modal !== "registry" ? sliceRef.current?.[modal] : void 0;
+        return actions.openModal(own ?? modal, { data });
+      },
+      set: (modal) => page.set({ modal })
+    }),
+    [actions, page]
+  );
+}
+var modalModule = defineModule({
+  id: "modal",
+  context: ModalContext,
+  Provider: ModalProvider,
+  Overlay: LazyModal,
+  registry: {
+    cleanupDelayMs: 600,
+    keyPolicy: "named",
+    lifecycle: "immediate",
+    valueKind: "component"
+  },
+  page: {
+    select: selectPageModals,
+    entries: (slice) => Object.entries(slice).map(([key, value]) => ({ key, value })),
+    use: useModalPage
+  }
+});
+function defineModal(definition = {}) {
+  const { type } = getModalIdentity(definition);
+  const modalDefinition = Object.freeze({
+    ...definition,
+    id: definition.id || type,
+    isModalDefinition: true,
+    type,
+    use: function useDefinedModal() {
+      return useModal(modalDefinition);
+    }
+  });
+  return modalDefinition;
+}
+
+// src/modules/modal/index.ts
+init_constants2();
+
+export { MODAL_CHROME, MODAL_POSITIONS, Modal, ModalContainer, ModalContext, ModalProvider, defineModal, modalModule, modalTheme, useModal, useModalActions, useModalRegistration, useModalState };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map