@almadar/ui 4.6.13 → 4.7.0

package/dist/avl/index.js

@@ -5328,13 +5328,23 @@ function SlotsProvider({ children }) {
   const setSlotPatterns = useCallback((slot, patterns, source) => {
     const sourceKey = source?.trait ?? DEFAULT_SOURCE_KEY2;
     const entityProp = patterns[0]?.pattern && typeof patterns[0].pattern === "object" ? patterns[0].pattern.entity : void 0;
+    const firstPatternType = patterns[0]?.pattern && typeof patterns[0].pattern === "object" ? patterns[0].pattern.type : void 0;
     slotLog.debug("setSlotPatterns", {
       slot,
       sourceKey,
       patternCount: patterns.length,
-      firstPatternType: patterns[0]?.pattern && typeof patterns[0].pattern === "object" ? patterns[0].pattern.type : void 0,
+      firstPatternType,
       entityRefId: refId(entityProp)
     });
+    if (source?.trait) {
+      xOrbitalLog.info("slot-set", {
+        slot,
+        sourceTrait: source.trait,
+        patternCount: patterns.length,
+        firstPatternType,
+        state: source.state
+      });
+    }
     setSlots((prev) => {
       const prevSlot = prev[slot] ?? {};
       return {
@@ -5356,6 +5366,7 @@ function SlotsProvider({ children }) {
     });
   }, []);
   const clearSlotForSource = useCallback((slot, sourceTrait) => {
+    xOrbitalLog.info("slot-clear-source", { slot, sourceTrait });
     setSlots((prev) => {
       const existing = prev[slot];
       if (!existing || !(sourceTrait in existing)) return prev;
@@ -5392,11 +5403,12 @@ function useSlotsActions() {
   }
   return actions;
 }
-var slotLog, refIds, nextRefId, DEFAULT_SOURCE_KEY2, SlotsStateContext, SlotsActionsContext;
+var slotLog, xOrbitalLog, refIds, nextRefId, DEFAULT_SOURCE_KEY2, SlotsStateContext, SlotsActionsContext;
 var init_SlotsContext = __esm({
   "runtime/ui/SlotsContext.tsx"() {
     init_logger();
     slotLog = createLogger("almadar:ui:slot-render");
+    xOrbitalLog = createLogger("almadar:runtime:cross-orbital");
     refIds = /* @__PURE__ */ new WeakMap();
     nextRefId = 1;
     DEFAULT_SOURCE_KEY2 = "__default__";
@@ -11132,7 +11144,7 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect87, useRef: useRef87, useCallback: useCallback125, useState: useState125 } = React127__default;
+      const { useEffect: useEffect87, useRef: useRef87, useCallback: useCallback125, useState: useState124 } = React127__default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus3 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
@@ -11176,7 +11188,7 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus3();
-        const [clickedPosition, setClickedPosition] = useState125(null);
+        const [clickedPosition, setClickedPosition] = useState124(null);
         const handleMapClick = useCallback125((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
@@ -12277,9 +12289,9 @@ function bindEventBus(eventBus) {
   log2.info("bindEventBus", { hasOnAny: !!eventBus.onAny });
   exposeOnWindow();
   if (window.__orbitalVerification) {
-    window.__orbitalVerification.sendEvent = (event, payload) => {
-      const prefixed = event.startsWith("UI:") ? event : `UI:${event}`;
-      log2.debug("sendEvent", { event: prefixed, payloadKeys: payload ? Object.keys(payload) : [] });
+    window.__orbitalVerification.sendEvent = (event, payload, traitScope) => {
+      const prefixed = event.startsWith("UI:") ? event : traitScope ? `UI:${traitScope}.${event}` : `UI:${event}`;
+      log2.debug("sendEvent", { event: prefixed, traitScope, payloadKeys: payload ? Object.keys(payload) : [] });
       eventBus.emit(prefixed, payload);
     };
     const eventLog = [];
@@ -51454,6 +51466,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
   const eventBus = useEventBus();
   const { entities } = useEntitySchema();
   const traitConfigsByName = options?.traitConfigsByName;
+  const orbitalsByTrait = options?.orbitalsByTrait;
   const manager = useMemo(() => {
     const traitDefs = traitBindings.map(toTraitDefinition);
     const m = new StateMachineManager(traitDefs);
@@ -51666,24 +51679,7 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
     const actions = slotsActionsRef.current;
     console.log("[TraitStateMachine] Processing event:", normalizedEvent, "payload:", payload);
     const bindingMap = new Map(bindings.map((b) => [b.trait.name, b]));
-    for (const traitName of bindingMap.keys()) {
-      const traitState = currentManager.getState(traitName);
-      eventBus.emit(`${traitName}:DISPATCH`, {
-        event: normalizedEvent,
-        payload,
-        currentState: traitState?.currentState
-      });
-    }
     const results = currentManager.sendEvent(normalizedEvent, payload);
-    for (const { traitName, result } of results) {
-      const suffix = result.executed ? "SUCCESS" : "ERROR";
-      eventBus.emit(`${traitName}:${normalizedEvent}:${suffix}`, {
-        event: normalizedEvent,
-        payload,
-        newState: result.newState,
-        currentState: result.previousState
-      });
-    }
     const emittedByTrait = /* @__PURE__ */ new Map();
     for (const { traitName, result } of results) {
       const binding = bindingMap.get(traitName);
@@ -51919,7 +51915,10 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
     if (!LIFECYCLE_EVENTS.has(normalizedEvent)) {
       for (const { traitName, result } of results) {
         if (!result.executed) continue;
-        eventBus.emit(normalizedEvent, payload, {
+        const orbitalName = orbitalsByTrait?.[traitName];
+        if (!orbitalName) continue;
+        eventBus.emit(`UI:${orbitalName}.${traitName}.${normalizedEvent}`, payload, {
+          orbital: orbitalName,
           trait: traitName,
           fromBridge: true
         });
@@ -51930,7 +51929,13 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
     }
     const onEventProcessed = optionsRef.current?.onEventProcessed;
     if (onEventProcessed) {
-      await onEventProcessed(normalizedEvent, payload);
+      const dispatchedOrbitals = /* @__PURE__ */ new Set();
+      for (const { traitName, result } of results) {
+        if (!result.executed) continue;
+        const orbital = orbitalsByTrait?.[traitName];
+        if (orbital) dispatchedOrbitals.add(orbital);
+      }
+      await onEventProcessed(normalizedEvent, payload, dispatchedOrbitals);
     }
   }, [entities, eventBus]);
   const drainEventQueue = useCallback(async () => {
@@ -51974,26 +51979,34 @@ function useTraitStateMachine(traitBindings, slotsActions, options) {
     }
     console.log("[TraitStateMachine] Subscribing to events:", Array.from(allEvents));
     const unsubscribes = [];
-    for (const eventKey of allEvents) {
-      if (eventKey === "INIT" || eventKey === "LOAD" || eventKey === "$MOUNT") {
-        continue;
+    for (const binding of traitBindings) {
+      const traitName = binding.trait.name;
+      const orbitalName = orbitalsByTrait?.[traitName];
+      if (!orbitalName) continue;
+      for (const transition of binding.trait.transitions) {
+        const eventKey = transition.event;
+        if (eventKey === "INIT" || eventKey === "LOAD" || eventKey === "$MOUNT") {
+          continue;
+        }
+        const unsub = eventBus.on(`UI:${orbitalName}.${traitName}.${eventKey}`, (event) => {
+          if (event.source && event.source.fromBridge) {
+            return;
+          }
+          enqueueAndDrain(eventKey, event.payload);
+        });
+        unsubscribes.push(unsub);
       }
-      const unsub = eventBus.on(`UI:${eventKey}`, (event) => {
-        console.log("[TraitStateMachine] Received event:", `UI:${eventKey}`, event);
-        enqueueAndDrain(eventKey, event.payload);
-      });
-      unsubscribes.push(unsub);
     }
     for (const binding of traitBindings) {
+      const ownOrbital = orbitalsByTrait?.[binding.trait.name];
       const listens = binding.trait.listens ?? [];
       for (const listen of listens) {
-        const expectedTrait = listen.source?.trait;
-        const unsub = eventBus.on(listen.event, (event) => {
-          if (expectedTrait) {
-            const emitTrait = event.source?.trait;
-            if (emitTrait !== expectedTrait) return;
-          }
-          console.log("[TraitStateMachine] listens", binding.trait.name, listen.event, "\u2192", listen.triggers, "from", event.source?.trait);
+        const sourceTrait = listen.source?.trait;
+        if (!sourceTrait) continue;
+        const sourceOrbital = listen.source?.orbital ?? ownOrbital;
+        if (!sourceOrbital) continue;
+        const busKey = `UI:${sourceOrbital}.${sourceTrait}.${listen.event}`;
+        const unsub = eventBus.on(busKey, (event) => {
           enqueueAndDrain(listen.triggers, event.payload);
         });
         unsubscribes.push(unsub);
@@ -52019,6 +52032,8 @@ init_EntitySchemaContext();
 
 // runtime/ServerBridge.tsx
 init_useEventBus();
+init_logger();
+var xOrbitalLog2 = createLogger("almadar:runtime:cross-orbital");
 var ServerBridgeContext = createContext(null);
 function useServerBridge() {
   const ctx = useContext(ServerBridgeContext);
@@ -52096,8 +52111,22 @@ function ServerBridgeProvider({
         }
         if (result.emittedEvents) {
           for (const emitted of result.emittedEvents) {
-            eventBus.emit(`UI:${emitted.event}`, emitted.payload);
-            eventBus.emit(emitted.event, emitted.payload);
+            const evTrait = emitted.source?.trait;
+            if (!evTrait) {
+              xOrbitalLog2.warn("emit:dropped-no-source", {
+                event: emitted.event,
+                dispatchOrbital: orbitalName
+              });
+              continue;
+            }
+            const key = emitted.source?.orbital ? `UI:${emitted.source.orbital}.${evTrait}.${emitted.event}` : `UI:${evTrait}.${emitted.event}`;
+            xOrbitalLog2.info("emit:rebroadcast", {
+              busKey: key,
+              sourceOrbital: emitted.source?.orbital,
+              sourceTrait: evTrait,
+              dispatchOrbital: orbitalName
+            });
+            eventBus.emit(key, emitted.payload);
           }
         }
       } else if (result.error) {
@@ -52218,6 +52247,10 @@ function prepareSchemaForPreview(input) {
   const schema = adjustSchemaForMockData(parsed, mockData);
   return { schema, mockData };
 }
+
+// runtime/OrbPreview.tsx
+init_logger();
+var xOrbitalLog3 = createLogger("almadar:runtime:cross-orbital");
 function normalizeChild(child) {
   if (typeof child === "string") return child;
   if (child === null || typeof child !== "object" || Array.isArray(child)) {
@@ -52297,6 +52330,11 @@ function applyServerEffects(effects, uiSlots, onNavigate) {
       const patternRecord = eff.pattern;
       const { type: patternType, children, ...inlineProps } = patternRecord;
       const normalizedChildren = Array.isArray(children) ? children.map((c) => normalizeChild(c)) : children;
+      xOrbitalLog3.info("slot-write", {
+        slot: eff.slot,
+        sourceTrait: eff.traitName ?? "server",
+        patternType: typeof patternType === "string" ? patternType : void 0
+      });
       uiSlots.render({
         target: eff.slot,
         pattern: patternType,
@@ -52311,19 +52349,26 @@ function applyServerEffects(effects, uiSlots, onNavigate) {
     }
   }
 }
-function TraitInitializer({ traits: traits2, orbitalNames, onNavigate, onLocalFallback, persistence, traitConfigsByName }) {
+function TraitInitializer({ traits: traits2, orbitalNames, onNavigate, onLocalFallback, persistence, traitConfigsByName, orbitalsByTrait }) {
   const slotsActions = useSlotsActions();
   const bridge = useServerBridge();
   const uiSlots = useUISlots();
-  const onEventProcessed = useCallback(async (event, payload) => {
+  const onEventProcessed = useCallback(async (event, payload, dispatchedOrbitals) => {
     if (!bridge.connected || !orbitalNames?.length) return;
-    for (const name of orbitalNames) {
+    const targets = dispatchedOrbitals && dispatchedOrbitals.size > 0 ? orbitalNames.filter((n) => dispatchedOrbitals.has(n)) : orbitalNames;
+    xOrbitalLog3.info("TraitInitializer:fanout", {
+      event,
+      sentTo: targets,
+      skipped: orbitalNames.filter((n) => !targets.includes(n)),
+      dispatchedOrbitalsSize: dispatchedOrbitals?.size ?? 0
+    });
+    for (const name of targets) {
       const { effects, meta } = await bridge.sendEvent(name, event, payload);
       recordServerResponse(name, event, meta);
       applyServerEffects(effects, uiSlots, onNavigate);
     }
   }, [bridge.connected, bridge.sendEvent, orbitalNames, uiSlots, onNavigate]);
-  const opts = orbitalNames ? { onEventProcessed, navigate: onNavigate, traitConfigsByName } : { navigate: onNavigate, persistence, traitConfigsByName };
+  const opts = orbitalNames ? { onEventProcessed, navigate: onNavigate, traitConfigsByName, orbitalsByTrait } : { navigate: onNavigate, persistence, traitConfigsByName, orbitalsByTrait };
   const { sendEvent } = useTraitStateMachine(traits2, slotsActions, opts);
   const initSentRef = useRef(false);
   useEffect(() => {
@@ -52373,27 +52418,68 @@ function SchemaRunner({ schema, serverUrl, mockData, pageName, onNavigate, onLoc
   const allPageTraits = useMemo(() => {
     if (pageName && traits2.length > 0) return traits2;
     if (!ir?.pages || ir.pages.size <= 1) return traits2;
-    const combined = [];
+    const firstPage = ir.pages.values().next().value;
+    if (!firstPage) return traits2;
+    const firstPageTraits = [];
     const seen = /* @__PURE__ */ new Set();
-    for (const page of ir.pages.values()) {
-      for (const t of page.traits) {
-        const binding = t;
-        const traitObj = binding.trait;
-        const name = traitObj?.name ?? binding.name ?? "";
-        if (name && !seen.has(name)) {
-          seen.add(name);
-          combined.push(t);
-        }
+    for (const binding of firstPage.traits) {
+      const name = binding.trait.name;
+      if (name && !seen.has(name)) {
+        seen.add(name);
+        firstPageTraits.push(binding);
       }
     }
-    return combined.length > 0 ? combined : traits2;
+    return firstPageTraits.length > 0 ? firstPageTraits : traits2;
   }, [ir, traits2, pageName]);
-  const orbitalNames = useMemo(() => {
+  useMemo(() => {
     const parsed = schema;
     const orbitals = parsed?.orbitals;
     if (!orbitals) return [];
     return orbitals.filter((o) => typeof o.name === "string").map((o) => o.name);
   }, [schema]);
+  const orbitalsByTrait = useMemo(() => {
+    const map = {};
+    const parsed = schema;
+    if (!parsed?.orbitals) return map;
+    for (const orb of parsed.orbitals) {
+      for (const traitRef of orb.traits) {
+        let traitName;
+        if (typeof traitRef === "string") {
+          const parts = traitRef.split(".");
+          traitName = parts[parts.length - 1];
+        } else if ("ref" in traitRef && typeof traitRef.ref === "string") {
+          const parts = traitRef.ref.split(".");
+          traitName = traitRef.name ?? parts[parts.length - 1];
+        } else if ("name" in traitRef && typeof traitRef.name === "string") {
+          traitName = traitRef.name;
+        }
+        if (traitName) map[traitName] = orb.name;
+      }
+    }
+    return map;
+  }, [schema]);
+  const pageOrbitalNames = useMemo(() => {
+    const set = /* @__PURE__ */ new Set();
+    for (const binding of allPageTraits) {
+      const orb = orbitalsByTrait[binding.trait.name];
+      if (orb) set.add(orb);
+    }
+    return Array.from(set);
+  }, [allPageTraits, orbitalsByTrait]);
+  useEffect(() => {
+    const traitNames = allPageTraits.map((b) => b.trait.name);
+    const orbitalsByTraitForPage = {};
+    for (const name of traitNames) {
+      const orb = orbitalsByTrait[name];
+      if (orb) orbitalsByTraitForPage[name] = orb;
+    }
+    xOrbitalLog3.info("SchemaRunner:mount", {
+      pageName,
+      traitNames,
+      orbitalsByTraitForPage,
+      pageOrbitalNames: pageOrbitalNames.join(",")
+    });
+  }, [pageName, allPageTraits, orbitalsByTrait, pageOrbitalNames]);
   const traitConfigsByName = useMemo(() => {
     const map = {};
     const parsed = schema;
@@ -52434,8 +52520,9 @@ function SchemaRunner({ schema, serverUrl, mockData, pageName, onNavigate, onLoc
           TraitInitializer,
           {
             traits: allPageTraits,
-            orbitalNames: serverUrl ? orbitalNames : void 0,
+            orbitalNames: serverUrl ? pageOrbitalNames : void 0,
             traitConfigsByName,
+            orbitalsByTrait,
             onNavigate,
             onLocalFallback,
             persistence
@@ -52457,7 +52544,8 @@ function OrbPreview({
   autoMock = false,
   height = "400px",
   className,
-  serverUrl
+  serverUrl,
+  initialPagePath
 }) {
   const [localFallback, setLocalFallback] = useState(false);
   const eventBus = useEventBus();
@@ -52503,7 +52591,17 @@ function OrbPreview({
       return [];
     }
   }, [parsedSchema]);
-  const [currentPage, setCurrentPage] = useState(void 0);
+  const initialPageName = useMemo(() => {
+    if (!initialPagePath) return void 0;
+    const match = pages.find(({ page }) => page.path === initialPagePath);
+    return match?.page.name;
+  }, [pages, initialPagePath]);
+  const [currentPage, setCurrentPage] = useState(initialPageName);
+  useEffect(() => {
+    if (initialPageName && initialPageName !== currentPage) {
+      setCurrentPage(initialPageName);
+    }
+  }, [initialPageName, currentPage]);
   const handleNavigate = useCallback((path) => {
     const match = pages.find(({ page }) => page.path === path);
     if (match) {

package/dist/components/atoms/Card.d.ts

@@ -9,6 +9,8 @@ export interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
     subtitle?: string;
     /** Shadow size override */
     shadow?: CardShadow;
+    /** Card content */
+    children?: React.ReactNode;
 }
 export declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
 export declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;

package/dist/components/index.cjs

@@ -4897,6 +4897,7 @@ var init_SlotsContext = __esm({
   "runtime/ui/SlotsContext.tsx"() {
     init_logger();
     slotLog = createLogger("almadar:ui:slot-render");
+    createLogger("almadar:runtime:cross-orbital");
     refIds = /* @__PURE__ */ new WeakMap();
     nextRefId = 1;
     React111.createContext({});
@@ -6311,7 +6312,7 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect66, useRef: useRef65, useCallback: useCallback115, useState: useState100 } = React111__namespace.default;
+      const { useEffect: useEffect66, useRef: useRef65, useCallback: useCallback115, useState: useState99 } = React111__namespace.default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus2 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
@@ -6355,7 +6356,7 @@ var init_MapView = __esm({
         showAttribution = true
       }) {
         const eventBus = useEventBus2();
-        const [clickedPosition, setClickedPosition] = useState100(null);
+        const [clickedPosition, setClickedPosition] = useState99(null);
         const handleMapClick = useCallback115((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
@@ -41123,87 +41124,58 @@ function useUISlotManager() {
 // hooks/useUIEvents.ts
 init_useEventBus();
 var UI_PREFIX = "UI:";
-function useUIEvents(dispatch, validEvents, eventBusInstance) {
+function useUIEvents(dispatch, traitName, validEvents, eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
-  const validEventsKey = validEvents ? validEvents.slice().sort().join(",") : "";
+  const validEventsKey = validEvents.slice().sort().join(",");
   const stableValidEvents = React111.useMemo(
     () => validEvents,
     [validEventsKey]
-    // intentional — validEventsKey is the stable dep, not validEvents array ref
+    // intentional — validEventsKey is the stable dep
   );
   React111.useEffect(() => {
     const unsubscribes = [];
-    if (stableValidEvents) {
-      for (const smEvent of stableValidEvents) {
-        const prefixedHandler = (event) => {
-          dispatch(smEvent, event.payload);
-        };
-        unsubscribes.push(eventBus.on(`${UI_PREFIX}${smEvent}`, prefixedHandler));
-        const directHandler = (event) => {
-          if (event.source && event.source.fromBridge) {
-            return;
-          }
-          dispatch(smEvent, event.payload);
-        };
-        unsubscribes.push(eventBus.on(smEvent, directHandler));
-      }
-    }
-    const genericHandler = (event) => {
-      const eventName = event.payload?.event;
-      if (eventName) {
-        const smEvent = eventName;
-        if (!stableValidEvents || stableValidEvents.includes(smEvent)) {
-          dispatch(smEvent, event.payload);
+    for (const smEvent of stableValidEvents) {
+      const handler = (event) => {
+        if (event.source && event.source.fromBridge) {
+          return;
         }
-      }
-    };
-    unsubscribes.push(eventBus.on(`${UI_PREFIX}DISPATCH`, genericHandler));
+        dispatch(smEvent, event.payload);
+      };
+      unsubscribes.push(
+        eventBus.on(`${UI_PREFIX}${traitName}.${smEvent}`, handler)
+      );
+    }
     return () => {
       for (const unsub of unsubscribes) {
         if (typeof unsub === "function") unsub();
       }
     };
-  }, [eventBus, dispatch, stableValidEvents]);
+  }, [eventBus, dispatch, traitName, stableValidEvents]);
 }
-function useSelectedEntity(eventBusInstance) {
+function useTraitListens(dispatch, listens, eventBusInstance) {
   const defaultEventBus = useEventBus();
   const eventBus = eventBusInstance ?? defaultEventBus;
-  const selectionContext = useSelectionContext();
-  const [localSelected, setLocalSelected] = React111.useState(null);
-  const usingContext = selectionContext !== null;
+  const stableKey = listens.map((l) => `${l.sourceKey}->${l.trigger}`).sort().join("|");
+  const stableListens = React111.useMemo(
+    () => listens,
+    [stableKey]
+    // intentional
+  );
   React111.useEffect(() => {
-    if (usingContext) return;
-    const handleSelect = (event) => {
-      const row = event.payload?.row;
-      if (row) {
-        setLocalSelected(row);
-      }
-    };
-    const handleDeselect = () => {
-      setLocalSelected(null);
-    };
-    const unsubSelect = eventBus.on("UI:SELECT", handleSelect);
-    const unsubView = eventBus.on("UI:VIEW", handleSelect);
-    const unsubDeselect = eventBus.on("UI:DESELECT", handleDeselect);
-    const unsubClose = eventBus.on("UI:CLOSE", handleDeselect);
-    const unsubCancel = eventBus.on("UI:CANCEL", handleDeselect);
+    const unsubscribes = [];
+    for (const spec of stableListens) {
+      const handler = (event) => {
+        dispatch(spec.trigger, event.payload);
+      };
+      unsubscribes.push(eventBus.on(`${UI_PREFIX}${spec.sourceKey}`, handler));
+    }
     return () => {
-      [unsubSelect, unsubView, unsubDeselect, unsubClose, unsubCancel].forEach(
-        (unsub) => {
-          if (typeof unsub === "function") unsub();
-        }
-      );
+      for (const unsub of unsubscribes) {
+        if (typeof unsub === "function") unsub();
+      }
     };
-  }, [eventBus, usingContext]);
-  if (selectionContext) {
-    return [selectionContext.selected, selectionContext.setSelected];
-  }
-  return [localSelected, setLocalSelected];
-}
-function useSelectionContext() {
-  const context = React111.useContext(providers.SelectionContext);
-  return context;
+  }, [eventBus, dispatch, stableListens]);
 }
 
 // hooks/index.ts
@@ -41738,10 +41710,10 @@ exports.usePlayer = usePlayer;
 exports.usePreview = usePreview;
 exports.usePullToRefresh = usePullToRefresh;
 exports.useQuerySingleton = useQuerySingleton;
-exports.useSelectedEntity = useSelectedEntity;
 exports.useSingletonEntity = useSingletonEntity;
 exports.useSpriteAnimations = useSpriteAnimations;
 exports.useSwipeGesture = useSwipeGesture;
+exports.useTraitListens = useTraitListens;
 exports.useTranslate = useTranslate;
 exports.useUIEvents = useUIEvents;
 exports.useUISlotManager = useUISlotManager;