@almadar/ui 5.101.0 → 5.103.0

package/dist/hooks/useTraitStateMachine.d.ts

@@ -16,7 +16,9 @@
  *
  * @packageDocumentation
  */
-import type { EventPayload, ServiceParams } from '@almadar/core';
+import { type MutableRefObject } from 'react';
+import { type SharedEntityWriter } from './index';
+import type { ResolvedTraitTick, EventPayload, SExpr, ServiceParams, ResolvedTrait } from '@almadar/core';
 import { type TraitState } from '@almadar/runtime';
 import type { ResolvedTraitBinding } from '../types/runtime-types';
 import type { useUISlots } from '../providers/UISlotContext';
@@ -31,6 +33,35 @@ export interface TraitStateMachineResult {
     /** Check if a trait can handle an event from its current state */
     canHandleEvent: (traitName: string, eventKey: string) => boolean;
 }
+/** Effect head-operator that writes a field onto a shared entity. */
+export declare const SHARED_ENTITY_WRITE_OPS: ReadonlySet<string>;
+/** Effect head-operators that paint a shared entity's merged state. */
+export declare const SHARED_ENTITY_RENDER_OPS: ReadonlySet<string>;
+/** Every tick + transition effect a trait declares, flattened for a structural scan. */
+export declare function collectAllTraitEffects(trait: ResolvedTrait): SExpr[];
+/**
+ * Does ANY effect in this list call one of `ops` anywhere in its (possibly
+ * `do`/`if`/`when`/`let`-nested) tree? Reuses `@almadar/core`'s canonical
+ * `walkSExpr` rather than a bespoke recursive walk, and looks only at the
+ * effect's head operator — a structural presence check, no name-matching.
+ */
+export declare function effectsCallOp(effects: SExpr[], ops: ReadonlySet<string>): boolean;
+/**
+ * Build one writer trait's tick into a synchronous `SharedEntityWriter`
+ * (`(scratch) => writes[]`) so `runTickFrame` can fold several writer ticks
+ * into one merged commit, in binding order.
+ *
+ * `runTickFrame`'s writer contract is synchronous, but `@almadar/runtime`'s
+ * `EffectExecutor` is inherently async (`executeAll`'s `for...of await`
+ * sequencing only guarantees the FIRST top-level effect lands before a
+ * fire-and-forget caller reads the result back — everything after the first
+ * `await` boundary would be silently dropped). `@almadar/evaluator`'s
+ * `executeEffects` is fully synchronous end-to-end (its `set`/`do`/`if`/
+ * `when`/`let` dispatch never awaits), so it — not `EffectExecutor` — is the
+ * correct tool here; `ctx.mutateEntity` captures each write instead of
+ * applying it through a handler.
+ */
+export declare function createSharedEntityWriter(binding: ResolvedTraitBinding, tick: ResolvedTraitTick, traitStatesRef: MutableRefObject<Map<string, TraitState>>, emit: (event: string, payload?: EventPayload) => void): SharedEntityWriter;
 export interface UseTraitStateMachineOptions {
     /**
      * Callback invoked after each event is processed (for server forwarding).

package/dist/runtime/index.cjs

@@ -7730,7 +7730,7 @@ function recordTransition(trace) {
     ...trace,
     id: `t-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   };
-  log3.debug("transition:recorded", { trait: trace.traitName, from: trace.from, to: trace.to, event: trace.event, effectCount: trace.effects.length });
+  log4.debug("transition:recorded", { trait: trace.traitName, from: trace.from, to: trace.to, event: trace.event, effectCount: trace.effects.length });
   getState().transitions.push(entry);
   if (getState().transitions.length > MAX_TRANSITIONS) {
     getState().transitions.shift();
@@ -7832,7 +7832,7 @@ function getTraitSnapshots() {
     try {
       snapshots.push(getter());
     } catch (err) {
-      log3.error("traitSnapshot getter failed", { trait: traitName, err: String(err) });
+      log4.error("traitSnapshot getter failed", { trait: traitName, err: String(err) });
     }
   }
   return snapshots;
@@ -7931,10 +7931,10 @@ function updateAssetStatus(url, status) {
     window.__orbitalVerification.assetStatus[url] = status;
   }
 }
-var log3, MAX_TRANSITIONS;
+var log4, MAX_TRANSITIONS;
 var init_verificationRegistry = __esm({
   "lib/verificationRegistry.ts"() {
-    log3 = logger.createLogger("almadar:bridge");
+    log4 = logger.createLogger("almadar:bridge");
     MAX_TRANSITIONS = 500;
     exposeOnWindow();
   }
@@ -17542,7 +17542,7 @@ var init_avl_elk_layout = __esm({
     elk = new ELK__default.default();
   }
 });
-var log4, SWIM_GUTTER, CENTER_W, BehaviorView;
+var log5, SWIM_GUTTER, CENTER_W, BehaviorView;
 var init_BehaviorView = __esm({
   "components/avl/molecules/BehaviorView.tsx"() {
     "use client";
@@ -17551,7 +17551,7 @@ var init_BehaviorView = __esm({
     init_AvlSwimLane();
     init_avl_atom_types();
     init_avl_elk_layout();
-    log4 = logger.createLogger("almadar:ui:avl:behavior-view");
+    log5 = logger.createLogger("almadar:ui:avl:behavior-view");
     SWIM_GUTTER = 120;
     CENTER_W = 360;
     BehaviorView = ({ data }) => {
@@ -17562,7 +17562,7 @@ var init_BehaviorView = __esm({
       const dataKey = React96.useMemo(() => JSON.stringify(traitData), [traitData]);
       React96.useEffect(() => {
         if (!traitData) return;
-        computeTraitLayout(traitData).then(setLayout).catch((err) => log4.error("compute-trait-layout-failed", { error: err instanceof Error ? err : String(err) }));
+        computeTraitLayout(traitData).then(setLayout).catch((err) => log5.error("compute-trait-layout-failed", { error: err instanceof Error ? err : String(err) }));
       }, [dataKey]);
       if (!traitData) {
         return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-lg border border-[var(--color-border)] bg-[var(--color-card)] p-4 text-center text-[var(--color-muted-foreground)] text-sm", children: t("avl.noTraitData") });
@@ -18114,7 +18114,7 @@ function generateDiff(oldVal, newVal) {
   }
   return diff;
 }
-var orbStyleOverrides, orbStyle, loloStyleOverrides, loloStyle, log5, CODE_LANGUAGES, CODE_LANGUAGE_SET, DIFF_STYLES, DIFF_STYLE_FALLBACK, LINE_PROPS_FN, HIDDEN_LINE_NUMBERS, CodeBlock;
+var orbStyleOverrides, orbStyle, loloStyleOverrides, loloStyle, log6, CODE_LANGUAGES, CODE_LANGUAGE_SET, DIFF_STYLES, DIFF_STYLE_FALLBACK, LINE_PROPS_FN, HIDDEN_LINE_NUMBERS, CodeBlock;
 var init_CodeBlock = __esm({
   "components/core/molecules/markdown/CodeBlock.tsx"() {
     init_cn();
@@ -18197,7 +18197,7 @@ var init_CodeBlock = __esm({
       "lolo-op-async": { color: syntax.ORB_COLORS.dark.async }
     };
     loloStyle = { ...dark__default.default, ...loloStyleOverrides };
-    log5 = logger.createLogger("almadar:ui:markdown-code");
+    log6 = logger.createLogger("almadar:ui:markdown-code");
     CODE_LANGUAGES = [
       "text",
       "json",
@@ -18465,7 +18465,7 @@ var init_CodeBlock = __esm({
             eventBus.emit("UI:COPY_CODE", { language: activeLanguage, success: true });
             setTimeout(() => setCopied(false), 2e3);
           } catch (err) {
-            log5.error("Failed to copy code", { error: err instanceof Error ? err : String(err) });
+            log6.error("Failed to copy code", { error: err instanceof Error ? err : String(err) });
             eventBus.emit("UI:COPY_CODE", { language: activeLanguage, success: false });
           }
         };
@@ -27330,14 +27330,14 @@ function useSafeEventBus3() {
     } };
   }
 }
-var log6, lookStyles5, ButtonGroup;
+var log7, lookStyles5, ButtonGroup;
 var init_ButtonGroup = __esm({
   "components/core/molecules/ButtonGroup.tsx"() {
     "use client";
     init_cn();
     init_atoms();
     init_useEventBus();
-    log6 = logger.createLogger("almadar:ui:button-group");
+    log7 = logger.createLogger("almadar:ui:button-group");
     lookStyles5 = {
       "right-aligned-buttons": "",
       "floating-bar": "fixed bottom-section left-1/2 -translate-x-1/2 shadow-elevation-toast bg-card p-card-sm rounded-container",
@@ -27418,7 +27418,7 @@ var init_ButtonGroup = __esm({
           {
             variant: "ghost",
             onClick: () => {
-              log6.debug("Filter clicked", { field: filter.field });
+              log7.debug("Filter clicked", { field: filter.field });
             },
             children: filter.label
           },
@@ -28327,9 +28327,9 @@ function debug(...args) {
   const [first, ...rest] = args;
   const message = typeof first === "string" ? first : "<debug>";
   if (rest.length === 0 && typeof first === "string") {
-    log7.debug(message);
+    log8.debug(message);
   } else {
-    log7.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
+    log8.debug(message, { args: rest.length > 0 ? formatArgs(rest) : formatArgs([first]) });
   }
 }
 function debugGroup(label) {
@@ -28357,11 +28357,11 @@ function toLogMetaValue(v) {
   }
   return String(v);
 }
-var NAMESPACE, log7;
+var NAMESPACE, log8;
 var init_debug = __esm({
   "lib/debug.ts"() {
     NAMESPACE = "almadar:ui:debug";
-    log7 = logger.createLogger(NAMESPACE);
+    log8 = logger.createLogger(NAMESPACE);
     logger.createLogger("almadar:ui:debug:input");
     logger.createLogger("almadar:ui:debug:collision");
     logger.createLogger("almadar:ui:debug:physics");
@@ -30519,12 +30519,12 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect67, useRef: useRef65, useCallback: useCallback98, useState: useState97 } = React96__namespace.default;
+      const { useEffect: useEffect67, useRef: useRef66, useCallback: useCallback98, useState: useState97 } = React96__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 = useRef65({ centerLat, centerLng, zoom });
+        const prevRef = useRef66({ centerLat, centerLng, zoom });
         useEffect67(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
@@ -43786,7 +43786,7 @@ function getAllEvents(traits2) {
 function EventDispatcherTab({ traits: traits2, schema }) {
   const eventBus = useEventBus();
   const { t } = hooks.useTranslate();
-  const [log9, setLog] = React96__namespace.useState([]);
+  const [log10, setLog] = React96__namespace.useState([]);
   const prevStatesRef = React96__namespace.useRef(/* @__PURE__ */ new Map());
   React96__namespace.useEffect(() => {
     for (const trait of traits2) {
@@ -43850,9 +43850,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)) })
     ] }),
