@almadar/ui 5.111.0 → 5.113.0

package/dist/runtime/index.js

@@ -11,7 +11,7 @@ import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { createPortal } from 'react-dom';
 import { useTranslate } from '@almadar/ui/hooks';
 import { useUISlots, UISlotProvider, useTheme } from '@almadar/ui/context';
-import { evaluateGuard, createMinimalContext, executeEffects, evaluate } from '@almadar/evaluator';
+import { evaluateGuard, evaluate, createMinimalContext, executeEffects } from '@almadar/evaluator';
 import { Link, Outlet, useLocation } from 'react-router-dom';
 import ELK from 'elkjs/lib/elk.bundled.js';
 import SyntaxHighlighter from 'react-syntax-highlighter/dist/esm/prism-light.js';
@@ -42,8 +42,8 @@ import { DndContext, pointerWithin, rectIntersection, closestCorners, useSensors
 import { useSortable, arrayMove, sortableKeyboardCoordinates, SortableContext, rectSortingStrategy, verticalListSortingStrategy } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
 import { useNodeId, ReactFlowProvider, Handle, Position } from '@xyflow/react';
-import { getPatternDefinition, getComponentForPattern as getComponentForPattern$1 } from '@almadar/patterns';
-import { StateMachineManager, collectDeclaredConfigDefaults, createServerEffectHandlers, EffectExecutor, createContextFromBindings, createTickScheduler, isValidCronExpression, parseDurationString, InMemoryPersistence } from '@almadar/runtime';
+import { isDrawHostPattern, getPatternDefinition, getComponentForPattern as getComponentForPattern$1 } from '@almadar/core/patterns';
+import { StateMachineManager, collectDeclaredConfigDefaults, createServerEffectHandlers, EffectExecutor, createContextFromBindings, createTickScheduler, isValidCronExpression, parseDurationString, InMemoryPersistence, normalizeCallSiteConfigToValues } from '@almadar/runtime';
 import { OrbitalServerRuntime } from '@almadar/runtime/OrbitalServerRuntime';
 
 var __defProp = Object.defineProperty;
@@ -9228,8 +9228,12 @@ var init_MiniMap = __esm({
     MiniMap.displayName = "MiniMap";
   }
 });
