@almadar/ui 5.78.0 → 5.79.1

package/dist/context/index.cjs

@@ -1,957 +0,0 @@
-'use strict';
-
-var react = require('react');
-var logger = require('@almadar/logger');
-var jsxRuntime = require('react/jsx-runtime');
-var providers = require('@almadar/ui/providers');
-var context = require('@almadar/ui/context');
-
-var log = logger.createLogger("almadar:ui:ui-slots");
-var DEFAULT_SOURCE_KEY = "__default__";
-var MULTI_SOURCE_STACK_TRAIT = "__multi_source_stack__";
-var ALL_SLOTS = [
-  "main",
-  "sidebar",
-  "modal",
-  "drawer",
-  "overlay",
-  "center",
-  "toast",
-  "hud-top",
-  "hud-bottom",
-  "floating"
-];
-var DEFAULT_SLOTS = ALL_SLOTS.reduce(
-  (acc, slot) => {
-    acc[slot] = null;
-    return acc;
-  },
-  {}
-);
-var DEFAULT_SOURCES = ALL_SLOTS.reduce(
-  (acc, slot) => {
-    acc[slot] = {};
-    return acc;
-  },
-  {}
-);
-function aggregateSlot(sources) {
-  if (!sources) return null;
-  const entries = Object.entries(sources);
-  if (entries.length === 0) return null;
-  if (entries.length === 1) return entries[0][1];
-  const children = entries.map(([, entry]) => ({
-    type: entry.pattern,
-    ...entry.props
-  }));
-  const stackId = `slot-content-stack-${entries.map(([k]) => k).join("-")}`;
-  return {
-    id: stackId,
-    pattern: "stack",
-    props: {
-      direction: "vertical",
-      gap: "lg",
-      children
-    },
-    priority: 0,
-    animation: "fade",
-    sourceTrait: MULTI_SOURCE_STACK_TRAIT
-  };
-}
-function useUISlotManager() {
-  const [sources, setSources] = react.useState(DEFAULT_SOURCES);
-  const subscribersRef = react.useRef(/* @__PURE__ */ new Set());
-  const timersRef = react.useRef(/* @__PURE__ */ new Map());
-  const traitIndexRef = react.useRef(/* @__PURE__ */ new Map());
-  const traitSubscribersRef = react.useRef(/* @__PURE__ */ new Map());
-  const slots = react.useMemo(() => {
-    const out = { ...DEFAULT_SLOTS };
-    for (const slot of ALL_SLOTS) {
-      out[slot] = aggregateSlot(sources[slot]);
-    }
-    return out;
-  }, [sources]);
-  react.useEffect(() => {
-    return () => {
-      timersRef.current.forEach((timer) => clearTimeout(timer));
-      timersRef.current.clear();
-    };
-  }, []);
-  const notifySubscribers = react.useCallback((slot, content) => {
-    subscribersRef.current.forEach((callback) => {
-      try {
-        callback(slot, content);
-      } catch (error) {
-        log.error("Subscriber error", { error: error instanceof Error ? error : String(error) });
-      }
-    });
-  }, []);
-  const notifyTraitSubscribers = react.useCallback(
-    (traitName, content) => {
-      const subs = traitSubscribersRef.current.get(traitName);
-      if (!subs) return;
-      subs.forEach((callback) => {
-        try {
-          callback(content);
-        } catch (error) {
-          log.error("Trait subscriber error", { traitName, error: error instanceof Error ? error : String(error) });
-        }
-      });
-    },
-    []
-  );
-  const indexTraitRender = react.useCallback(
-    (traitName, content) => {
-      traitIndexRef.current.set(traitName, content);
-    },
-    []
-  );
-  const unindexTrait = react.useCallback((traitName) => {
-    traitIndexRef.current.delete(traitName);
-  }, []);
-  const render = react.useCallback(
-    (config) => {
-      const sourceKey = config.sourceTrait ?? DEFAULT_SOURCE_KEY;
-      const id = `slot-content-${config.target}-${sourceKey}`;
-      const content = {
-        id,
-        pattern: config.pattern,
-        props: config.props ?? {},
-        priority: config.priority ?? 0,
-        animation: config.animation ?? "fade",
-        onDismiss: config.onDismiss,
-        sourceTrait: config.sourceTrait,
-        slot: config.target,
-        transitionEvent: config.transitionEvent,
-        fromState: config.fromState,
-        entity: config.entity
-      };
-      if (config.autoDismissMs && config.autoDismissMs > 0) {
-        content.autoDismissAt = Date.now() + config.autoDismissMs;
-        const prevTimer = timersRef.current.get(id);
-        if (prevTimer) clearTimeout(prevTimer);
-        const timer = setTimeout(() => {
-          setSources((prev) => {
-            const slotSources = prev[config.target];
-            if (slotSources && slotSources[sourceKey] === content) {
-              content.onDismiss?.();
-              const next = { ...slotSources };
-              delete next[sourceKey];
-              const updated = { ...prev, [config.target]: next };
-              notifySubscribers(config.target, aggregateSlot(next));
-              return updated;
-            }
-            return prev;
-          });
-          timersRef.current.delete(id);
-        }, config.autoDismissMs);
-        timersRef.current.set(id, timer);
-      }
-      setSources((prev) => {
-        const slotSources = prev[config.target] ?? {};
-        const existing = slotSources[sourceKey];
-        if (existing && existing.priority > content.priority) {
-          log.warn("Slot already has higher priority content", {
-            slot: config.target,
-            sourceKey,
-            existingPriority: existing.priority,
-            newPriority: content.priority
-          });
-          return prev;
-        }
-        const nextSources = {
-          ...slotSources,
-          [sourceKey]: content
-        };
-        const nextAll = { ...prev, [config.target]: nextSources };
-        if (content.sourceTrait) {
-          indexTraitRender(content.sourceTrait, content);
-          notifyTraitSubscribers(content.sourceTrait, content);
-        }
-        log.info("slot:written", {
-          slot: config.target,
-          sourceKey,
-          sourceTrait: content.sourceTrait,
-          patternType: content.pattern,
-          priority: content.priority
-        });
-        notifySubscribers(config.target, aggregateSlot(nextSources));
-        return nextAll;
-      });
-      return id;
-    },
-    [notifySubscribers, notifyTraitSubscribers, indexTraitRender]
-  );
-  const clear = react.useCallback(
-    (slot) => {
-      setSources((prev) => {
-        const slotSources = prev[slot];
-        if (!slotSources || Object.keys(slotSources).length === 0) {
-          return prev;
-        }
-        for (const content of Object.values(slotSources)) {
-          const timer = timersRef.current.get(content.id);
-          if (timer) {
-            clearTimeout(timer);
-            timersRef.current.delete(content.id);
-          }
-          content.onDismiss?.();
-          if (content.sourceTrait) {
-            unindexTrait(content.sourceTrait);
-            notifyTraitSubscribers(content.sourceTrait, null);
-          }
-        }
-        notifySubscribers(slot, null);
-        return { ...prev, [slot]: {} };
-      });
-    },
-    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
-  );
-  const clearBySource = react.useCallback(
-    (slot, sourceTrait) => {
-      const sourceKey = sourceTrait;
-      setSources((prev) => {
-        const slotSources = prev[slot];
-        if (!slotSources || !(sourceKey in slotSources)) {
-          log.debug("slot:clear-noop", { slot, sourceTrait, reason: !slotSources ? "no-slot" : "no-source" });
-          return prev;
-        }
-        const content = slotSources[sourceKey];
-        const timer = timersRef.current.get(content.id);
-        if (timer) {
-          clearTimeout(timer);
-          timersRef.current.delete(content.id);
-        }
-        content.onDismiss?.();
-        if (content.sourceTrait) {
-          unindexTrait(content.sourceTrait);
-          notifyTraitSubscribers(content.sourceTrait, null);
-        }
-        const nextSources = { ...slotSources };
-        delete nextSources[sourceKey];
-        log.info("slot:cleared", { slot, sourceTrait, lastPatternType: content.pattern });
-        notifySubscribers(slot, aggregateSlot(nextSources));
-        return { ...prev, [slot]: nextSources };
-      });
-    },
-    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
-  );
-  const clearById = react.useCallback(
-    (id) => {
-      setSources((prev) => {
-        for (const slot of ALL_SLOTS) {
-          const slotSources = prev[slot];
-          if (!slotSources) continue;
-          const matchKey = Object.keys(slotSources).find(
-            (k) => slotSources[k].id === id
-          );
-          if (!matchKey) continue;
-          const content = slotSources[matchKey];
-          const timer = timersRef.current.get(id);
-          if (timer) {
-            clearTimeout(timer);
-            timersRef.current.delete(id);
-          }
-          content.onDismiss?.();
-          if (content.sourceTrait) {
-            unindexTrait(content.sourceTrait);
-            notifyTraitSubscribers(content.sourceTrait, null);
-          }
-          const nextSources = { ...slotSources };
-          delete nextSources[matchKey];
-          notifySubscribers(slot, aggregateSlot(nextSources));
-          return { ...prev, [slot]: nextSources };
-        }
-        return prev;
-      });
-    },
-    [notifySubscribers, notifyTraitSubscribers, unindexTrait]
-  );
-  const clearAll = react.useCallback(() => {
-    timersRef.current.forEach((timer) => clearTimeout(timer));
-    timersRef.current.clear();
-    setSources((prev) => {
-      for (const slot of ALL_SLOTS) {
-        const slotSources = prev[slot];
-        if (!slotSources) continue;
-        for (const content of Object.values(slotSources)) {
-          content.onDismiss?.();
-          if (content.sourceTrait) {
-            notifyTraitSubscribers(content.sourceTrait, null);
-          }
-        }
-        notifySubscribers(slot, null);
-      }
-      return DEFAULT_SOURCES;
-    });
-    traitIndexRef.current.clear();
-  }, [notifySubscribers, notifyTraitSubscribers]);
-  const subscribe = react.useCallback((callback) => {
-    subscribersRef.current.add(callback);
-    return () => {
-      subscribersRef.current.delete(callback);
-    };
-  }, []);
-  const hasContent = react.useCallback(
-    (slot) => slots[slot] !== null,
-    [slots]
-  );
-  const getContent = react.useCallback(
-    (slot) => slots[slot] ?? null,
-    [slots]
-  );
-  const getTraitContent = react.useCallback(
-    (traitName) => traitIndexRef.current.get(traitName) ?? null,
-    []
-  );
-  const subscribeTrait = react.useCallback(
-    (traitName, callback) => {
-      let set = traitSubscribersRef.current.get(traitName);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        traitSubscribersRef.current.set(traitName, set);
-      }
-      set.add(callback);
-      return () => {
-        const s = traitSubscribersRef.current.get(traitName);
-        if (!s) return;
-        s.delete(callback);
-        if (s.size === 0) {
-          traitSubscribersRef.current.delete(traitName);
-        }
-      };
-    },
-    []
-  );
-  const updateTraitContent = react.useCallback(
-    (traitName, content) => {
-      const id = `slot-content-trait-${traitName}`;
-      const fullContent = { ...content, id, sourceTrait: traitName };
-      indexTraitRender(traitName, fullContent);
-      notifyTraitSubscribers(traitName, fullContent);
-      return id;
-    },
-    [indexTraitRender, notifyTraitSubscribers]
-  );
-  return {
-    slots,
-    render,
-    clear,
-    clearBySource,
-    clearById,
-    clearAll,
-    subscribe,
-    hasContent,
-    getContent,
-    getTraitContent,
-    subscribeTrait,
-    updateTraitContent
-  };
-}
-var UISlotContext = react.createContext(null);
-function UISlotProvider({ children }) {
-  const slotManager = useUISlotManager();
-  const contextValue = react.useMemo(() => slotManager, [slotManager]);
-  return /* @__PURE__ */ jsxRuntime.jsx(UISlotContext.Provider, { value: contextValue, children });
-}
-function useUISlots() {
-  const context = react.useContext(UISlotContext);
-  if (!context) {
-    throw new Error(
-      "useUISlots must be used within a UISlotProvider. Make sure your component tree is wrapped with <UISlotProvider>."
-    );
-  }
-  return context;
-}
-function useSlotContent(slot) {
-  const { getContent } = useUISlots();
-  return getContent(slot);
-}
-function useSlotHasContent(slot) {
-  const { hasContent } = useUISlots();
-  return hasContent(slot);
-}
-var log2 = logger.createLogger("almadar:ui:theme");
-var BUILT_IN_THEMES = [
-  {
-    name: "wireframe",
-    displayName: "Wireframe",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "minimalist",
-    displayName: "Minimalist",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "almadar",
-    displayName: "Almadar",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "trait-wars",
-    displayName: "Trait Wars",
-    hasLightMode: false,
-    hasDarkMode: true
-  },
-  // Extended themes
-  {
-    name: "ocean",
-    displayName: "Ocean",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "forest",
-    displayName: "Forest",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "sunset",
-    displayName: "Sunset",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "lavender",
-    displayName: "Lavender",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "rose",
-    displayName: "Rose",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "slate",
-    displayName: "Slate",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "ember",
-    displayName: "Ember",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "midnight",
-    displayName: "Midnight",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "sand",
-    displayName: "Sand",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "neon",
-    displayName: "Neon",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "arctic",
-    displayName: "Arctic",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "copper",
-    displayName: "Copper",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  // Layer 1 skin axes — truly-unique themes (compact tech / editorial / brutalist dense / display-heavy / touch-first)
-  {
-    name: "prism",
-    displayName: "Prism",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "gazette",
-    displayName: "Gazette",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "terminal",
-    displayName: "Terminal",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "atelier",
-    displayName: "Atelier",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "kiosk",
-    displayName: "Kiosk",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "linear-clean",
-    displayName: "Linear Clean",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "notion-editorial",
-    displayName: "Notion Editorial",
-    hasLightMode: true,
-    hasDarkMode: true
-  },
-  {
-    name: "bloomberg-dense",
-    displayName: "Bloomberg Dense",
-    hasLightMode: true,
-    hasDarkMode: true
-  }
-];
-var ThemeContext = react.createContext(void 0);
-var THEME_STORAGE_KEY = "theme";
-var MODE_STORAGE_KEY = "theme-mode";
-function getSystemMode() {
-  if (typeof window === "undefined") return "light";
-  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-}
-function resolveMode(mode) {
-  if (mode === "system") {
-    return getSystemMode();
-  }
-  return mode;
-}
-var ThemeProvider = ({
-  children,
-  themes = [],
-  defaultTheme = "wireframe",
-  defaultMode = "system",
-  targetRef
-}) => {
-  const availableThemes = react.useMemo(() => {
-    const themeMap = /* @__PURE__ */ new Map();
-    BUILT_IN_THEMES.forEach((t) => themeMap.set(t.name, t));
-    themes.forEach((t) => themeMap.set(t.name, t));
-    return Array.from(themeMap.values());
-  }, [themes]);
-  const isScoped = !!targetRef;
-  const [theme, setThemeState] = react.useState(() => {
-    if (isScoped || typeof window === "undefined") return defaultTheme;
-    const stored = localStorage.getItem(THEME_STORAGE_KEY);
-    const validThemes = [
-      ...BUILT_IN_THEMES.map((t) => t.name),
-      ...themes.map((t) => t.name)
-    ];
-    if (stored && validThemes.includes(stored)) {
-      return stored;
-    }
-    return defaultTheme;
-  });
-  const [mode, setModeState] = react.useState(() => {
-    if (isScoped || typeof window === "undefined") return defaultMode;
-    const stored = localStorage.getItem(MODE_STORAGE_KEY);
-    if (stored === "light" || stored === "dark" || stored === "system") {
-      return stored;
-    }
-    return defaultMode;
-  });
-  const [resolvedMode, setResolvedMode] = react.useState(
-    () => resolveMode(mode)
-  );
-  const appliedTheme = react.useMemo(
-    () => `${theme}-${resolvedMode}`,
-    [theme, resolvedMode]
-  );
-  react.useEffect(() => {
-    const updateResolved = () => {
-      setResolvedMode(resolveMode(mode));
-    };
-    updateResolved();
-    if (mode === "system") {
-      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
-      const handleChange = () => updateResolved();
-      mediaQuery.addEventListener("change", handleChange);
-      return () => mediaQuery.removeEventListener("change", handleChange);
-    }
-    return void 0;
-  }, [mode]);
-  react.useEffect(() => {
-    if (isScoped) {
-      if (targetRef?.current) {
-        targetRef.current.setAttribute("data-theme", appliedTheme);
-        targetRef.current.classList.remove("light", "dark");
-        targetRef.current.classList.add(resolvedMode);
-      }
-      return;
-    }
-    const root = document.documentElement;
-    root.setAttribute("data-theme", appliedTheme);
-    root.classList.remove("light", "dark");
-    root.classList.add(resolvedMode);
-  }, [appliedTheme, resolvedMode, targetRef, isScoped]);
-  const setTheme = react.useCallback(
-    (newTheme) => {
-      const validTheme = availableThemes.find((t) => t.name === newTheme);
-      if (validTheme) {
-        setThemeState(newTheme);
-        if (!isScoped && typeof window !== "undefined") {
-          localStorage.setItem(THEME_STORAGE_KEY, newTheme);
-        }
-      } else {
-        log2.warn("Theme not found", {
-          theme: newTheme,
-          available: availableThemes.map((t) => t.name)
-        });
-      }
-    },
-    [availableThemes]
-  );
-  const setMode = react.useCallback((newMode) => {
-    setModeState(newMode);
-    if (!isScoped && typeof window !== "undefined") {
-      localStorage.setItem(MODE_STORAGE_KEY, newMode);
-    }
-  }, []);
-  const toggleMode = react.useCallback(() => {
-    const newMode = resolvedMode === "dark" ? "light" : "dark";
-    setMode(newMode);
-  }, [resolvedMode, setMode]);
-  const contextValue = react.useMemo(
-    () => ({
-      theme,
-      mode,
-      resolvedMode,
-      setTheme,
-      setMode,
-      toggleMode,
-      availableThemes,
-      appliedTheme
-    }),
-    [
-      theme,
-      mode,
-      resolvedMode,
-      setTheme,
-      setMode,
-      toggleMode,
-      availableThemes,
-      appliedTheme
-    ]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(ThemeContext.Provider, { value: contextValue, children });
-};
-function useTheme() {
-  const context = react.useContext(ThemeContext);
-  if (context === void 0) {
-    return {
-      theme: "wireframe",
-      mode: "light",
-      resolvedMode: "light",
-      setTheme: () => {
-      },
-      setMode: () => {
-      },
-      toggleMode: () => {
-      },
-      availableThemes: BUILT_IN_THEMES,
-      appliedTheme: "wireframe-light"
-    };
-  }
-  return context;
-}
-var ThemeContext_default = ThemeContext;
-
-// lib/themeTokens.ts
-function themeTokensToCssVars(tokens, mode = "light", darkVariant) {
-  const vars = {};
-  const isDark = mode === "dark";
-  const pickColors = isDark && darkVariant?.colors ? darkVariant.colors : tokens.colors;
-  if (pickColors) {
-    for (const [key, value] of Object.entries(pickColors)) {
-      vars[`--color-${key}`] = value;
-    }
-    if (isDark && darkVariant?.colors && tokens.colors) {
-      for (const [key, value] of Object.entries(tokens.colors)) {
-        const varName = `--color-${key}`;
-        if (!(varName in vars)) vars[varName] = value;
-      }
-    }
-  }
-  const pickRadii = isDark && darkVariant?.radii ? darkVariant.radii : tokens.radii;
-  if (pickRadii) {
-    for (const [key, value] of Object.entries(pickRadii)) {
-      vars[`--radius-${key}`] = value;
-    }
-  }
-  const pickSpacing = isDark && darkVariant?.spacing ? darkVariant.spacing : tokens.spacing;
-  if (pickSpacing) {
-    for (const [key, value] of Object.entries(pickSpacing)) {
-      vars[`--space-${key}`] = value;
-    }
-  }
-  const pickTypography = isDark && darkVariant?.typography ? darkVariant.typography : tokens.typography;
-  if (pickTypography) {
-    for (const [key, value] of Object.entries(pickTypography)) {
-      vars[`--${key}`] = value;
-    }
-  }
-  const pickShadows = isDark && darkVariant?.shadows ? darkVariant.shadows : tokens.shadows;
-  if (pickShadows) {
-    for (const [key, value] of Object.entries(pickShadows)) {
-      vars[`--shadow-${key}`] = value;
-    }
-  }
-  const pickDensity = isDark && darkVariant?.density ? darkVariant.density : tokens.density;
-  emitDensity(pickDensity, vars);
-  const pickTypeScale = isDark && darkVariant?.typeScale ? darkVariant.typeScale : tokens.typeScale;
-  emitTypeScale(pickTypeScale, vars);
-  const pickMotion = isDark && darkVariant?.motion ? darkVariant.motion : tokens.motion;
-  emitMotion(pickMotion, vars);
-  const pickIconography = isDark && darkVariant?.iconography ? darkVariant.iconography : tokens.iconography;
-  emitIconography(pickIconography, vars);
-  const pickElevation = isDark && darkVariant?.elevation ? darkVariant.elevation : tokens.elevation;
-  emitElevation(pickElevation, vars);
-  const pickGeometry = isDark && darkVariant?.geometry ? darkVariant.geometry : tokens.geometry;
-  emitGeometry(pickGeometry, vars);
-  return vars;
-}
-function emitDensity(density, vars) {
-  if (!density) return;
-  if (density.spacing) {
-    const s = density.spacing;
-    const pairs2 = [
-      ["0", s.space0],
-      ["1", s.space1],
-      ["2", s.space2],
-      ["3", s.space3],
-      ["4", s.space4],
-      ["5", s.space5],
-      ["6", s.space6],
-      ["7", s.space7],
-      ["8", s.space8],
-      ["9", s.space9],
-      ["10", s.space10],
-      ["11", s.space11],
-      ["12", s.space12]
-    ];
-    for (const [k, v] of pairs2) {
-      if (v !== void 0) vars[`--space-${k}`] = v;
-    }
-  }
-  const pairs = [
-    ["button-height-sm", density.buttonHeightSm],
-    ["button-height-md", density.buttonHeightMd],
-    ["button-height-lg", density.buttonHeightLg],
-    ["input-height-sm", density.inputHeightSm],
-    ["input-height-md", density.inputHeightMd],
-    ["input-height-lg", density.inputHeightLg],
-    ["row-height-compact", density.rowHeightCompact],
-    ["row-height-normal", density.rowHeightNormal],
-    ["row-height-spacious", density.rowHeightSpacious],
-    ["card-padding-sm", density.cardPaddingSm],
-    ["card-padding-md", density.cardPaddingMd],
-    ["card-padding-lg", density.cardPaddingLg],
-    ["dialog-padding", density.dialogPadding],
-    ["section-gap", density.sectionGap]
-  ];
-  for (const [k, v] of pairs) {
-    if (v !== void 0) vars[`--${k}`] = v;
-  }
-}
-function typeSizeKeyStr(k) {
-  return k;
-}
-function typeWeightStr(w) {
-  return w;
-}
-function emitTypeIntent(name, intent, vars) {
-  const sizeKey = typeSizeKeyStr(intent.size);
-  const weight = typeWeightStr(intent.weight);
-  vars[`--intent-${name}-size`] = `var(--text-${sizeKey})`;
-  vars[`--intent-${name}-weight`] = `var(--font-weight-${weight})`;
-  vars[`--intent-${name}-leading`] = `var(--leading-${sizeKey})`;
-}
-function emitTypeScale(ts, vars) {
-  if (!ts) return;
-  if (ts.displayFamily !== void 0) vars["--font-family-display"] = ts.displayFamily;
-  if (ts.bodyFamily !== void 0) vars["--font-family-body"] = ts.bodyFamily;
-  if (ts.monoFamily !== void 0) vars["--font-family-mono"] = ts.monoFamily;
-  if (ts.scale) {
-    const s = ts.scale;
-    const pairs = [
-      ["xs", s.xs],
-      ["sm", s.sm],
-      ["base", s.base],
-      ["lg", s.lg],
-      ["xl", s.xl],
-      ["2xl", s["2xl"]],
-      ["3xl", s["3xl"]],
-      ["4xl", s["4xl"]],
-      ["display-1", s["display-1"]],
-      ["display-2", s["display-2"]]
-    ];
-    for (const [k, entry] of pairs) {
-      if (entry !== void 0) {
-        vars[`--text-${k}`] = entry.size;
-        vars[`--leading-${k}`] = entry.lineHeight;
-      }
-    }
-  }
-  if (ts.intents) {
-    const i = ts.intents;
-    if (i.headingMajor) emitTypeIntent("heading-major", i.headingMajor, vars);
-    if (i.headingMinor) emitTypeIntent("heading-minor", i.headingMinor, vars);
-    if (i.bodyEmphasis) emitTypeIntent("body-emphasis", i.bodyEmphasis, vars);
-    if (i.bodyDefault) emitTypeIntent("body-default", i.bodyDefault, vars);
-    if (i.bodyQuiet) emitTypeIntent("body-quiet", i.bodyQuiet, vars);
-    if (i.caption) emitTypeIntent("caption", i.caption, vars);
-    if (i.numeric) emitTypeIntent("numeric", i.numeric, vars);
-  }
-}
-function emitMotionIntent(name, intent, vars) {
-  vars[`--intent-${name}-duration`] = `var(--duration-${intent.duration})`;
-  vars[`--intent-${name}-easing`] = `var(--easing-${intent.easing})`;
-}
-function emitMotion(m, vars) {
-  if (!m) return;
-  if (m.durations) {
-    const d = m.durations;
-    const pairs = [
-      ["instant", d.instant],
-      ["fast", d.fast],
-      ["normal", d.normal],
-      ["slow", d.slow],
-      ["dramatic", d.dramatic]
-    ];
-    for (const [k, v] of pairs) {
-      if (v !== void 0) vars[`--duration-${k}`] = v;
-    }
-  }
-  if (m.easings) {
-    const e = m.easings;
-    const pairs = [
-      ["linear", e.linear],
-      ["standard", e.standard],
-      ["emphasized", e.emphasized],
-      ["spring", e.spring]
-    ];
-    for (const [k, v] of pairs) {
-      if (v !== void 0) vars[`--easing-${k}`] = v;
-    }
-  }
-  if (m.intents) {
-    const i = m.intents;
-    if (i.enter) emitMotionIntent("enter", i.enter, vars);
-    if (i.exit) emitMotionIntent("exit", i.exit, vars);
-    if (i.hover) emitMotionIntent("hover", i.hover, vars);
-    if (i.press) emitMotionIntent("press", i.press, vars);
-    if (i.expand) emitMotionIntent("expand", i.expand, vars);
-    if (i.transition) emitMotionIntent("transition", i.transition, vars);
-  }
-}
-function emitIconography(i, vars) {
-  if (!i) return;
-  if (i.family !== void 0) vars["--icon-family"] = i.family;
-  if (i.strokeWidth !== void 0) vars["--icon-stroke-width"] = i.strokeWidth;
-  if (i.defaultSize !== void 0) vars["--icon-default-size"] = i.defaultSize;
-}
-function emitElevation(e, vars) {
-  if (!e) return;
-  if (e.cardElevation !== void 0) vars["--elevation-card"] = e.cardElevation;
-  if (e.popoverElevation !== void 0) vars["--elevation-popover"] = e.popoverElevation;
-  if (e.dialogElevation !== void 0) vars["--elevation-dialog"] = e.dialogElevation;
-  if (e.toastElevation !== void 0) vars["--elevation-toast"] = e.toastElevation;
-}
-function emitGeometry(g, vars) {
-  if (!g) return;
-  if (g.radiusContainer !== void 0) vars["--radius-container"] = g.radiusContainer;
-  if (g.radiusInteractive !== void 0) vars["--radius-interactive"] = g.radiusInteractive;
-  if (g.radiusPill !== void 0) vars["--radius-pill"] = g.radiusPill;
-  if (g.borderHairline !== void 0) vars["--border-hairline"] = g.borderHairline;
-  if (g.borderStandard !== void 0) vars["--border-standard"] = g.borderStandard;
-  if (g.borderHeavy !== void 0) vars["--border-heavy"] = g.borderHeavy;
-}
-function resolveThemeForRuntime(theme) {
-  if (theme === void 0) return void 0;
-  if (typeof theme === "string") return void 0;
-  return theme;
-}
-var DesignThemeProvider = context.ThemeProvider;
-function useDesignTheme() {
-  const { theme, setTheme, availableThemes } = context.useTheme();
-  return {
-    designTheme: theme,
-    setDesignTheme: setTheme,
-    availableThemes: availableThemes.map((t) => t.name)
-  };
-}
-
-Object.defineProperty(exports, "ANONYMOUS_USER", {
-  enumerable: true,
-  get: function () { return providers.ANONYMOUS_USER; }
-});
-Object.defineProperty(exports, "CurrentPagePathContext", {
-  enumerable: true,
-  get: function () { return providers.CurrentPagePathContext; }
-});
-Object.defineProperty(exports, "CurrentPagePathProvider", {
-  enumerable: true,
-  get: function () { return providers.CurrentPagePathProvider; }
-});
-Object.defineProperty(exports, "OrbitalThemeProvider", {
-  enumerable: true,
-  get: function () { return providers.OrbitalThemeProvider; }
-});
-Object.defineProperty(exports, "UserContext", {
-  enumerable: true,
-  get: function () { return providers.UserContext; }
-});
-Object.defineProperty(exports, "UserProvider", {
-  enumerable: true,
-  get: function () { return providers.UserProvider; }
-});
-Object.defineProperty(exports, "useCurrentPagePath", {
-  enumerable: true,
-  get: function () { return providers.useCurrentPagePath; }
-});
-Object.defineProperty(exports, "useHasPermission", {
-  enumerable: true,
-  get: function () { return providers.useHasPermission; }
-});
-Object.defineProperty(exports, "useHasRole", {
-  enumerable: true,
-  get: function () { return providers.useHasRole; }
-});
-Object.defineProperty(exports, "useUser", {
-  enumerable: true,
-  get: function () { return providers.useUser; }
-});
-Object.defineProperty(exports, "useUserForEvaluation", {
-  enumerable: true,
-  get: function () { return providers.useUserForEvaluation; }
-});
-exports.BUILT_IN_THEMES = BUILT_IN_THEMES;
-exports.DesignThemeProvider = DesignThemeProvider;
-exports.ThemeContext = ThemeContext_default;
-exports.ThemeProvider = ThemeProvider;
-exports.UISlotContext = UISlotContext;
-exports.UISlotProvider = UISlotProvider;
-exports.resolveThemeForRuntime = resolveThemeForRuntime;
-exports.themeTokensToCssVars = themeTokensToCssVars;
-exports.useDesignTheme = useDesignTheme;
-exports.useSlotContent = useSlotContent;
-exports.useSlotHasContent = useSlotHasContent;
-exports.useTheme = useTheme;
-exports.useUISlots = useUISlots;