-    log9.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+    log10.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: log9.map((entry, i) => /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "small", className: "font-mono text-xs", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(Stack, { gap: "xs", children: log10.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 }),
@@ -47562,7 +47562,67 @@ var init_UISlotRenderer = __esm({
 
 // hooks/index.ts
 init_useEventBus();
-var log2 = logger.createLogger("almadar:ui:effects:client-handlers");
+var log2 = logger.createLogger("almadar:ui:shared-entity-store");
+var EMPTY_ENTITY_STATE = {};
+function createSharedEntityStore() {
+  const states = /* @__PURE__ */ new Map();
+  const subscribers2 = /* @__PURE__ */ new Map();
+  const getSnapshot3 = (entityId) => states.get(entityId) ?? EMPTY_ENTITY_STATE;
+  const subscribe2 = (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) {
+        log2.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: getSnapshot3, subscribe: subscribe2, commit, seed };
+}
+function useSharedEntityStore() {
+  const storeRef = React96.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 log3 = logger.createLogger("almadar:ui:effects:client-handlers");
 function createClientEffectHandlers(options) {
   const { eventBus, slotSetter, navigate, notify, callService, liveEntity } = options;
   return {
@@ -47571,12 +47631,12 @@ function createClientEffectHandlers(options) {
       eventBus.emit(prefixedEvent, payload);
     },
     persist: async () => {
-      log2.warn("persist is server-side only, ignored on client");
+      log3.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) {
-        log2.warn("set is server-side only, ignored on client (no live entity)");
+        log3.warn("set is server-side only, ignored on client (no live entity)");
         return;
       }
       liveEntity[field] = value;
@@ -47608,10 +47668,10 @@ function createClientEffectHandlers(options) {
       slotSetter.addPattern(slot, pattern, props);
     },
     navigate: navigate ?? ((path) => {
-      log2.warn("No navigate handler, ignoring", { path });
+      log3.warn("No navigate handler, ignoring", { path });
     }),
     notify: notify ?? ((msg, type) => {
-      log2.debug("notify", { type, message: msg });
+      log3.debug("notify", { type, message: msg });
     })
   };
 }
@@ -47782,11 +47842,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 = React96.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 = React96.useRef(/* @__PURE__ */ new Map());
+  React96.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 = React96.useMemo(() => {
     const traitDefs = traitBindings.map(toTraitDefinition);
     const m = new runtime.StateMachineManager(traitDefs);
@@ -47969,14 +48119,21 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     };
   }, [traitBindings]);
   const executeTransitionEffects = React96.useCallback(async (params) => {
-    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log9 } = params;
+    const { binding, previousState, newState, payload, flushEvent, syncOnly, log: log10 } = 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]))
@@ -48058,7 +48215,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       ...handlers,
       set: async (targetId, field, value) => {
         if (baseSet) await baseSet(targetId, field, value);
-        log9.debug("set:write", {
+        log10.debug("set:write", {
           traitName,
           field,
           value: JSON.stringify(value),
@@ -48098,17 +48255,20 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     const executor = new runtime.EffectExecutor({ handlers: trackingHandlers, bindings: bindingCtx, context: effectContext });
     try {
       await executor.executeAll(effects);
-      log9.debug("effects:executed", () => ({
+      if (sharedKey !== void 0) {
+        sharedEntityStore.commit(sharedKey, liveEntity);
+      }
+      log10.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) {
-        log9.debug("flush:slot", {
+        log10.debug("flush:slot", {
           traitName,
           slot,
           patternCount: patterns.length,
@@ -48123,7 +48283,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         });
       }
     } catch (error) {
-      log9.error("effects:error", {
+      log10.error("effects:error", {
         traitName,
         transition: `${previousState}->${newState}`,
         event: flushEvent,
@@ -48132,14 +48292,16 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       });
     }
     return emittedDuringExec;
-  }, [eventBus, flushSlot]);
+  }, [eventBus, flushSlot, sharedEntityStore]);
   const runTickEffects = React96.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
       };
@@ -48164,10 +48326,46 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       syncOnly: true,
       log: tickLog
     });
-  }, [executeTransitionEffects]);
+  }, [executeTransitionEffects, sharedEntityStore]);
+  const emitFromSharedWriter = React96.useCallback((event, payload) => {
+    const prefixedEvent = event.startsWith("UI:") ? event : `UI:${event}`;
+    eventBus.emit(prefixedEvent, payload);
+  }, [eventBus]);
   React96.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));
@@ -48181,7 +48379,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       }
     }
     return () => scheduler.stopAll();
-  }, [traitBindings, runTickEffects]);
+  }, [traitBindings, runTickEffects, sharedGroups, sharedEntityStore, emitFromSharedWriter]);
   const processEventQueued = React96.useCallback(async (eventKey, payload) => {
     const normalizedEvent = normalizeEventKey(eventKey);
     const bindings = traitBindingsRef.current;
@@ -48701,7 +48899,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;
@@ -48756,7 +48954,7 @@ function perfEnd(name, startToken, detail) {
     }
   }
   push({ name, durationMs, ts: endTs, detail });
-  log8.debug(name, () => ({ durationMs, ...detail ?? {} }));
+  log9.debug(name, () => ({ durationMs, ...detail ?? {} }));
 }
 function perfTime(name, fn, detail) {
   const t = perfStart(name);
@@ -48774,7 +48972,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 }));
 };
 function getPerfSnapshot() {
   if (ring.length < RING_SIZE) return ring.slice();