-function useCamera() {
-  const cameraRef = useRef({ x: 0, y: 0, zoom: 1 });
+function useCamera(initial) {
+  const cameraRef = useRef({
+    x: initial?.x ?? 0,
+    y: initial?.y ?? 0,
+    zoom: initial?.zoom ?? 1
+  });
   const targetCameraRef = useRef(null);
   const isDraggingRef = useRef(false);
   const dragDistanceRef = useRef(0);
@@ -9798,8 +9802,18 @@ function Canvas2D({
   scale = 0.4,
   showMinimap = true,
   followTarget,
+  cameraPos,
   bgColor
 }) {
+  const instanceId = useMemo(() => Math.random().toString(36).slice(2, 8), []);
+  function isDrawableLayer(node) {
+    return node.type === "draw-sprite-layer" || node.type === "draw-shape-layer" || node.type === "draw-text-layer";
+  }
+  const layerSummaries = drawables?.map((d) => {
+    if (!isDrawableLayer(d)) return { type: d.type };
+    return { type: d.type, itemsLen: d.items.length, firstItem: d.items[0] };
+  });
+  canvas2DLog.debug("Canvas2D render", { instanceId, projection, scale, cameraMode: camera, cameraPos: cameraPos ? JSON.stringify(cameraPos) : void 0, drawablesCount: drawables?.length, layerSummaries: layerSummaries ? JSON.stringify(layerSummaries) : void 0 });
   const backgroundImage = normalizeBackdrop(backgroundImageRaw);
   const isFree = projection === "free";
   const squareGrid = projection === "flat" || isFree || projection === "side";
@@ -9882,7 +9896,7 @@ function Canvas2D({
     zoomAtPoint,
     screenToWorld,
     lerpToTarget
-  } = useCamera();
+  } = useCamera({ zoom: scale });
   const [atlasVersion, setAtlasVersion] = useState(0);
   const bumpAtlas = useCallback(() => setAtlasVersion((v) => v + 1), []);
   const miniMapTiles = useMemo(() => {
@@ -9928,6 +9942,14 @@ function Canvas2D({
     }
     if (!drawables || drawables.length === 0) return;
     const cam = cameraRef.current;
+    if (cameraPos && dragDistance() === 0) {
+      const p = projector.anchorPoint(cameraPos, "center");
+      cam.x = p.x - viewportSize.width / 2;
+      cam.y = p.y - viewportSize.height / 2;
+    }
+    const containerRect = containerRef.current?.getBoundingClientRect();
+    const canvasRect = canvas.getBoundingClientRect();
+    canvas2DLog.debug("Canvas2D draw", { instanceId, viewportSize, baseOffsetX, cam: { x: cam.x, y: cam.y, zoom: cam.zoom }, cameraPos: cameraPos ? JSON.stringify(cameraPos) : void 0, containerRect: containerRect ? { width: containerRect.width, height: containerRect.height } : null, canvasRect: canvasRect ? { width: canvasRect.width, height: canvasRect.height } : null });
     const painter = createWebPainter(ctx, bumpAtlas);
     painter.save();
     painter.translate(viewportSize.width / 2, viewportSize.height / 2);
@@ -10139,6 +10161,7 @@ function Canvas2D({
     }
   );
 }
+var canvas2DLog;
 var init_Canvas2D = __esm({
   "components/game/molecules/Canvas2D.tsx"() {
     "use client";
@@ -10160,6 +10183,7 @@ var init_Canvas2D = __esm({
     init_paintDispatch();
     init_hitTest();
     init_isometric();
+    canvas2DLog = createLogger("almadar:ui:game-canvas");
     Canvas2D.displayName = "Canvas2D";
   }
 });
@@ -10198,6 +10222,7 @@ function Canvas({
   keyMap,
   keyUpMap
 }) {
+  canvasLog.debug("Canvas render", { mode, drawablesCount: drawables?.length, projection, camera: camera ? JSON.stringify(camera) : void 0 });
   const zoom = camera?.zoom;
   if (mode === "3d") {
     const props3d = {
@@ -10237,6 +10262,7 @@ function Canvas({
       camera: to2DCamera(camera?.mode),
       ...zoom !== void 0 ? { scale: zoom } : {},
       ...camera?.target !== void 0 ? { followTarget: camera.target } : {},
+      ...camera?.pos !== void 0 ? { cameraPos: camera.pos } : {},
       showMinimap,
       backgroundImage,
       ...backgroundColor !== void 0 ? { bgColor: backgroundColor } : {},
@@ -10249,7 +10275,7 @@ function Canvas({
     }
   );
 }
-var Canvas3DHost;
+var Canvas3DHost, canvasLog;
 var init_Canvas = __esm({
   "components/game/molecules/Canvas.tsx"() {
     "use client";
@@ -10257,6 +10283,7 @@ var init_Canvas = __esm({
     Canvas3DHost = lazy(
       () => import('@almadar/ui/components/molecules/game/three').then((m) => ({ default: m.Canvas3DHost }))
     );
+    canvasLog = createLogger("almadar:ui:game-canvas");
     Canvas.displayName = "Canvas";
   }
 });
@@ -43651,7 +43678,7 @@ function SlotContentRenderer({
     const childrenConfig = content.props.children;
     const isSingleChild = typeof childrenConfig === "string" || typeof childrenConfig === "object" && childrenConfig !== null && !Array.isArray(childrenConfig) && "type" in childrenConfig;
     const hasChildren = PATTERNS_WITH_CHILDREN.has(content.pattern) || Array.isArray(childrenConfig) && childrenConfig.length > 0 || isSingleChild;
-    const isDrawHost = getPatternDefinition(content.pattern)?.drawHost === true;
+    const isDrawHost = isDrawHostPattern(content.pattern);
     const myPath = patternPath ?? "root";
     const renderedChildren = hasChildren && !isDrawHost ? renderPatternChildren(childrenConfig, onDismiss, content.id, myPath, content.sourceTrait, {
       slot: content.slot,
@@ -44170,6 +44197,8 @@ var flushLog = createLogger("almadar:ui:slot-flush");
 var stateLog = createLogger("almadar:ui:state-transitions");
 var tickLog = createLogger("almadar:ui:tick-effects");
 setNamespaceLevel("almadar:ui:tick-effects", "WARN");
+var sharedEntityLog = createLogger("almadar:ui:shared-entity");
+setNamespaceLevel("almadar:ui:shared-entity", "WARN");
 var SYNC_TICK_OPERATORS = /* @__PURE__ */ new Set([
   "set",
   "emit",
@@ -44222,6 +44251,14 @@ function effectsCallOp(effects, ops) {
   }
   return false;
 }
+function classifySharedTick(tick) {
+  const writes = effectsCallOp(tick.effects, SHARED_ENTITY_WRITE_OPS);
+  const renders = effectsCallOp(tick.effects, SHARED_ENTITY_RENDER_OPS);
+  if (writes && renders) return "both";
+  if (writes) return "writer";
+  if (renders) return "renderer";
+  return "neither";
+}
 function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
   return (scratch) => {
     const traitName = binding.trait.name;
@@ -44231,7 +44268,7 @@ function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
     const writes = [];
     const ctx = createMinimalContext(scratchEntity, {}, currentState);
     const declaredDefaults = collectDeclaredConfigDefaults(binding.trait);
-    const callSiteConfig = binding.config;
+    const callSiteConfig = getBindingConfig(binding);
     if (declaredDefaults || callSiteConfig) {
       ctx.config = { ...declaredDefaults ?? {}, ...callSiteConfig ?? {} };
     }
@@ -44253,7 +44290,25 @@ function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
     return writes;
   };
 }
+function getBindingConfig(binding) {
+  const raw = binding.config;
+  const normalized = normalizeCallSiteConfigToValues(raw);
+  sharedEntityLog.debug("getBindingConfig", { traitName: binding.trait.name, rawKeys: raw ? Object.keys(raw) : void 0, hasTiles: raw ? "tiles" in raw : false });
+  return normalized;
+}
+function evalFieldDefault(value) {
+  if (!Array.isArray(value) || value.length === 0) return value;
+  const head = value[0];
+  const isSExpr = typeof head === "string" && (head.includes("/") || head === "let" || head === "if" || head === "lambda");
+  if (!isSExpr) return value;
+  try {
+    return evaluate(value, createMinimalContext({}, {}, ""));
+  } catch {
+    return value;
+  }
+}
 function useTraitStateMachine(traitBindings, uiSlots, options) {
+  sharedEntityLog.debug("useTraitStateMachine start", { traitBindingsCount: traitBindings.length, traitNames: traitBindings.map((b) => b.trait.name) });
   const eventBus = useEventBus();
   const { entities } = useEntitySchema();
   const traitConfigsByName = options?.traitConfigsByName;
@@ -44272,8 +44327,17 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       if (!group) {
         let defaults;
         for (const field of entityDef.fields) {
-          if (field.default !== void 0) {
-            (defaults ?? (defaults = {}))[field.name] = field.default;
+          if (field.default !== void 0 && field.default !== null) {
+            const evaluated = evalFieldDefault(field.default);
+            if (field.name === "tiles") {
+              sharedEntityLog.debug("seed tiles", {
+                linkedEntityName,
+                type: typeof evaluated,
+                length: Array.isArray(evaluated) ? evaluated?.length : void 0,
+                head: Array.isArray(evaluated) && evaluated.length > 0 ? JSON.stringify(evaluated[0]).slice(0, 80) : void 0
+              });
+            }
+            (defaults ?? (defaults = {}))[field.name] = evaluated;
           }
         }
         group = { storeKey, entityName: linkedEntityName, writerBindings: [], renderBindings: [], defaults };
@@ -44286,7 +44350,15 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     return groups;
   }, [traitBindings, entities, orbitalsByTrait]);
   for (const group of sharedGroups.values()) {
-    if (group.defaults) sharedEntityStore.seed(group.storeKey, group.defaults);
+    if (group.defaults) {
+      sharedEntityStore.seed(group.storeKey, group.defaults);
+      sharedEntityLog.debug("shared-seed", {
+        storeKey: group.storeKey,
+        writers: group.writerBindings.map((b) => b.trait.name),
+        renderers: group.renderBindings.map((b) => b.trait.name),
+        tilesLength: Array.isArray(group.defaults.tiles) ? group.defaults.tiles.length : group.defaults.tiles
+      });
+    }
   }
   const sharedKeyByTraitNameRef = useRef(/* @__PURE__ */ new Map());
   useEffect(() => {
@@ -44296,12 +44368,13 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       for (const binding of group.renderBindings) map.set(binding.trait.name, group.storeKey);
     }
     sharedKeyByTraitNameRef.current = map;
+    sharedEntityLog.debug("shared-map", { map: Array.from(map.entries()).map(([k, v]) => `${k}->${v}`) });
   }, [sharedGroups]);
   const manager = useMemo(() => {
     const traitDefs = traitBindings.map(toTraitDefinition);
     const m = new StateMachineManager(traitDefs);
     for (const binding of traitBindings) {
-      const cfg = binding.config ?? traitConfigsByName?.[binding.trait.name];
+      const cfg = getBindingConfig(binding) ?? traitConfigsByName?.[binding.trait.name];
       if (cfg !== void 0) {
         m.setTraitConfig(binding.trait.name, cfg);
       }
@@ -44484,6 +44557,9 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     const linkedEntity = binding.linkedEntity || "";
     const entityId = payload?.entityId;
     const sharedKey = sharedKeyByTraitNameRef.current.get(traitName);
+    if (traitName === "Hero" || traitName === "Authority") {
+      sharedEntityLog.debug("executeTransitionEffects sharedKey", { traitName, sharedKey, storeTilesLength: sharedKey ? sharedEntityStore.getSnapshot(sharedKey).tiles?.length : void 0 });
+    }
     let liveEntity;
     if (sharedKey !== void 0) {
       liveEntity = { ...sharedEntityStore.getSnapshot(sharedKey) };
@@ -44507,6 +44583,18 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       eventBus,
       slotSetter: {
         addPattern: (slot, pattern, props) => {
+          if (traitName === "Hero" && slot === "main" && props && typeof props === "object") {
+            const canvasChild = Array.isArray(props.children) ? props.children[0] : null;
+            const grandChildren = canvasChild && typeof canvasChild === "object" && !Array.isArray(canvasChild) ? canvasChild.children : null;
+            const firstLayer = Array.isArray(grandChildren) && grandChildren.length > 0 ? grandChildren[0] : null;
+            const firstLayerItems = firstLayer && typeof firstLayer === "object" && !Array.isArray(firstLayer) ? firstLayer.items : null;
+            sharedEntityLog.debug("render-ui main slot", {
+              traitName,
+              slot,
+              canvasChildType: canvasChild && typeof canvasChild === "object" && !Array.isArray(canvasChild) ? canvasChild.type : "none",
+              firstLayerItemsLength: Array.isArray(firstLayerItems) ? firstLayerItems.length : firstLayerItems
+            });
+          }
           const existing = pendingSlots.get(slot) || [];
           existing.push({ pattern, props: props || {} });
           pendingSlots.set(slot, existing);
@@ -44538,7 +44626,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         state: previousState
       };
       const sharedDeclared = collectDeclaredConfigDefaults(binding.trait);
-      const sharedCallSite = binding.config;
+      const sharedCallSite = getBindingConfig(binding);
       if (sharedDeclared || sharedCallSite) {
         sharedBindings.config = {
           ...sharedDeclared ?? {},
@@ -44589,13 +44677,21 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       state: previousState
     };
     const declaredDefaults = collectDeclaredConfigDefaults(binding.trait);
-    const callSiteConfig = binding.config;
+    const callSiteConfig = getBindingConfig(binding);
     if (declaredDefaults || callSiteConfig) {
       bindingCtx.config = {
         ...declaredDefaults ?? {},
         ...callSiteConfig ?? {}
       };
     }
+    if (traitName === "Authority" || traitName === "Hero") {
+      sharedEntityLog.debug("executeTransitionEffects config tiles", {
+        traitName,
+        tilesType: typeof bindingCtx.config?.tiles,
+        tilesLength: Array.isArray(bindingCtx.config?.tiles) ? bindingCtx.config?.tiles?.length : void 0,
+        configKeys: bindingCtx.config ? Object.keys(bindingCtx.config) : void 0
+      });
+    }
     const effectContext = {
       traitName,
       state: previousState,
@@ -44612,9 +44708,25 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         baseEmit(event, eventPayload, source);
       }
     };
+    if (traitName === "Hero") {
+      sharedEntityLog.debug("executeTransitionEffects effects summary", {
+        traitName,
+        effectsCount: effects.length,
+        hasRenderUI: typeof handlers.renderUI === "function",
+        effectHeads: effects.map((e) => Array.isArray(e) ? String(e[0]) : "??")
+      });
+    }
     const executor = new EffectExecutor({ handlers: trackingHandlers, bindings: bindingCtx, context: effectContext });
     try {
       await executor.executeAll(effects);
+      if (traitName === "Authority" || traitName === "Hero") {
+        sharedEntityLog.debug("executeTransitionEffects after executeAll", {
+          traitName,
+          tilesType: typeof liveEntity.tiles,
+          tilesLength: Array.isArray(liveEntity.tiles) ? liveEntity.tiles?.length : void 0,
+          firstTilePos: Array.isArray(liveEntity.tiles) && liveEntity.tiles.length > 0 ? JSON.stringify(liveEntity.tiles[0]).slice(0, 120) : void 0
+        });
+      }
       if (sharedKey !== void 0) {
         sharedEntityStore.commit(sharedKey, liveEntity);
       }
@@ -44665,8 +44777,9 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         payload: {},
         state: currentState
       };
-      if (binding.config) {
-        guardCtx.config = binding.config;
+      const bindingCfg = getBindingConfig(binding);
+      if (bindingCfg) {
+        guardCtx.config = bindingCfg;
       }
       const passed = evaluateGuard(
         tick.guard,
@@ -44693,12 +44806,14 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
   }, [eventBus]);
   useEffect(() => {
     const scheduler = createTickScheduler();
-    const writerTraitNames = /* @__PURE__ */ new Set();
+    const pureWriterTickKeys = /* @__PURE__ */ new Set();
     for (const group of sharedGroups.values()) {
       const ticksByInterval = /* @__PURE__ */ new Map();
       for (const binding of group.writerBindings) {
-        writerTraitNames.add(binding.trait.name);
         for (const tick of binding.trait.ticks ?? []) {
+          const classification = classifySharedTick(tick);
+          if (classification !== "writer") continue;
+          pureWriterTickKeys.add(`${binding.trait.name}::${tick.name}`);
           const intervalKey = String(tick.interval);
           const entries = ticksByInterval.get(intervalKey) ?? [];
           entries.push({ binding, tick });
@@ -44725,8 +44840,11 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       }
     }
     for (const binding of traitBindings) {
-      if (writerTraitNames.has(binding.trait.name)) continue;
       for (const tick of binding.trait.ticks ?? []) {
+        const sharedKey = sharedKeyByTraitNameRef.current.get(binding.trait.name);
+        if (sharedKey !== void 0 && pureWriterTickKeys.has(`${binding.trait.name}::${tick.name}`)) {
+          continue;
+        }
         if (tick.interval === "frame") {
           scheduler.add(0, () => runTickEffects(tick, binding));
         } else if (typeof tick.interval === "number") {
@@ -45571,6 +45689,7 @@ function TraitInitializer({ traits: traits2, orbitalNames, onNavigate, onLocalFa
       hadPrev: prevTraitsRef.current !== void 0
     }));
     if (refChanged) {
+      navLog.info("page:traits-reset", { traitsCount: Array.isArray(traits2) ? traits2.length : -1 });
       uiSlots.clearAll();
       initSentRef.current = false;
     }

package/dist/useEventBus-CQWyAWpK.d.ts

@@ -0,0 +1,65 @@
+import { E as EventBusContextType } from './event-bus-types-Bl78kokd.js';
+import { EventPayload, BusEventSource, BusEventListener } from '@almadar/core';
+
+declare global {
+    interface Window {
+        __kflowEventBus?: EventBusContextType | null;
+    }
+}
+/**
+ * Hook for accessing the event bus.
+ *
+ * Uses EventBusProvider context if available, otherwise falls back to
+ * a simple in-memory event bus (for design system / Storybook).
+ *
+ * @returns Event bus instance with emit, on, once, and hasListeners methods
+ *
+ * @example
+ * ```tsx
+ * const eventBus = useEventBus();
+ *
+ * // Emit an event
+ * eventBus.emit('UI:CLICK', { id: '123' });
+ *
+ * // Subscribe to an event
+ * useEffect(() => {
+ *   return eventBus.on('UI:CLICK', (event) => {
+ *     console.log('Clicked:', event.payload);
+ *   });
+ * }, []);
+ * ```
+ */
+declare function useEventBus(): EventBusContextType;
+/**
+ * Hook for subscribing to a specific event.
+ * Automatically cleans up subscription on unmount.
+ *
+ * @param event - Event name to subscribe to
+ * @param handler - Event handler function
+ *
+ * @example
+ * ```tsx
+ * useEventListener('UI:CLICK', (event) => {
+ *   console.log('Clicked:', event.payload);
+ * });
+ * ```
+ */
+declare function useEventListener(event: string, handler: BusEventListener): void;
+/**
+ * Hook for emitting events.
+ * Returns a memoized emit function.
+ *
+ * @returns Function to emit events
+ *
+ * @example
+ * ```tsx
+ * const emit = useEmitEvent();
+ *
+ * const handleClick = () => {
+ *   emit('UI:CLICK', { id: '123' });
+ * };
+ * ```
+ */
+declare function useEmitEvent(): (type: string, payload?: EventPayload, source?: BusEventSource) => void;
+
+export { useEventBus as a, useEventListener as b, useEmitEvent as u };

package/dist/useEventBus-Ckr4wqW3.d.cts

@@ -0,0 +1,65 @@
+import { E as EventBusContextType } from './event-bus-types-Bl78kokd.cjs';
+import { EventPayload, BusEventSource, BusEventListener } from '@almadar/core';
+
+declare global {
+    interface Window {
+        __kflowEventBus?: EventBusContextType | null;
+    }
+}
+/**
+ * Hook for accessing the event bus.
+ *
+ * Uses EventBusProvider context if available, otherwise falls back to
+ * a simple in-memory event bus (for design system / Storybook).
+ *
+ * @returns Event bus instance with emit, on, once, and hasListeners methods
+ *
+ * @example
+ * ```tsx
+ * const eventBus = useEventBus();
+ *
+ * // Emit an event
+ * eventBus.emit('UI:CLICK', { id: '123' });
+ *
+ * // Subscribe to an event
+ * useEffect(() => {
+ *   return eventBus.on('UI:CLICK', (event) => {
+ *     console.log('Clicked:', event.payload);
+ *   });
+ * }, []);
+ * ```
+ */
+declare function useEventBus(): EventBusContextType;
+/**
+ * Hook for subscribing to a specific event.
+ * Automatically cleans up subscription on unmount.
+ *
+ * @param event - Event name to subscribe to
+ * @param handler - Event handler function
+ *
+ * @example
+ * ```tsx
+ * useEventListener('UI:CLICK', (event) => {
+ *   console.log('Clicked:', event.payload);
+ * });
+ * ```
+ */
+declare function useEventListener(event: string, handler: BusEventListener): void;
+/**
+ * Hook for emitting events.
+ * Returns a memoized emit function.
+ *
+ * @returns Function to emit events
+ *
+ * @example
+ * ```tsx
+ * const emit = useEmitEvent();
+ *
+ * const handleClick = () => {
+ *   emit('UI:CLICK', { id: '123' });
+ * };
+ * ```
+ */
+declare function useEmitEvent(): (type: string, payload?: EventPayload, source?: BusEventSource) => void;
+
+export { useEventBus as a, useEventListener as b, useEmitEvent as u };

package/dist/{hooks/useUISlots.d.ts → useUISlots-BesZYMks.d.cts}

@@ -1,3 +1,6 @@
+import React__default from 'react';
+import { UISlot, RenderItemLambda, EventPayloadValue } from '@almadar/core';
+
 /**
  * useUISlots Hook
  *
@@ -29,13 +32,11 @@
  *
  * @packageDocumentation
  */
-import type React from 'react';
-import type { EventPayloadValue, RenderItemLambda, UISlot } from '@almadar/core';
-export type { UISlot };
+
 /**
  * Animation types for slot transitions
  */
-export type SlotAnimation = 'fade' | 'slide' | 'scale' | 'none';
+type SlotAnimation = 'fade' | 'slide' | 'scale' | 'none';
 /**
  * Render-prop callback after fn-form-lambda conversion or
  * `wrapCallbackForEvent` wrapping. Pattern components consume these as
@@ -45,7 +46,7 @@ export type SlotAnimation = 'fade' | 'slide' | 'scale' | 'none';
  * shapes seen at this layer. Pattern-level prop types narrow the
  * signature for each consumer downstream.
  */
-export type SlotCallback = (...args: never[]) => void | React.ReactNode | EventPayloadValue;
+type SlotCallback = (...args: never[]) => void | React__default.ReactNode | EventPayloadValue;
 /**
  * Render-ui prop value: any leaf flowing from a `(render-ui slot {...})`
  * effect into a React pattern component. The union enumerates every
@@ -61,7 +62,7 @@ export type SlotCallback = (...args: never[]) => void | React.ReactNode | EventP
  *   can appear at any depth (e.g. `tabs[].content: "@trait.X"` surviving
  *   substitution into a `ReactElement`).
  */
-export type SlotPropValue = string | number | boolean | Date | null | undefined | RenderItemLambda | SlotCallback | React.ReactElement | ReadonlyArray<SlotPropValue> | {
+type SlotPropValue = string | number | boolean | Date | null | undefined | RenderItemLambda | SlotCallback | React__default.ReactElement | ReadonlyArray<SlotPropValue> | {
     readonly [key: string]: SlotPropValue;
 };
 /**
@@ -69,11 +70,11 @@ export type SlotPropValue = string | number | boolean | Date | null | undefined
  * routes these from `(render-ui slot {...})` effects to React pattern
  * components without coercion.
  */
-export type SlotProps = Record<string, SlotPropValue>;
+type SlotProps = Record<string, SlotPropValue>;
 /**
  * Content rendered in a slot
  */
-export interface SlotContent {
+interface SlotContent {
     /** Unique ID for this content */
     id: string;
     /** Pattern/component type to render */
@@ -104,7 +105,7 @@ export interface SlotContent {
 /**
  * Configuration for render_ui effect
  */
-export interface SlotRenderConfig {
+interface SlotRenderConfig {
     /** Target slot */
     target: UISlot;
     /** Pattern/component to render */
@@ -131,7 +132,7 @@ export interface SlotRenderConfig {
 /**
  * Callback for slot changes
  */
-export type SlotChangeCallback = (slot: UISlot, content: SlotContent | null) => void;
+type SlotChangeCallback = (slot: UISlot, content: SlotContent | null) => void;
 /**
  * Fires when a specific trait's current render-ui output changes.
  * Used by `<TraitFrame>` to subscribe only to the trait it embeds,
@@ -141,11 +142,11 @@ export type SlotChangeCallback = (slot: UISlot, content: SlotContent | null) =>
  * render), so the callback signature carries just the new content —
  * no per-slot disambiguation needed.
  */
-export type TraitChangeCallback = (content: SlotContent | null) => void;
+type TraitChangeCallback = (content: SlotContent | null) => void;
 /**
  * UI Slot Manager interface
  */
-export interface UISlotManager {
+interface UISlotManager {
     /**
      * Current aggregate content for each slot. Single-source slots hold
      * that source's SlotContent; multi-source slots hold a synthetic
@@ -210,5 +211,6 @@ declare const DEFAULT_SLOTS: Partial<Record<UISlot, SlotContent | null>>;
  * This is the internal hook that creates the manager.
  * Use `useUISlots()` from context in components.
  */
-export declare function useUISlotManager(): UISlotManager;
-export { DEFAULT_SLOTS };
+declare function useUISlotManager(): UISlotManager;
+
+export { DEFAULT_SLOTS as D, type SlotAnimation as S, type UISlotManager as U, type SlotChangeCallback as a, type SlotContent as b, type SlotRenderConfig as c, useUISlotManager as u };