@almadar/ui 6.51.2 → 6.53.0

package/dist/{chunk-T7IH5ABO.js → chunk-IKULQIDX.js}

@@ -1,17 +1,18 @@
 import { runTickFrame } from './chunk-DQTV6QVS.js';
-import { ALL_SLOTS } from './chunk-6CFYRP4S.js';
-import { UISlotRenderer } from './chunk-GIPZSCND.js';
-import { Box } from './chunk-BUEIZY54.js';
-import { Typography } from './chunk-MWPX2O4M.js';
+import { ALL_SLOTS } from './chunk-VHTJRS2N.js';
+import { UISlotRenderer } from './chunk-3EF5SDIJ.js';
+import { Box } from './chunk-7LM6I3NA.js';
+import { Typography } from './chunk-GMDMOYXD.js';
+import { beginPending, endPending } from './chunk-JRW33U35.js';
 import { useEventBus } from './chunk-6EV3OEBQ.js';
-import { registerTrait, unregisterTrait, perfTimeAsync } from './chunk-OLZ3EEML.js';
+import { registerTrait, unregisterTrait, perfTimeAsync } from './chunk-KQXXO42S.js';
 import { bindTraitStateGetter, registerTraitSnapshot, recordTransition, recordingTransport, recordServerResponse } from './chunk-O7OLVVBR.js';
-import { isNotificationSlot } from './chunk-YHY5K2Y7.js';
+import { isNotificationSlot } from './chunk-PEST66PN.js';
 import React, { useState, useMemo, useEffect, useRef, useCallback, useSyncExternalStore } from 'react';
 import { schemaToIR, getPage, clearSchemaCache as clearSchemaCache$1, applyListenPayloadMapping, buildResolvedTraitConfigs, collectCallsiteCaptureChildren, walkSExpr, isRenderBindingMarker, containsEntityBinding, isSExpr, isEventPayloadValue, RENDER_BINDING_MARKER } from '@almadar/core';
 import { createLogger } from '@almadar/logger';
-import { LIFECYCLE_EVENTS, InMemoryPersistence, createInProcessTransport, buildTraitIndex, createMemoryCircuitStore, createIndexStageRunner, evaluateOrbitalEvent, createClientKernel, collectListenerTargets, createTickScheduler, isValidCronExpression, parseDurationString, UNMOUNT_EVENT, createClientEffectHandlers, EffectExecutor, isSExpression, collectDeclaredConfigDefaults, createContextFromBindings, normalizeCallSiteConfigToValues } from '@almadar/runtime';
-import { useUser, useArbitraryClassStyles, getAllPages, matchPathAmong, CurrentPagePathProvider, NavStackProvider, OrbitalProvider, useNavStack, VerificationProvider, EntitySchemaProvider, OrbitalThemeProvider, ServerBridgeProvider, useServerBridge, EntityBindingContext } from '@almadar/ui/providers';
+import { collectListenerTargets, LIFECYCLE_EVENTS, InMemoryPersistence, createInProcessTransport, buildTraitIndex, createMemoryCircuitStore, createIndexStageRunner, evaluateOrbitalEvent, createClientKernel, createTickScheduler, isValidCronExpression, parseDurationString, UNMOUNT_EVENT, createClientEffectHandlers, EffectExecutor, isSExpression, collectDeclaredConfigDefaults, createContextFromBindings, normalizeCallSiteConfigToValues } from '@almadar/runtime';
+import { useUser, useArbitraryClassStyles, getAllPages, matchPathAmong, CurrentPagePathProvider, NavStackProvider, OrbitalProvider, useNavStack, VerificationProvider, EntitySchemaProvider, OrbitalThemeProvider, ServerBridgeProvider, useServerBridge, EntityBindingContext, AwaitingSkeletonContext } from '@almadar/ui/providers';
 import { evaluateListenPayloadExpr, evaluate, createMinimalContext, evaluateGuard, executeEffects } from '@almadar/evaluator';
 import { getPatternDefinition } from '@almadar/core/patterns';
 import { isKnownStdOperator } from '@almadar/std/registry';
@@ -269,6 +270,18 @@ function useCircuitKernel(traitBindings, options) {
     [baseTransport]
   );
   const orbitalName = options.orbitals[0]?.name ?? "";
