@almadar/ui 5.101.0 → 5.103.0

package/dist/avl/index.cjs

@@ -33295,12 +33295,12 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect71, useRef: useRef67, useCallback: useCallback104, useState: useState105 } = React105__namespace.default;
+      const { useEffect: useEffect71, useRef: useRef68, useCallback: useCallback104, useState: useState105 } = React105__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 }) {
         const map = useMap();
-        const prevRef = useRef67({ centerLat, centerLng, zoom });
+        const prevRef = useRef68({ centerLat, centerLng, zoom });
         useEffect71(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
@@ -46291,7 +46291,7 @@ function getAllEvents(traits2) {
 function EventDispatcherTab({ traits: traits2, schema }) {
   const eventBus = useEventBus();
   const { t } = hooks.useTranslate();
-  const [log11, setLog] = React105__namespace.useState([]);
+  const [log12, setLog] = React105__namespace.useState([]);
   const prevStatesRef = React105__namespace.useRef(/* @__PURE__ */ new Map());
   React105__namespace.useEffect(() => {
     for (const trait of traits2) {
@@ -46355,9 +46355,9 @@ function EventDispatcherTab({ traits: traits2, schema }) {
       /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "medium", className: "text-gray-500 mb-1", children: t("debug.otherEvents") }),
       /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap gap-1", children: unavailableEvents.map((event) => /* @__PURE__ */ jsxRuntime.jsx(Badge, { variant: "default", size: "sm", className: "opacity-50", children: event }, event)) })
     ] }),
-    log11.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+    log12.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
       /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "medium", className: "text-gray-500 mb-1", children: t("debug.recentTransitions") }),
-      /* @__PURE__ */ jsxRuntime.jsx(Stack, { gap: "xs", children: log11.map((entry, i) => /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Stack, { gap: "xs", children: log12.map((entry, i) => /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-purple-400", children: entry.traitName }),
         " ",
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-gray-500", children: entry.from }),
@@ -53642,7 +53642,67 @@ function convertFnFormLambdasInProps(props) {
 
 // hooks/index.ts
 init_useEventBus();
-var log7 = logger.createLogger("almadar:ui:effects:client-handlers");
+var log7 = logger.createLogger("almadar:ui:shared-entity-store");
+var EMPTY_ENTITY_STATE = {};
+function createSharedEntityStore() {
+  const states = /* @__PURE__ */ new Map();
+  const subscribers2 = /* @__PURE__ */ new Map();
+  const getSnapshot2 = (entityId) => states.get(entityId) ?? EMPTY_ENTITY_STATE;
+  const subscribe = (entityId, callback) => {
+    let set = subscribers2.get(entityId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      subscribers2.set(entityId, set);
+    }
+    set.add(callback);
+    return () => {
+      const current = subscribers2.get(entityId);
+      if (!current) return;
+      current.delete(callback);
+      if (current.size === 0) {
+        subscribers2.delete(entityId);
+      }
+    };
+  };
+  const commit = (entityId, nextState) => {
+    states.set(entityId, nextState);
+    const set = subscribers2.get(entityId);
+    if (!set) return;
+    set.forEach((callback) => {
+      try {
+        callback();
+      } catch (error) {
+        log7.error("Shared entity subscriber error", {
+          entityId,
+          error: error instanceof Error ? error : String(error)
+        });
+      }
+    });
+  };
+  const seed = (entityId, initialState) => {
+    if (!states.has(entityId)) {
+      states.set(entityId, initialState);
+    }
+  };
+  return { getSnapshot: getSnapshot2, subscribe, commit, seed };
+}
+function useSharedEntityStore() {
+  const storeRef = React105.useRef(null);
+  if (storeRef.current === null) {
+    storeRef.current = createSharedEntityStore();
+  }
+  return storeRef.current;
+}
+function runTickFrame(entityId, orderedWriters, store) {
+  let scratch = store.getSnapshot(entityId);
+  for (const writer of orderedWriters) {
+    const writes = writer(scratch);
+    scratch = core.mergeEntityFrame(scratch, writes);
+  }
+  store.commit(entityId, scratch);
+  return scratch;
+}
+var log8 = logger.createLogger("almadar:ui:effects:client-handlers");
 function createClientEffectHandlers(options) {
   const { eventBus, slotSetter, navigate, notify, callService, liveEntity } = options;
   return {
@@ -53651,12 +53711,12 @@ function createClientEffectHandlers(options) {
       eventBus.emit(prefixedEvent, payload);
     },
     persist: async () => {
-      log7.warn("persist is server-side only, ignored on client");
+      log8.warn("persist is server-side only, ignored on client");
     },
     // @almadar/runtime EffectHandlers.set types value:unknown — should be FieldValue (upstream fix queued)
     set: ((_entityId, field, value) => {
       if (!liveEntity) {
-        log7.warn("set is server-side only, ignored on client (no live entity)");
+        log8.warn("set is server-side only, ignored on client (no live entity)");
         return;
       }
       liveEntity[field] = value;
@@ -53688,10 +53748,10 @@ function createClientEffectHandlers(options) {
       slotSetter.addPattern(slot, pattern, props);
     },
     navigate: navigate ?? ((path) => {
-      log7.warn("No navigate handler, ignoring", { path });
+      log8.warn("No navigate handler, ignoring", { path });
     }),
     notify: notify ?? ((msg, type) => {
-      log7.debug("notify", { type, message: msg });
+      log8.debug("notify", { type, message: msg });
     })
   };
 }
@@ -53736,11 +53796,101 @@ function toTraitDefinition(binding) {
 function normalizeEventKey(eventKey) {
   return eventKey.startsWith("UI:") ? eventKey.slice(3) : eventKey;
 }
+var SHARED_ENTITY_WRITE_OPS = /* @__PURE__ */ new Set(["set"]);
+var SHARED_ENTITY_RENDER_OPS = /* @__PURE__ */ new Set(["render-ui", "render"]);
+function collectAllTraitEffects(trait) {
+  return [
+    ...trait.ticks.flatMap((t) => t.effects),
+    ...trait.transitions.flatMap((t) => t.effects)
+  ];
+}
+function effectsCallOp(effects, ops) {
+  for (const effect of effects) {
+    let found = false;
+    core.walkSExpr(effect, (node) => {
+      if (!found && Array.isArray(node) && typeof node[0] === "string" && ops.has(node[0])) {
+        found = true;
+      }
+    });
+    if (found) return true;
+  }
+  return false;
+}
+function createSharedEntityWriter(binding, tick, traitStatesRef, emit) {
+  return (scratch) => {
+    const traitName = binding.trait.name;
+    const currentState = traitStatesRef.current.get(traitName)?.currentState ?? "";
+    if (tick.appliesTo.length > 0 && !tick.appliesTo.includes(currentState)) return [];
+    const scratchEntity = { ...scratch };
+    const writes = [];
+    const ctx = evaluator.createMinimalContext(scratchEntity, {}, currentState);
+    const declaredDefaults = runtime.collectDeclaredConfigDefaults(binding.trait);
+    const callSiteConfig = binding.config;
+    if (declaredDefaults || callSiteConfig) {
+      ctx.config = { ...declaredDefaults ?? {}, ...callSiteConfig ?? {} };
+    }
+    ctx.mutateEntity = (changes) => {
+      for (const [field, value] of Object.entries(changes)) {
+        const fieldValue = value;
+        scratchEntity[field] = fieldValue;
+        writes.push({ field, value: fieldValue });
+      }
+    };
+    ctx.emit = (event, payload) => {
+      emit(event, payload);
+    };
+    if (tick.guard !== void 0 && !evaluator.evaluateGuard(tick.guard, ctx)) {
+      tickLog.debug("guard-blocked", { traitName, tick: tick.name, state: currentState });
+      return [];
+    }
+    evaluator.executeEffects(tick.effects, ctx);
+    return writes;
+  };
+}
 function useTraitStateMachine(traitBindings, uiSlots, options) {
   const eventBus = useEventBus();
   const { entities } = providers.useEntitySchema();
   const traitConfigsByName = options?.traitConfigsByName;
   const orbitalsByTrait = options?.orbitalsByTrait;
+  const sharedEntityStore = useSharedEntityStore();
+  const sharedGroups = React105.useMemo(() => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const binding of traitBindings) {
+      const linkedEntityName = binding.linkedEntity ?? binding.trait.linkedEntity;
+      if (!linkedEntityName) continue;
+      const entityDef = entities.get(linkedEntityName);
+      if (!entityDef?.shared) continue;
+      const orbitalName = orbitalsByTrait?.[binding.trait.name] ?? "";
+      const storeKey = `${orbitalName}::${linkedEntityName}`;
+      let group = groups.get(storeKey);
+      if (!group) {
+        let defaults;
+        for (const field of entityDef.fields) {
+          if (field.default !== void 0) {
+            (defaults ?? (defaults = {}))[field.name] = field.default;
+          }
+        }
+        group = { storeKey, entityName: linkedEntityName, writerBindings: [], renderBindings: [], defaults };
+        groups.set(storeKey, group);
+      }
+      const allEffects = collectAllTraitEffects(binding.trait);
+      if (effectsCallOp(allEffects, SHARED_ENTITY_WRITE_OPS)) group.writerBindings.push(binding);
+      if (effectsCallOp(allEffects, SHARED_ENTITY_RENDER_OPS)) group.renderBindings.push(binding);
+    }
+    return groups;
+  }, [traitBindings, entities, orbitalsByTrait]);
+  for (const group of sharedGroups.values()) {
+    if (group.defaults) sharedEntityStore.seed(group.storeKey, group.defaults);
+  }
+  const sharedKeyByTraitNameRef = React105.useRef(/* @__PURE__ */ new Map());
+  React105.useEffect(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const group of sharedGroups.values()) {
+      for (const binding of group.writerBindings) map.set(binding.trait.name, group.storeKey);
+      for (const binding of group.renderBindings) map.set(binding.trait.name, group.storeKey);
+    }
+    sharedKeyByTraitNameRef.current = map;
+  }, [sharedGroups]);
   const manager = React105.useMemo(() => {
     const traitDefs = traitBindings.map(toTraitDefinition);
     const m = new runtime.StateMachineManager(traitDefs);
@@ -53923,14 +54073,21 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     };
   }, [traitBindings]);
   const executeTransitionEffects = React105.useCallback(async (params) => {
-    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log11 } = params;
+    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log12 } = params;
     const traitName = binding.trait.name;
     const linkedEntity = binding.linkedEntity || "";
     const entityId = payload?.entityId;
-    let liveEntity = traitFieldStatesRef.current.get(traitName);
-    if (!liveEntity) {
-      liveEntity = {};
-      traitFieldStatesRef.current.set(traitName, liveEntity);
+    const sharedKey = sharedKeyByTraitNameRef.current.get(traitName);
+    let liveEntity;
+    if (sharedKey !== void 0) {
+      liveEntity = { ...sharedEntityStore.getSnapshot(sharedKey) };
+    } else {
+      let existing = traitFieldStatesRef.current.get(traitName);
+      if (!existing) {
+        existing = {};
+        traitFieldStatesRef.current.set(traitName, existing);
+      }
+      liveEntity = existing;
     }
     const effects = syncOnly ? params.effects.filter(
       (e) => Array.isArray(e) && SYNC_TICK_OPERATORS.has(String(e[0]))
@@ -54012,7 +54169,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       ...handlers,
       set: async (targetId, field, value) => {
         if (baseSet) await baseSet(targetId, field, value);
-        log11.debug("set:write", {
+        log12.debug("set:write", {
           traitName,
           field,
           value: JSON.stringify(value),
@@ -54052,17 +54209,20 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     const executor = new runtime.EffectExecutor({ handlers: trackingHandlers, bindings: bindingCtx, context: effectContext });
     try {
       await executor.executeAll(effects);
-      log11.debug("effects:executed", () => ({
+      if (sharedKey !== void 0) {
+        sharedEntityStore.commit(sharedKey, liveEntity);
+      }
+      log12.debug("effects:executed", () => ({
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
         effectCount: effects.length,
         emitted: emittedDuringExec.join(","),
-        entityAfter: JSON.stringify(traitFieldStatesRef.current.get(traitName) ?? {}),
+        entityAfter: JSON.stringify(liveEntity ?? {}),
         slotsTouched: Array.from(pendingSlots.keys()).join(",")
       }));
       for (const [slot, patterns] of pendingSlots) {
-        log11.debug("flush:slot", {
+        log12.debug("flush:slot", {
           traitName,
           slot,
           patternCount: patterns.length,
@@ -54077,7 +54237,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         });
       }
     } catch (error) {
-      log11.error("effects:error", {
+      log12.error("effects:error", {
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
@@ -54086,14 +54246,16 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       });
     }
     return emittedDuringExec;
-  }, [eventBus, flushSlot]);
+  }, [eventBus, flushSlot, sharedEntityStore]);
   const runTickEffects = React105.useCallback((tick, binding) => {
     const traitName = binding.trait.name;
     const currentState = traitStatesRef.current.get(traitName)?.currentState ?? "";
     if (tick.appliesTo.length > 0 && !tick.appliesTo.includes(currentState)) return;
     if (tick.guard !== void 0) {
+      const sharedKey = sharedKeyByTraitNameRef.current.get(traitName);
+      const entity = sharedKey !== void 0 ? sharedEntityStore.getSnapshot(sharedKey) : traitFieldStatesRef.current.get(traitName) ?? {};
       const guardCtx = {
-        entity: traitFieldStatesRef.current.get(traitName) ?? {},
+        entity,
         payload: {},
         state: currentState
       };
@@ -54118,10 +54280,46 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       syncOnly: true,
       log: tickLog
     });
-  }, [executeTransitionEffects]);
+  }, [executeTransitionEffects, sharedEntityStore]);
+  const emitFromSharedWriter = React105.useCallback((event, payload) => {
+    const prefixedEvent = event.startsWith("UI:") ? event : `UI:${event}`;
+    eventBus.emit(prefixedEvent, payload);
+  }, [eventBus]);
   React105.useEffect(() => {
     const scheduler = runtime.createTickScheduler();
+    const writerTraitNames = /* @__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 intervalKey = String(tick.interval);
+          const entries = ticksByInterval.get(intervalKey) ?? [];
+          entries.push({ binding, tick });
+          ticksByInterval.set(intervalKey, entries);
+        }
+      }
+      for (const entries of ticksByInterval.values()) {
+        const interval = entries[0].tick.interval;
+        const onDue = () => {
+          const writers = entries.map(
+            ({ binding, tick }) => createSharedEntityWriter(binding, tick, traitStatesRef, emitFromSharedWriter)
+          );
+          runTickFrame(group.storeKey, writers, sharedEntityStore);
+        };
+        if (interval === "frame") {
+          scheduler.add(0, onDue);
+        } else if (typeof interval === "number") {
+          scheduler.add(interval, onDue);
+        } else if (runtime.isValidCronExpression(interval)) {
+          scheduler.addCron(interval, onDue);
+        } else {
+          scheduler.add(runtime.parseDurationString(interval), onDue);
+        }
+      }
+    }
     for (const binding of traitBindings) {
+      if (writerTraitNames.has(binding.trait.name)) continue;
       for (const tick of binding.trait.ticks ?? []) {
         if (tick.interval === "frame") {
           scheduler.add(0, () => runTickEffects(tick, binding));
@@ -54135,7 +54333,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       }
     }
     return () => scheduler.stopAll();
-  }, [traitBindings, runTickEffects]);
+  }, [traitBindings, runTickEffects, sharedGroups, sharedEntityStore, emitFromSharedWriter]);
   const processEventQueued = React105.useCallback(async (eventKey, payload) => {
     const normalizedEvent = normalizeEventKey(eventKey);
     const bindings = traitBindingsRef.current;
@@ -54479,7 +54677,7 @@ function buildOrbitalsByTrait(schema, resolvedPages = []) {
 // runtime/OrbPreview.tsx
 init_verificationRegistry();
 var PERF_NAMESPACE = "almadar:perf:canvas";
-var log8 = logger.createLogger(PERF_NAMESPACE);
+var log9 = logger.createLogger(PERF_NAMESPACE);
 var RING_SIZE = 50;
 var ring = [];
 var writeIdx = 0;
@@ -54530,7 +54728,7 @@ function perfEnd(name, startToken, detail) {
     }
   }
   push({ name, durationMs, ts: endTs, detail });
-  log8.debug(name, () => ({ durationMs, ...detail ?? {} }));
+  log9.debug(name, () => ({ durationMs, ...detail ?? {} }));
 }
 var profilerOnRender = (id, phase, actualDuration, baseDuration, _startTime, commitTime) => {
   if (!isEnabled()) return;
@@ -54540,7 +54738,7 @@ var profilerOnRender = (id, phase, actualDuration, baseDuration, _startTime, com
     ts: commitTime,
     detail: { baseDuration }
   });
-  log8.debug(`profiler:${id}:${phase}`, () => ({ actualDuration, baseDuration }));
+  log9.debug(`profiler:${id}:${phase}`, () => ({ actualDuration, baseDuration }));
 };
 
 // lib/prepareSchemaForPreview.ts
@@ -55182,7 +55380,7 @@ init_useEventBus();
 // components/avl/hooks/useCanvasDnd.tsx
 init_useEventBus();
 init_useAlmadarDndCollision();
-var log9 = logger.createLogger("almadar:ui:canvas-dnd");
+var log10 = logger.createLogger("almadar:ui:canvas-dnd");
 function useCanvasDraggable({
   id,
   payload,
@@ -55221,7 +55419,7 @@ function defaultEmit(eventBus, drop) {
   if (payload.kind === "pattern") {
     const patternType = payload.data["type"];
     if (typeof patternType !== "string") {
-      log9.warn("default-emit:pattern:missing-type");
+      log10.warn("default-emit:pattern:missing-type");
       return;
     }
     const out = { patternType, containerNode: target.containerNode };
@@ -55230,23 +55428,23 @@ function defaultEmit(eventBus, drop) {
       out.index = resolved.index;
     }
     eventBus.emit("UI:PATTERN_DROP", out);
-    log9.info("default-emit:pattern", { patternType, level: target.level });
+    log10.info("default-emit:pattern", { patternType, level: target.level });
     return;
   }
   if (payload.kind === "behavior") {
     const behaviorName = payload.data["name"];
     if (typeof behaviorName !== "string") {
-      log9.warn("default-emit:behavior:missing-name");
+      log10.warn("default-emit:behavior:missing-name");
       return;
     }
     eventBus.emit("UI:BEHAVIOR_DROP", {
       behaviorName,
       containerNode: target.containerNode
     });
-    log9.info("default-emit:behavior", { behaviorName, level: target.level });
+    log10.info("default-emit:behavior", { behaviorName, level: target.level });
     return;
   }
-  log9.debug("default-emit:unhandled-kind", { kind: payload.kind });
+  log10.debug("default-emit:unhandled-kind", { kind: payload.kind });
 }
 function CanvasDndProvider({
   children,
@@ -55262,9 +55460,9 @@ function CanvasDndProvider({
     if (payload) {
       setActivePayload(payload);
       eventBus.emit("UI:DRAG_START", { kind: payload.kind, data: payload.data });
-      log9.info("dragStart", { id: e.active.id, kind: payload.kind });
+      log10.info("dragStart", { id: e.active.id, kind: payload.kind });
     } else {
-      log9.warn("dragStart:missing-payload", { id: e.active.id });
+      log10.warn("dragStart:missing-payload", { id: e.active.id });
     }
   }, [eventBus]);
   const handleDragEnd = React105__namespace.default.useCallback((e) => {
@@ -55274,7 +55472,7 @@ function CanvasDndProvider({
     const overData = e.over?.data.current;
     const target = overData?.target;
     const accepts = overData?.accepts;
-    log9.info("dragEnd", {
+    log10.info("dragEnd", {
       activeId: e.active.id,
       overId: e.over?.id,
       hasPayload: !!payload,
@@ -55286,7 +55484,7 @@ function CanvasDndProvider({
     }
     if (!payload || !target) return;
     if (accepts && !accepts.includes(payload.kind)) {
-      log9.debug("dragEnd:rejected:kind", { kind: payload.kind, accepts: [...accepts] });
+      log10.debug("dragEnd:rejected:kind", { kind: payload.kind, accepts: [...accepts] });
       return;
     }
     const activator = e.activatorEvent;
@@ -55298,7 +55496,7 @@ function CanvasDndProvider({
   }, [eventBus, onDrop]);
   const handleDragCancel = React105__namespace.default.useCallback(() => {
     setActivePayload(null);
-    log9.info("dragCancel");
+    log10.info("dragCancel");
   }, []);
   return /* @__PURE__ */ jsxRuntime.jsxs(
     core$1.DndContext,
@@ -57131,7 +57329,7 @@ init_AvlTransitionLane();
 init_AvlSwimLane();
 init_avl_atom_types();
 init_avl_elk_layout();
-var log10 = logger.createLogger("almadar:ui:avl:trait-scene");
+var log11 = logger.createLogger("almadar:ui:avl:trait-scene");
 var SWIM_GUTTER2 = 120;
 var CENTER_W2 = 360;
 var AvlTraitScene = ({
@@ -57144,7 +57342,7 @@ var AvlTraitScene = ({
   const dataKey = React105.useMemo(() => JSON.stringify(data), [data]);
   React105.useEffect(() => {
     computeTraitLayout(data).then(setLayout).catch((error) => {
-      log10.error("computeTraitLayout failed", { error: error instanceof Error ? error : String(error) });
+      log11.error("computeTraitLayout failed", { error: error instanceof Error ? error : String(error) });
     });
   }, [dataKey]);
   if (!layout) {