+  const topology = useMemo(() => {
+    let resolve = () => void 0;
+    const promise = new Promise((r) => {
+      resolve = r;
+    });
+    return { promise, resolve };
+  }, [effectiveTransport]);
+  const awaitTopology = options.awaitTopology === true;
+  const confirmedCarries = options.carriesCircuitState ?? false;
+  useEffect(() => {
+    if (!awaitTopology) topology.resolve({ carriesCircuitState: confirmedCarries });
+  }, [awaitTopology, confirmedCarries, topology]);
   const rawKernel = useMemo(() => createClientKernel({
     orbitalName,
     traitIndex,
@@ -281,7 +294,8 @@ function useCircuitKernel(traitBindings, options) {
     ...options.contextExtensions !== void 0 ? { contextExtensions: options.contextExtensions } : {},
     ...options.debug !== void 0 ? { debug: options.debug } : {},
     ...options.logContext !== void 0 ? { logContext: options.logContext } : {},
-    carriesCircuitState: options.carriesCircuitState ?? false,
+    carriesCircuitState: false,
+    topology: topology.promise,
     ...effectiveTransport !== void 0 ? { transport: effectiveTransport } : {}
   }), [
     orbitalName,
@@ -295,50 +309,16 @@ function useCircuitKernel(traitBindings, options) {
     options.contextExtensions,
     options.debug,
     options.logContext,
-    options.carriesCircuitState,
+    topology,
     effectiveTransport
   ]);
-  const rawKernelRef = useRef(rawKernel);
-  rawKernelRef.current = rawKernel;
-  const awaitTopology = options.awaitTopology === true;
-  const holdRef = useRef(awaitTopology);
-  holdRef.current = awaitTopology;
-  const heldRef = useRef([]);
-  useEffect(() => {
-    if (awaitTopology) return;
-    const held = heldRef.current;
-    heldRef.current = [];
-    for (const release of held) release();
-  }, [awaitTopology, rawKernel]);
   const kernel = useMemo(() => ({
     store: rawKernel.store,
-    dispatch: (request) => {
-      const stamped = request.clientId !== void 0 ? request : { ...request, clientId: getTabClientId() };
-      if (!holdRef.current) return rawKernel.dispatch(stamped);
-      return new Promise((resolve, reject) => {
-        heldRef.current.push(() => {
-          rawKernelRef.current.dispatch(stamped).then(resolve, reject);
-        });
-      });
-    }
+    dispatch: (request, hooks) => rawKernel.dispatch(request.clientId !== void 0 ? request : { ...request, clientId: getTabClientId() }, hooks),
+    dispatchMount: (seeds, hooks, base = {}) => rawKernel.dispatchMount(seeds, hooks, base.clientId !== void 0 ? base : { ...base, clientId: getTabClientId() }),
+    dispatchProgress: (request) => rawKernel.dispatchProgress(request.clientId !== void 0 ? request : { ...request, clientId: getTabClientId() })
   }), [rawKernel]);
-  const kernelRef = useRef(kernel);
-  kernelRef.current = kernel;
-  useEffect(() => {
-    if (!effectiveTransport?.subscribe) return;
-    return effectiveTransport.subscribe((emitted) => {
-      const targets = collectListenerTargets(traitIndex, emitted.source, emitted.event, emitted.payload);
-      for (const target of targets) {
-        void kernelRef.current.dispatch({
-          event: target.triggers,
-          ...target.payload !== void 0 ? { payload: target.payload } : {},
-          ...target.entityId !== void 0 ? { entityId: target.entityId } : {},
-          targetTrait: target.listenerTrait
-        });
-      }
-    }, { clientId: getTabClientId() });
-  }, [effectiveTransport, traitIndex]);
-  return { kernel, store, traitIndex };
+  return { kernel, store, traitIndex, transport: effectiveTransport };
 }
 var log2 = createLogger("almadar:ui:circuit:bus-ingress");
 function useBusIngress(traitBindings, traitIndex, settle, eventBus) {
@@ -363,8 +343,12 @@ function useBusIngress(traitBindings, traitIndex, settle, eventBus) {
     const dispatch = (traitName, eventKey, payload, source) => {
       if (!claim(source, traitName, eventKey)) return;
       const tick = source?.tick;
+      const pendingKey = source?.pendingKey;
+      if (pendingKey !== void 0) beginPending(pendingKey);
       void settle(traitName, eventKey, payload, tick).catch((err) => {
         log2.error("dispatch:failed", { trait: traitName, event: eventKey, error: String(err) });
+      }).finally(() => {
+        if (pendingKey !== void 0) endPending(pendingKey);
       });
     };
     for (const binding of traitBindings) {
@@ -514,7 +498,7 @@ function resolveLambdaBindings(body, params, item, index) {
   return body;
 }
 var LazySlotContentRenderer = React.lazy(
-  () => import('./UISlotRenderer-7UYHFW4S.js').then((m) => ({ default: m.SlotContentRenderer }))
+  () => import('./UISlotRenderer-JT34I3O7.js').then((m) => ({ default: m.SlotContentRenderer }))
 );
 function deferLambdaEntityExprs(value) {
   if (typeof value === "string") {
@@ -638,12 +622,15 @@ function useSlotFlush(uiSlots, embeddedTraits) {
   uiSlotsRef.current = uiSlots;
   const embeddedTraitsRef = useRef(embeddedTraits);
   embeddedTraitsRef.current = embeddedTraits;
+  const writtenRef = useRef(/* @__PURE__ */ new Map());
+  const keyOf = (slot, trait) => `${slot}\0${trait}`;
   const flushSlot = useCallback((traitName, slot, patterns, source) => {
     const slots = uiSlotsRef.current;
     const embedded = embeddedTraitsRef.current;
     if (patterns.length === 0) {
       flushLog.debug("clear", { traitName, slot });
       slots.clearBySource(slot, traitName);
+      writtenRef.current.set(keyOf(slot, traitName), { kind: "clear", slot, trait: traitName });
       return;
     }
     const last = patterns[patterns.length - 1];
@@ -652,19 +639,20 @@ function useSlotFlush(uiSlots, embeddedTraits) {
     const props = convertFnFormLambdasInProps(rawProps, typeof patternType === "string" ? patternType : void 0);
     const isEmbedded = (embedded?.has(traitName) ?? false) && !isNotificationSlot(slot);
     if (isEmbedded) {
-      slots.updateTraitContent(traitName, {
+      const content = {
         pattern: patternType,
         props,
         slot,
         priority: 0,
-        animation: "fade",
         transitionEvent: source?.event,
         fromState: source?.state,
         entity: source?.entity
-      });
+      };
+      slots.updateTraitContent(traitName, content);
+      writtenRef.current.set(keyOf(slot, traitName), { kind: "trait", trait: traitName, content });
       return;
     }
-    slots.render({
+    const config = {
       target: slot,
       pattern: patternType,
       props,
@@ -672,7 +660,9 @@ function useSlotFlush(uiSlots, embeddedTraits) {
       transitionEvent: source?.event,
       fromState: source?.state,
       entity: source?.entity
-    });
+    };
+    slots.render(config);
+    writtenRef.current.set(keyOf(slot, traitName), { kind: "render", config });
   }, []);
   const applyClientEffects = useCallback((clientEffects, clientEffectsByTrait, onNavigate, onNavigateBack, activeTraits) => {
     const slots = uiSlotsRef.current;
@@ -687,13 +677,18 @@ function useSlotFlush(uiSlots, embeddedTraits) {
         const { bareTraitRef, patternType, props: unwrapped } = unwrapPattern(pattern);
         const isEmbedded = (embedded?.has(sourceTrait) ?? false) && !isNotificationSlot(slot);
         const propsValue = bareTraitRef !== void 0 ? bareTraitRef : { ...unwrapped ?? {}, ...rawProps };
-        const props = convertFnFormLambdasInProps(propsValue);
+        const props = convertFnFormLambdasInProps(propsValue, typeof patternType === "string" ? patternType : void 0);
         if (pattern === null) {
           slots.clearBySource(slot, sourceTrait);
+          writtenRef.current.set(keyOf(slot, sourceTrait), { kind: "clear", slot, trait: sourceTrait });
         } else if (isEmbedded) {
-          slots.updateTraitContent(sourceTrait, { pattern: patternType, props, slot, priority: 0, animation: "fade", transitionEvent: event, fromState });
+          const content = { pattern: patternType, props, slot, priority: 0, transitionEvent: event, fromState };
+          slots.updateTraitContent(sourceTrait, content);
+          writtenRef.current.set(keyOf(slot, sourceTrait), { kind: "trait", trait: sourceTrait, content });
         } else {
-          slots.render({ target: slot, pattern: patternType, props, sourceTrait, transitionEvent: event, fromState });
+          const config = { target: slot, pattern: patternType, props, sourceTrait, transitionEvent: event, fromState };
+          slots.render(config);
+          writtenRef.current.set(keyOf(slot, sourceTrait), { kind: "render", config });
         }
       } else if (kind === "navigate") {
         const [, route, params, options] = effect;
@@ -703,7 +698,26 @@ function useSlotFlush(uiSlots, embeddedTraits) {
       }
     }
   }, []);
-  return useMemo(() => ({ flushSlot, applyClientEffects }), [flushSlot, applyClientEffects]);
+  const checkpoint = useCallback(() => new Map(writtenRef.current), []);
+  const rollback = useCallback((cp) => {
+    const slots = uiSlotsRef.current;
+    for (const [key, now] of writtenRef.current) {
+      const then = cp.get(key);
+      if (then === now) continue;
+      if (then === void 0 || then.kind === "clear") {
+        if (now.kind === "render") slots.clearBySource(now.config.target, now.config.sourceTrait ?? "kernel");
+        else if (now.kind === "trait") {
+          flushLog.warn("rollback:embedded-frame-kept", { trait: now.trait });
+        }
+      } else if (then.kind === "render") {
+        slots.render(then.config);
+      } else {
+        slots.updateTraitContent(then.trait, then.content);
+      }
+    }
+    writtenRef.current = new Map(cp);
+  }, []);
+  return useMemo(() => ({ flushSlot, applyClientEffects, checkpoint, rollback }), [flushSlot, applyClientEffects, checkpoint, rollback]);
 }
 var log3 = createLogger("almadar:ui:circuit:effect-runner");
 async function runCircuitEffects(params) {
@@ -1096,6 +1110,25 @@ function sameFields(a, b) {
   }
   return true;
 }
+function useAwaitingSkeletonSource(store, traitIndex, embeddedTraits) {
+  return useMemo(() => {
+    const activeRenders = () => {
+      const renders = [];
+      for (const awaiting of store.awaiting.list()) {
+        const transitions = traitIndex.byName.get(awaiting.trait)?.irTrait.stateMachine?.transitions ?? [];
+        const taken = transitions.find((t) => t.event === awaiting.event && t.from === awaiting.from);
+        if (taken?.awaitRender) renders.push(...taken.awaitRender);
+      }
+      return renders;
+    };
+    return {
+      forSlot: (slot) => activeRenders().find((r) => r.slot === slot && !(embeddedTraits?.has(r.trait) ?? false))?.skeleton,
+      forTrait: (traitName) => activeRenders().find((r) => r.trait === traitName)?.skeleton,
+      subscribe: (callback) => store.awaiting.subscribeAll(callback),
+      getVersion: () => store.awaiting.getVersion()
+    };
+  }, [store, traitIndex, embeddedTraits]);
+}
 
 // hooks/useTraitStateMachine.ts
 var stateLog = createLogger("almadar:ui:state-transitions");
@@ -1114,7 +1147,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
   const { user: contextViewer } = useUser();
   const userContext = options.user ?? contextViewer ?? void 0;
   const observer = useMemo(() => createCircuitVerificationObserver(), []);
-  const { kernel, store, traitIndex } = useCircuitKernel(traitBindings, {
+  const { kernel, store, traitIndex, transport } = useCircuitKernel(traitBindings, {
     orbitals: options.orbitals,
     ...options.traitConfigsByName !== void 0 ? { traitConfigsByName: options.traitConfigsByName } : {},
     ...options.transport !== void 0 ? { transport: options.transport } : {},
@@ -1144,6 +1177,7 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
     ...userContext !== void 0 ? { user: userContext } : {}
   });
   const entityBindingSource = useEntityBindingSource(store, traitIndex);
+  const awaitingSkeletonSource = useAwaitingSkeletonSource(store, traitIndex, options.embeddedTraits);
   const activeTraitNamesRef = useRef(/* @__PURE__ */ new Set());
   useEffect(() => {
     activeTraitNamesRef.current = new Set(traitIndex.byName.keys());
@@ -1191,11 +1225,41 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       for (const unreg of snapshotUnregs) unreg();
     };
   }, [traitBindings, store, traitIndex]);
+  const afterSettle = useCallback(async (traitName, eventKey, payload, transitioned, repaints, composedBefore) => {
+    if (transitioned) {
+      const entityByTrait = {};
+      for (const [name, entry] of traitIndex.byName) {
+        const row = store.frames.get(entry.frameKey);
+        if (row !== void 0) entityByTrait[name] = row;
+      }
+      const repainted = new Set(repaints.map((e) => e.traitName));
+      const serverComposed = new Set([...store.callsitePayloads].filter(([child, composed]) => composedBefore.get(child) !== composed).map(([child]) => child));
+      await reRenderCallsiteCaptureChildren(traitName, payload ?? {}, entityByTrait, repainted, serverComposed);
+    }
+    options.onEventProcessed?.(eventKey, payload);
+  }, [traitIndex, store, reRenderCallsiteCaptureChildren, options.onEventProcessed]);
+  const settleOutcome = useCallback(async (traitName, eventKey, payload, outcome, composedBefore) => {
+    recordDispatchVerdict(traitIndex.byName.get(traitName)?.orbitalName ?? traitName, eventKey, { response: outcome.response });
+    const settledEffects = outcome.localPainted && outcome.serverEffects !== void 0 ? outcome.serverEffects : outcome.response;
+    slotFlush.applyClientEffects(
+      settledEffects.clientEffects ?? [],
+      settledEffects.clientEffectsByTrait,
+      options.navigate,
+      options.navigateBack,
+      activeTraitNamesRef.current
+    );
+    for (const emitted of outcome.response.emittedEvents) {
+      eventBus.emit(`UI:${emitted.event}`, emitted.payload, { ...emitted.source ?? {}, dispatched: true });
+    }
+    stateLog.debug("dispatch:settled", { traitName, eventKey, mode: outcome.mode, transitioned: outcome.response.transitioned });
+    await afterSettle(traitName, eventKey, payload, outcome.response.transitioned, outcome.response.clientEffectsByTrait ?? [], composedBefore);
+  }, [slotFlush, traitIndex, eventBus, options.navigate, options.navigateBack, afterSettle]);
   const dispatchAndSettle = useCallback(async (traitName, eventKey, payload, tick) => {
     const entityId = typeof payload?.entityId === "string" ? payload.entityId : void 0;
     const orbitalName = traitIndex.byName.get(traitName)?.orbitalName ?? traitName;
     let outcome;
     const composedBefore = new Map(store.callsitePayloads);
+    let beforeLocalPaint;
     try {
       outcome = await kernel.dispatch({
         event: eventKey,
@@ -1203,35 +1267,80 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
         ...entityId !== void 0 ? { entityId } : {},
         ...tick !== void 0 ? { tick } : {},
         targetTrait: traitName
+      }, {
+        onLocal: (local) => {
+          beforeLocalPaint = slotFlush.checkpoint();
+          slotFlush.applyClientEffects(
+            local.clientEffects ?? [],
+            local.clientEffectsByTrait,
+            options.navigate,
+            options.navigateBack,
+            activeTraitNamesRef.current
+          );
+        }
       });
     } catch (err) {
+      if (beforeLocalPaint !== void 0) slotFlush.rollback(beforeLocalPaint);
       recordDispatchVerdict(orbitalName, eventKey, { error: err instanceof Error ? err : String(err) });
       throw err;
     }
-    recordDispatchVerdict(orbitalName, eventKey, { response: outcome.response });
-    slotFlush.applyClientEffects(
-      outcome.response.clientEffects ?? [],
-      outcome.response.clientEffectsByTrait,
-      options.navigate,
-      options.navigateBack,
-      activeTraitNamesRef.current
-    );
-    for (const emitted of outcome.response.emittedEvents) {
-      eventBus.emit(`UI:${emitted.event}`, emitted.payload, { ...emitted.source ?? {}, dispatched: true });
+    if (outcome.localPainted && !outcome.response.success && beforeLocalPaint !== void 0) {
+      slotFlush.rollback(beforeLocalPaint);
     }
-    stateLog.debug("dispatch:settled", { traitName, eventKey, mode: outcome.mode, transitioned: outcome.response.transitioned });
-    if (outcome.response.transitioned) {
-      const entityByTrait = {};
-      for (const [name, entry] of traitIndex.byName) {
-        const row = store.frames.get(entry.frameKey);
-        if (row !== void 0) entityByTrait[name] = row;
+    await settleOutcome(traitName, eventKey, payload, outcome, composedBefore);
+  }, [kernel, slotFlush, traitIndex, store, options.navigate, options.navigateBack, settleOutcome]);
+  const progressAndSettle = useCallback(async (traitName, eventKey, payload) => {
+    const entityId = typeof payload?.entityId === "string" ? payload.entityId : void 0;
+    const composedBefore = new Map(store.callsitePayloads);
+    const outcome = await kernel.dispatchProgress({
+      event: eventKey,
+      ...payload !== void 0 ? { payload } : {},
+      ...entityId !== void 0 ? { entityId } : {},
+      targetTrait: traitName
+    });
+    await settleOutcome(traitName, eventKey, payload, outcome, composedBefore);
+  }, [kernel, store, settleOutcome]);
+  useEffect(() => {
+    if (!transport?.subscribe) return;
+    return transport.subscribe((emitted, target) => {
+      for (const t of collectListenerTargets(traitIndex, emitted.source, emitted.event, emitted.payload)) {
+        void (target === "origin" ? progressAndSettle(t.listenerTrait, t.triggers, t.payload) : dispatchAndSettle(t.listenerTrait, t.triggers, t.payload));
       }
-      const repainted = new Set((outcome.response.clientEffectsByTrait ?? []).map((e) => e.traitName));
-      const serverComposed = new Set([...store.callsitePayloads].filter(([child, composed]) => composedBefore.get(child) !== composed).map(([child]) => child));
-      await reRenderCallsiteCaptureChildren(traitName, payload ?? {}, entityByTrait, repainted, serverComposed);
+    }, { clientId: getTabClientId() });
+  }, [transport, traitIndex, progressAndSettle, dispatchAndSettle]);
+  const mountAndSettle = useCallback(async (seeds, payload) => {
+    const composedBefore = new Map(store.callsitePayloads);
+    let beforeLocalPaint;
+    let outcome;
+    try {
+      outcome = await kernel.dispatchMount(seeds, {
+        onLocal: (_trait, local) => {
+          if (beforeLocalPaint === void 0) beforeLocalPaint = slotFlush.checkpoint();
+          slotFlush.applyClientEffects(local.clientEffects ?? [], local.clientEffectsByTrait, options.navigate, options.navigateBack, activeTraitNamesRef.current);
+        }
+      }, { payload });
+    } catch (err) {
+      if (beforeLocalPaint !== void 0) slotFlush.rollback(beforeLocalPaint);
+      for (const seed of seeds) {
+        recordDispatchVerdict(traitIndex.byName.get(seed.trait)?.orbitalName ?? seed.trait, seed.event, { error: err instanceof Error ? err : String(err) });
+      }
+      throw err;
     }
-    options.onEventProcessed?.(eventKey, payload);
-  }, [kernel, slotFlush, traitIndex, store, eventBus, reRenderCallsiteCaptureChildren, options.navigate, options.navigateBack, options.onEventProcessed]);
+    if (!outcome.success && beforeLocalPaint !== void 0) slotFlush.rollback(beforeLocalPaint);
+    slotFlush.applyClientEffects(outcome.serverEffects.clientEffects ?? [], outcome.serverEffects.clientEffectsByTrait, options.navigate, options.navigateBack, activeTraitNamesRef.current);
+    const emitted = [...outcome.seeds.flatMap((seed) => seed.local.emittedEvents), ...outcome.emittedEvents];
+    for (const e of emitted) {
+      eventBus.emit(`UI:${e.event}`, e.payload, { ...e.source ?? {}, dispatched: true });
+    }
+    const serverRepaints = outcome.serverEffects.clientEffectsByTrait ?? [];
+    for (const seed of outcome.seeds) {
+      recordDispatchVerdict(traitIndex.byName.get(seed.trait)?.orbitalName ?? seed.trait, seed.event, {
+        response: { ...seed.local, success: outcome.success, ...outcome.error !== void 0 ? { error: outcome.error } : {} }
+      });
+      stateLog.debug("mount:settled", { traitName: seed.trait, eventKey: seed.event, mode: seed.mode, transitioned: seed.local.transitioned });
+      await afterSettle(seed.trait, seed.event, payload, seed.local.transitioned, [...seed.local.clientEffectsByTrait ?? [], ...serverRepaints], composedBefore);
+    }
+  }, [kernel, slotFlush, traitIndex, store, eventBus, options.navigate, options.navigateBack, afterSettle]);
   useBusIngress(traitBindings, traitIndex, dispatchAndSettle, eventBus);
   const sendEvent = useCallback((eventKey, payload) => {
     const normalized = normalizeEventKey(eventKey);
@@ -1272,17 +1381,19 @@ function useTraitStateMachine(traitBindings, uiSlots, options) {
       if (mount.initialized.has(traitName)) continue;
       mount.initialized.add(traitName);
       const lifecycleEvent = LIFECYCLE_EVENTS.find((evt) => store.manager.canHandleEvent(traitName, evt));
-      if (lifecycleEvent !== void 0) entering.push({ traitName, lifecycleEvent });
+      if (lifecycleEvent !== void 0) entering.push({ trait: traitName, event: lifecycleEvent });
     }
-    store.mount.mounting(entering.map((e) => e.traitName));
-    for (const { traitName, lifecycleEvent } of entering) {
-      void dispatchAndSettle(traitName, lifecycleEvent, { ...options.initPayload ?? {} });
+    store.mount.mounting(entering.map((e) => e.trait));
+    if (entering.length > 0) {
+      void mountAndSettle(entering, { ...options.initPayload ?? {} }).catch((err) => {
+        stateLog.warn("mount:failed", { traits: entering.map((e) => e.trait), error: String(err) });
+      });
     }
     mountedRef.current = mount;
-  }, [traitBindings, store, dispatchAndSettle, mountKey]);
+  }, [traitBindings, store, mountAndSettle, mountKey]);
   useSyncExternalStore(store.subscribe, store.getVersion, store.getVersion);
   const traitStates = useMemo(() => store.manager.getAllStates(), [store, store.getVersion()]);
-  return { traitStates, sendEvent, getTraitState, canHandleEvent, entityBindingSource };
+  return { traitStates, sendEvent, getTraitState, canHandleEvent, entityBindingSource, awaitingSkeletonSource };
 }
 
 // runtime/fitContent.ts
@@ -1353,7 +1464,7 @@ function TraitInitializer({ traits, routeParams, mountKey, orbitals, onNavigate,
     }, localFallbackTimeoutMs ?? 5e3);
     return () => clearTimeout(timer);
   }, [hasBridge, bridge.connected, onLocalFallback, localFallbackTimeoutMs]);
-  const { entityBindingSource } = useTraitStateMachine(traits, uiSlots, {
+  const { entityBindingSource, awaitingSkeletonSource } = useTraitStateMachine(traits, uiSlots, {
     orbitals,
     ...onNavigate !== void 0 ? { navigate: onNavigate } : {},
     ...onNavigateBack !== void 0 ? { navigateBack: onNavigateBack } : {},
@@ -1364,7 +1475,7 @@ function TraitInitializer({ traits, routeParams, mountKey, orbitals, onNavigate,
     ...mountKey !== void 0 ? { mountKey } : {},
     ...hasBridge ? { transport: bridge.transport, carriesCircuitState: bridge.carriesCircuitState, awaitTopology: !bridge.topologyKnown } : { persistence }
   });
-  return /* @__PURE__ */ jsx(EntityBindingContext.Provider, { value: entityBindingSource, children });
+  return /* @__PURE__ */ jsx(EntityBindingContext.Provider, { value: entityBindingSource, children: /* @__PURE__ */ jsx(AwaitingSkeletonContext.Provider, { value: awaitingSkeletonSource, children }) });
 }
 var CONTENT_STAGE_WIDTH = 480;
 function FitToBox({ children, mode = "box" }) {